4

src/ActionFailureException.java

@@ -0,0 +1,66 @@
+/*
+ * 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.
+ */
+/*
+ * Description：支持小米便签运行过程中的运行异常处理。
+ */
+
+/**
+  * @ProjectName:    MiNote
+  * @Package:        net.micode.notes.gtask.exception
+  * @ClassName:      ActionFailureException
+  * @Description:继承自 RuntimeException，表示在执行某个操作时出现了失败的情况。该异常类可以用于在程序执行过程中抛出并捕获异常，以便进行错误处理。
+  * @Author:         cyh
+ */
+
+
+
+package net.micode.notes.gtask.exception;
+
+public class ActionFailureException extends RuntimeException {
+    private static final long serialVersionUID = 4425249765923293627L;//serialVersionUID相当于java类的身份证。主要用于版本控制。
+
+    /**
+      * @功能名： ActionFailureException()
+      * @功能描述： ActionFailureException 异常类的无参构造
+      * @实现过程：该方法调用了父类 RuntimeException 的无参构造方法，用于创建一个没有详细信息的异常对象
+      * @Author:cyh
+     */
+    public ActionFailureException() {
+        super();
+    }
+
+    /**
+      * @功能名：ActionFailureException(String paramString)
+      * @参数：String paramString
+      * @功能描述：ActionFailureException 异常类的带有字符串参数的构造
+      * @实现过程：调用了父类 RuntimeException 的带有字符串参数的构造方法，用于创建一个包含详细错误信息的异常对象。具体错误信息由参数 paramString 指定
+      * @Author:cyh
+     */
+    public ActionFailureException(String paramString) {
+        super(paramString);
+    }
+
+    /**
+      * @功能名：ActionFailureException(String paramString, Throwable paramThrowable)
+      * @参数：String paramString, Throwable paramThrowable
+      * @功能描述：ActionFailureException 异常类的带有字符串参数和可抛出对象参数的构造
+      * @实现过程：调用了父类 RuntimeException 的带有字符串参数和可抛出对象参数的构造方法，用于创建一个包含详细错误信息和可抛出对象的异常对象。具体错误信息由参数 paramString 指定，可抛出对象由参数 paramThrowable 指定。
+      * @Author:cyh
+     */
+    public ActionFailureException(String paramString, Throwable paramThrowable) {
+        super(paramString, paramThrowable);
+    }
+}

src/GTaskManager.java

@@ -0,0 +1,998 @@
+/*
+ * 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.
+ */
+
+/**
+  * @ProjectName:    MiNote
+  * @Package:        net.micode.notes.gtask.remote
+  * @ClassName:      GTaskManager
+  * @Description: 管理 Google 任务的同步操作。该类包含了一些内部状态和方法，用于处理本地数据与远程 Google 任务的同步。
+  * 这个类具有如下功能：
+  * 初始化 GTaskManager 实例。
+  * 获取 GTaskManager 的单例实例。
+  * 设置 Activity 上下文。
+  * 执行本地同步和远程同步操作。
+  * 初始化 GTaskList，将从 Google 获取的 JSON 数据转换为本地 TaskList。
+  * 处理本地内容同步操作，包括本地增加、删除和更新节点等操作。
+  * 更新远程 Meta 数据。
+  * 刷新本地同步 ID。
+  * 此外，代码中还包含了异常处理和日志记录，以及对线程取消标志的处理。
+  * @Author:         cyh
+ */
+
+
+
+package net.micode.notes.gtask.remote;
+
+import android.app.Activity;
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.util.Log;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.gtask.data.MetaData;
+import net.micode.notes.gtask.data.Node;
+import net.micode.notes.gtask.data.SqlNote;
+import net.micode.notes.gtask.data.Task;
+import net.micode.notes.gtask.data.TaskList;
+import net.micode.notes.gtask.exception.ActionFailureException;
+import net.micode.notes.gtask.exception.NetworkFailureException;
+import net.micode.notes.tool.DataUtils;
+import net.micode.notes.tool.GTaskStringUtils;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+
+
+public class GTaskManager {
+    private static final String TAG = GTaskManager.class.getSimpleName();
+
+    public static final int STATE_SUCCESS = 0;
+
+    public static final int STATE_NETWORK_ERROR = 1;
+
+    public static final int STATE_INTERNAL_ERROR = 2;
+
+    public static final int STATE_SYNC_IN_PROGRESS = 3;
+
+    public static final int STATE_SYNC_CANCELLED = 4;
+
+    private static GTaskManager mInstance = null;
+
+    private Activity mActivity;
+
+    private Context mContext;
+
+    private ContentResolver mContentResolver;
+
+    private boolean mSyncing;
+
+    private boolean mCancelled;
+
+    private HashMap<String, TaskList> mGTaskListHashMap;
+
+    private HashMap<String, Node> mGTaskHashMap;
+
+    private HashMap<String, MetaData> mMetaHashMap;
+
+    private TaskList mMetaList;
+
+    private HashSet<Long> mLocalDeleteIdMap;
+
+    private HashMap<String, Long> mGidToNid;
+
+    private HashMap<Long, String> mNidToGid;
+
+
+    /**
+      * @功能名：GTaskManager()
+      * @功能描述： GTaskManager 类的构造函数。
+      * @实现过程：在对象初始化时，会进行一些初始设置和数据结构的初始化。
+      * @Author:cyh
+     */
+    private GTaskManager() {        //对象初始化函数
+        mSyncing = false;           //正在同步,flase代表未执行
+        mCancelled = false;         //全局标识，flase代表可以执行
+        mGTaskListHashMap = new HashMap<String, TaskList>();    //<>代表Java的泛型,就是创建一个用类型作为参数的类。
+        mGTaskHashMap = new HashMap<String, Node>();
+        mMetaHashMap = new HashMap<String, MetaData>();
+        mMetaList = null;
+        mLocalDeleteIdMap = new HashSet<Long>();
+        mGidToNid = new HashMap<String, Long>();
+        mNidToGid = new HashMap<Long, String>();    //通过hashmap散列表建立映射
+    }
+
+
+    /**
+      * @功能名：GTaskManager getInstance()
+      * @功能描述：GTaskManager 类的静态方法 getInstance()。它用于获取 GTaskManager 的单例实例
+      * @实现过程：首先判断 mInstance 是否为 null，如果为 null，则说明还没有创建 GTaskManager 实例。如果 mInstance 为 null，则通过调用私有构造函数 new GTaskManager() 创建一个新的 GTaskManager 实例。将新创建的实例赋值给 mInstance。最后返回 mInstance，即返回 GTaskManager 的单例实例。
+      * @Author:cyh
+     */
+    public static synchronized GTaskManager getInstance() {     //可能运行在多线程环境下，使用语言级同步--synchronized
+        if (mInstance == null) {
+            mInstance = new GTaskManager();
+        }
+        return mInstance;
+    }
+
+
+    /**
+      * @功能名：setActivityContext(Activity activity)
+      * @参数：Activity activity
+      * @功能描述：接受一个 Activity 类型的参数，用于设置当前 Activity 的上下文
+      * @实现过程：将传入的 activity 赋值给成员变量 mActivity。
+      * @Author:cyh
+     */
+    public synchronized void setActivityContext(Activity activity) {
+        // used for getting authtoken
+        mActivity = activity;
+    }
+
+    /**
+      * @功能名：sync(Context context, GTaskASyncTask asyncTask)
+      * @参数：Context context, GTaskASyncTask asyncTask
+      * @功能描述：执行任务同步操作。
+      * @实现过程：
+      * 首先检查 mSyncing 标志位，如果为 true，则说明当前正在进行同步操作，直接返回 STATE_SYNC_IN_PROGRESS 状态。
+      * 将传入的 context 参数赋值给成员变量 mContext，并获取 ContentResolver 对象。
+      * 设置 mSyncing 标志位为 true，表示同步操作开始。
+      * 清空相关数据结构（如哈希表、映射等），以便重新初始化。
+      * 通过调用 GTaskClient.getInstance() 获取 GTaskClient 的单例实例，并重置更新数组。
+      * 如果未取消同步操作，进行 Google 账号的登录认证，如果登录失败则抛出 NetworkFailureException 异常。
+      * 将 Google 上获取任务列表并转换为本地的 TaskList。
+      * 执行内容同步操作。
+      * 如果捕获到 NetworkFailureException 异常，则记录错误日志并返回 STATE_NETWORK_ERROR 状态。
+      * 如果捕获到 ActionFailureException 异常，则记录错误日志并返回 STATE_INTERNAL_ERROR 状态。
+      * 如果捕获到其他异常，则记录错误日志并返回 STATE_INTERNAL_ERROR 状态。
+      * 最后，在 finally 块中清空相关数据结构，并将 mSyncing 标志位设置为 false，表示同步操作结束。
+      * 返回同步状态，如果取消了同步操作，则返回 STATE_SYNC_CANCELLED 状态，否则返回 STATE_SUCCESS 状态。
+      * @Author:cyh
+     */
+    public int sync(Context context, GTaskASyncTask asyncTask) {    //核心函数
+        if (mSyncing) {
+            Log.d(TAG, "Sync is in progress");       //创建日志文件（调试信息），debug
+            return STATE_SYNC_IN_PROGRESS;
+        }
+        mContext = context;
+        mContentResolver = mContext.getContentResolver();
+        mSyncing = true;
+        mCancelled = false;
+        mGTaskListHashMap.clear();
+        mGTaskHashMap.clear();
+        mMetaHashMap.clear();
+        mLocalDeleteIdMap.clear();
+        mGidToNid.clear();
+        mNidToGid.clear();
+
+        try {
+            GTaskClient client = GTaskClient.getInstance();  //getInstance即为创建一个实例,client--客户机
+            client.resetUpdateArray();
+
+            // login google task
+            if (!mCancelled) {
+                if (!client.login(mActivity)) {
+                    throw new NetworkFailureException("login google task failed");
+                }
+            }
+
+            // get the task list from google
+            asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list));
+            initGTaskList();     //获取Google上的JSONtasklist转为本地TaskList
+
+            // do content sync work
+            asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing));
+            syncContent();
+        } catch (NetworkFailureException e) {   //分为两种异常，此类异常为网络异常
+            Log.e(TAG, e.toString());   //创建日志文件（调试信息），error
+            return STATE_NETWORK_ERROR;
+        } catch (ActionFailureException e) {    //此类异常为操作异常
+            Log.e(TAG, e.toString());
+            return STATE_INTERNAL_ERROR;
+        } catch (Exception e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            return STATE_INTERNAL_ERROR;
+        } finally {
+            mGTaskListHashMap.clear();
+            mGTaskHashMap.clear();
+            mMetaHashMap.clear();
+            mLocalDeleteIdMap.clear();
+            mGidToNid.clear();
+            mNidToGid.clear();
+            mSyncing = false;
+        }
+
+        return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS;
+    }
+
+
+
+    /**
+      * @功能名：initGTaskList()
+      * @功能描述：初始化GTask列表的方法。通过与GTask服务器进行通信，获取任务列表和任务数据，并将其存储在相应的数据结构中。
+      * @实现过程：
+      *首先，代码从GTaskClient实例中获取任务列表的JSON对象数组。然后，它遍历这个数组，逐个解析每个JSON对象。对于元表（名字以特定前缀开头），代码创建一个TaskList对象，并将其内容从远程JSON对象复制到该对象中。然后，它获取该元表下的任务列表的JSON对象数组，并遍历这个数组。对于每个任务，代码创建一个MetaData对象，并将其内容从远程JSON对象复制到该对象中。如果该任务值得保存（由isWorthSaving()方法决定），则将其添加到元表的子任务列表中，并将其相关的gid作为键，将MetaData对象添加到mMetaHashMap中。
+      * 如果元表不存在，则代码创建一个新的元表，并使用GTaskClient实例的createTaskList方法将其发送到服务器。
+      * 接下来，代码再次遍历任务列表的JSON对象数组。对于以特定前缀开头但不是元表的任务列表，代码创建一个TaskList对象，并将其内容从远程JSON对象复制到该对象中。然后，它获取该任务列表下的任务的JSON对象数组，并遍历这个数组。对于每个任务，代码创建一个Task对象，并将其内容从远程JSON对象复制到该对象中。如果该任务值得保存，代码将其关联的元数据设置为mMetaHashMap中对应的对象，并将该任务添加到任务列表的子任务列表中，并使用gid作为键，将Task对象添加到mGTaskHashMap中。
+      * 最后，如果出现JSON解析异常，代码会打印错误信息并抛出ActionFailureException异常。
+      * @Author:cyh
+     */
+    private void initGTaskList() throws NetworkFailureException {
+        if (mCancelled)
+            return;
+        GTaskClient client = GTaskClient.getInstance();
+        try {
+            //Json对象是Name Value对(即子元素)的无序集合，相当于一个Map对象。JsonObject类是bantouyan-json库对Json对象的抽象，提供操纵Json对象的各种方法。
+            //其格式为{"key1":value1,"key2",value2....};key 必须是字符串。
+            //因为ajax请求不刷新页面，但配合js可以实现局部刷新，因此json常常被用来作为异步请求的返回对象使用。
+            JSONArray jsTaskLists = client.getTaskLists();
+
+            // init meta list first
+            mMetaList = null;       //TaskList类型
+            for (int i = 0; i < jsTaskLists.length(); i++) {
+                JSONObject object = jsTaskLists.getJSONObject(i);   //JSONObject与JSONArray一个为对象，一个为数组。此处取出单个JASONObject
+                String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
+                String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME);
+
+                if (name
+                        .equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) {
+                    mMetaList = new TaskList();      //MetaList意为元表,Tasklist类型，此处为初始化
+                    mMetaList.setContentByRemoteJSON(object);       //将JSON中部分数据复制到自己定义的对象中相对应的数据：name->mname...
+
+                    // load meta data
+                    JSONArray jsMetas = client.getTaskList(gid);
+                    for (int j = 0; j < jsMetas.length(); j++) {
+                        object = (JSONObject) jsMetas.getJSONObject(j);
+                        MetaData metaData = new MetaData();
+                        metaData.setContentByRemoteJSON(object);
+                        if (metaData.isWorthSaving()) {      //如果不值得保存，metadata将不加入mMetaList
+                            mMetaList.addChildTask(metaData);
+                            if (metaData.getGid() != null) {
+                                mMetaHashMap.put(metaData.getRelatedGid(), metaData);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // create meta list if not existed
+            if (mMetaList == null) {
+                mMetaList = new TaskList();
+                mMetaList.setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX
+                        + GTaskStringUtils.FOLDER_META);
+                GTaskClient.getInstance().createTaskList(mMetaList);
+            }
+
+            // init task list
+            for (int i = 0; i < jsTaskLists.length(); i++) {
+                JSONObject object = jsTaskLists.getJSONObject(i);
+                String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);  //通过getString函数传入本地某个标志数据的名称，获取其在远端的名称。
+                String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME);
+
+                if (name.startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX)
+                        && !name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX
+                                + GTaskStringUtils.FOLDER_META)) {
+                    TaskList tasklist = new TaskList();     //继承自Node
+                    tasklist.setContentByRemoteJSON(object);
+                    mGTaskListHashMap.put(gid, tasklist);
+                    mGTaskHashMap.put(gid, tasklist);
+
+                    // load tasks
+                    JSONArray jsTasks = client.getTaskList(gid);
+                    for (int j = 0; j < jsTasks.length(); j++) {
+                        object = (JSONObject) jsTasks.getJSONObject(j);
+                        gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
+                        Task task = new Task();
+                        task.setContentByRemoteJSON(object);
+                        if (task.isWorthSaving()) {
+                            task.setMetaInfo(mMetaHashMap.get(gid));
+                            tasklist.addChildTask(task);
+                            mGTaskHashMap.put(gid, task);
+                        }
+                    }
+                }
+            }
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            throw new ActionFailureException("initGTaskList: handing JSONObject failed");
+        }
+    }
+
+    /**
+      * @功能名：syncContent()
+      * @功能描述：同步本地内容的方法。通过与GTask服务器进行通信，将本地数据库中的笔记和任务列表与服务器上的数据进行同步
+      * @实现过程：
+      * 首先，代码清空了mLocalDeleteIdMap，这是一个用于存储已删除的笔记ID的HashSet。
+      * 接下来，代码查询本地数据库中的已删除笔记，并遍历结果集。对于每个已删除笔记，代码从mGTaskHashMap中根据gid获取对应的Node对象。如果存在该Node对象，说明该笔记在服务器上也存在，需要进行远程删除操作。代码将该Node对象从mGTaskHashMap中移除，并调用doContentSync方法执行同步操作。同时，将该笔记的ID添加到mLocalDeleteIdMap中。
+      * 然后，代码调用syncFolder方法同步文件夹信息。
+      * 接下来，代码查询本地数据库中的已存在的笔记，并遍历结果集。对于每个已存在的笔记，代码从mGTaskHashMap中根据gid获取对应的Node对象。如果存在该Node对象，说明该笔记在服务器上也存在，需要根据Node对象的同步状态执行相应的同步操作。如果不存在该Node对象，说明该笔记在服务器上不存在，需要执行本地添加操作或远程删除操作。
+      * 最后，代码使用Iterator迭代器遍历mGTaskHashMap中剩余的未处理的Node对象，并执行本地添加操作。
+      * 在整个同步过程中，代码会检查mCancelled变量是否被设置为true，如果是，则立即返回并结束同步过程。
+      * 最后，代码会清空已删除的本地笔记，并更新本地同步ID，以及提交更新到GTask服务器。
+      * @Author:cyh
+     */
+    private void syncContent() throws NetworkFailureException {     //本地内容同步操作
+        int syncType;
+        Cursor c = null;         //数据库指针
+        String gid;
+        Node node;       //Node包含Sync_Action的不同类型
+
+        mLocalDeleteIdMap.clear();       //HashSet<Long>类型
+
+        if (mCancelled) {
+            return;
+        }
+
+        // for local deleted note
+        try {
+            c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
+                    "(type<>? AND parent_id=?)", new String[] {
+                            String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLER)
+                    }, null);
+            if (c != null) {
+                while (c.moveToNext()) {
+                    gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+                    node = mGTaskHashMap.get(gid);
+                    if (node != null) {
+                        mGTaskHashMap.remove(gid);
+                        doContentSync(Node.SYNC_ACTION_DEL_REMOTE, node, c);
+                    }
+
+                    mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN));
+                }
+            } else {
+                Log.w(TAG, "failed to query trash folder");
+            }
+        } finally {
+            if (c != null) {
+                c.close();
+                c = null;
+            }
+        }
+
+        // sync folder first
+        syncFolder();
+
+        // for note existing in database
+        try {
+            c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
+                    "(type=? AND parent_id<>?)", new String[] {
+                            String.valueOf(Notes.TYPE_NOTE), String.valueOf(Notes.ID_TRASH_FOLER)
+                    }, NoteColumns.TYPE + " DESC");
+            if (c != null) {
+                while (c.moveToNext()) {
+                    gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+                    node = mGTaskHashMap.get(gid);
+                    if (node != null) {
+                        mGTaskHashMap.remove(gid);
+                        mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN));    //通过hashmap建立联系
+                        mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid);        //通过hashmap建立联系
+                        syncType = node.getSyncAction(c);
+                    } else {
+                        if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
+                            // local add
+                            syncType = Node.SYNC_ACTION_ADD_REMOTE;
+                        } else {
+                            // remote delete
+                            syncType = Node.SYNC_ACTION_DEL_LOCAL;
+                        }
+                    }
+                    doContentSync(syncType, node, c);
+                }
+            } else {
+                Log.w(TAG, "failed to query existing note in database");
+            }
+
+        } finally {
+            if (c != null) {
+                c.close();
+                c = null;
+            }
+        }
+
+        // go through remaining items
+        Iterator<Map.Entry<String, Node>> iter = mGTaskHashMap.entrySet().iterator();   //Iterator迭代器
+        while (iter.hasNext()) {
+            Map.Entry<String, Node> entry = iter.next();
+            node = entry.getValue();
+            doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null);
+        }
+
+        // mCancelled can be set by another thread, so we neet to check one by   //thread----线程
+        // one
+        // clear local delete table
+        if (!mCancelled) {
+            if (!DataUtils.batchDeleteNotes(mContentResolver, mLocalDeleteIdMap)) {
+                throw new ActionFailureException("failed to batch-delete local deleted notes");
+            }
+        }
+
+        // refresh local sync id
+        if (!mCancelled) {
+            GTaskClient.getInstance().commitUpdate();
+            refreshLocalSyncId();
+        }
+
+    }
+
+    /**
+      * @功能名：syncFolder()
+      * @功能描述：同步文件夹
+      * @实现过程：首先，查询root folder和 call-note folder 对应的 GTask 节点（通过 GTask ID），分别进行同步操作，如果节点不存在则添加节点到 GTask，并更新 ContentProvider 中对应的值；如果节点存在则根据需要更新远程名称或者不做任何操作。接着，查询本地存在的文件夹，根据节点是否存在进行不同类型的同步操作，同步操作包括：添加、删除、更新本地或远程节点。最后，遍历所有在 GTask 中出现但未被同步的节点，将它们添加到 ContentProvider 中。
+      * @Author:cyh
+     */
+
+    private void syncFolder() throws NetworkFailureException {
+        Cursor c = null;
+        String gid;
+        Node node;
+        int syncType;
+
+        if (mCancelled) {
+            return;
+        }
+
+        // for root folder
+        try {
+            c = mContentResolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,
+                    Notes.ID_ROOT_FOLDER), SqlNote.PROJECTION_NOTE, null, null, null);
+            if (c != null) {
+                c.moveToNext();
+                gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+                node = mGTaskHashMap.get(gid);
+                if (node != null) {
+                    mGTaskHashMap.remove(gid);
+                    mGidToNid.put(gid, (long) Notes.ID_ROOT_FOLDER);
+                    mNidToGid.put((long) Notes.ID_ROOT_FOLDER, gid);
+                    // for system folder, only update remote name if necessary
+                    if (!node.getName().equals(
+                            GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT))
+                        doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c);
+                } else {
+                    doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c);
+                }
+            } else {
+                Log.w(TAG, "failed to query root folder");
+            }
+        } finally {
+            if (c != null) {
+                c.close();
+                c = null;
+            }
+        }
+
+        // for call-note folder
+        try {
+            c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(_id=?)",
+                    new String[] {
+                        String.valueOf(Notes.ID_CALL_RECORD_FOLDER)
+                    }, null);
+            if (c != null) {
+                if (c.moveToNext()) {
+                    gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+                    node = mGTaskHashMap.get(gid);
+                    if (node != null) {
+                        mGTaskHashMap.remove(gid);
+                        mGidToNid.put(gid, (long) Notes.ID_CALL_RECORD_FOLDER);
+                        mNidToGid.put((long) Notes.ID_CALL_RECORD_FOLDER, gid);
+                        // for system folder, only update remote name if
+                        // necessary
+                        if (!node.getName().equals(
+                                GTaskStringUtils.MIUI_FOLDER_PREFFIX
+                                        + GTaskStringUtils.FOLDER_CALL_NOTE))
+                            doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c);
+                    } else {
+                        doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c);
+                    }
+                }
+            } else {
+                Log.w(TAG, "failed to query call note folder");
+            }
+        } finally {
+            if (c != null) {
+                c.close();
+                c = null;
+            }
+        }
+
+        // for local existing folders
+        try {
+            c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
+                    "(type=? AND parent_id<>?)", new String[] {
+                            String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER)
+                    }, NoteColumns.TYPE + " DESC");
+            if (c != null) {
+                while (c.moveToNext()) {
+                    gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+                    node = mGTaskHashMap.get(gid);
+                    if (node != null) {
+                        mGTaskHashMap.remove(gid);
+                        mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN));
+                        mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid);
+                        syncType = node.getSyncAction(c);
+                    } else {
+                        if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
+                            // local add
+                            syncType = Node.SYNC_ACTION_ADD_REMOTE;
+                        } else {
+                            // remote delete
+                            syncType = Node.SYNC_ACTION_DEL_LOCAL;
+                        }
+                    }
+                    doContentSync(syncType, node, c);
+                }
+            } else {
+                Log.w(TAG, "failed to query existing folder");
+            }
+        } finally {
+            if (c != null) {
+                c.close();
+                c = null;
+            }
+        }
+
+        // for remote add folders
+        Iterator<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator();
+        while (iter.hasNext()) {
+            Map.Entry<String, TaskList> entry = iter.next();
+            gid = entry.getKey();
+            node = entry.getValue();
+            if (mGTaskHashMap.containsKey(gid)) {
+                mGTaskHashMap.remove(gid);
+                doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null);
+            }
+        }
+
+        if (!mCancelled)
+            GTaskClient.getInstance().commitUpdate();
+    }
+
+
+    /**
+      * @功能名：doContentSync(int syncType, Node node, Cursor c)
+      * @参数：int syncType, Node node, Cursor c
+      * @功能描述：内容同步
+      * @实现过程：在执行同步操作之前，需要判断是否已经取消同步（mCancelled），如果已经取消同步，则直接返回。在添加、删除、更新节点时，需要同时更新 GTask 和 ContentProvider 中的数据，确保两者的数据一致性。此处还涉及到了 MetaData 和 mMetaHashMap，用于保存所有节点在 GTask 中对应的元数据信息。
+      * @Author:cyh
+     */
+    private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException {
+        if (mCancelled) {
+            return;
+        }
+
+        MetaData meta;
+        switch (syncType) {
+            case Node.SYNC_ACTION_ADD_LOCAL:
+                addLocalNode(node);
+                break;
+            case Node.SYNC_ACTION_ADD_REMOTE:
+                addRemoteNode(node, c);
+                break;
+            case Node.SYNC_ACTION_DEL_LOCAL:
+                meta = mMetaHashMap.get(c.getString(SqlNote.GTASK_ID_COLUMN));
+                if (meta != null) {
+                    GTaskClient.getInstance().deleteNode(meta);
+                }
+                mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN));
+                break;
+            case Node.SYNC_ACTION_DEL_REMOTE:
+                meta = mMetaHashMap.get(node.getGid());
+                if (meta != null) {
+                    GTaskClient.getInstance().deleteNode(meta);
+                }
+                GTaskClient.getInstance().deleteNode(node);
+                break;
+            case Node.SYNC_ACTION_UPDATE_LOCAL:
+                updateLocalNode(node, c);
+                break;
+            case Node.SYNC_ACTION_UPDATE_REMOTE:
+                updateRemoteNode(node, c);
+                break;
+            case Node.SYNC_ACTION_UPDATE_CONFLICT:
+                // merging both modifications maybe a good idea
+                // right now just use local update simply
+                updateRemoteNode(node, c);
+                break;
+            case Node.SYNC_ACTION_NONE:
+                break;
+            case Node.SYNC_ACTION_ERROR:
+            default:
+                throw new ActionFailureException("unkown sync action type");
+        }
+    }
+
+    /**
+      * @功能名：addLocalNode(Node node)
+      * @参数：Node node
+      * @功能描述：本地Node添加到 GTask 中
+      * @实现过程：
+      * 首先判断是否已经取消同步（mCancelled），如果已经取消同步，则直接返回。
+      * 根据节点类型的不同，分别创建 SqlNote，并将节点的内容设置到 SqlNote 中。
+      * 如果节点是 TaskList 类型，则需要判断节点的名称，并根据名称来设置 SqlNote 的内容。如果节点名称为默认文件夹，则创建一个根目录 SqlNote；如果节点名称为通话记录文件夹，则创建一个通话记录文件夹 SqlNote；否则创建一个普通 SqlNote，并将其内容设置为节点的本地 JSON 数据。
+      * 如果节点不是 TaskList 类型，则创建一个普通 SqlNote，并将其内容设置为节点的本地 JSON 数据。同时，还需要设置该 SqlNote 的 parentId，即节点的父节点在本地 ContentProvider 中对应的 Id。
+      * 设置 SqlNote 的 GTaskId 为节点的 Gid，并将该 SqlNote 提交到本地 ContentProvider 中，创建一个本地节点。
+      * 更新 mGidToNid 和 mNidToGid，用于保存 GTask 中的 Gid 和本地 ContentProvider 中的 Id 之间的映射关系。
+      * 最后，通过 updateRemoteMeta 方法，将该节点的元数据保存到 MetaData 中，确保 GTask 和本地 ContentProvider 中的节点信息一致。
+      * @Author:cyh
+     */
+    private void addLocalNode(Node node) throws NetworkFailureException {
+        if (mCancelled) {
+            return;
+        }
+
+        SqlNote sqlNote;
+        if (node instanceof TaskList) {
+            if (node.getName().equals(
+                    GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) {
+                sqlNote = new SqlNote(mContext, Notes.ID_ROOT_FOLDER);
+            } else if (node.getName().equals(
+                    GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE)) {
+                sqlNote = new SqlNote(mContext, Notes.ID_CALL_RECORD_FOLDER);
+            } else {
+                sqlNote = new SqlNote(mContext);
+                sqlNote.setContent(node.getLocalJSONFromContent());
+                sqlNote.setParentId(Notes.ID_ROOT_FOLDER);
+            }
+        } else {
+            sqlNote = new SqlNote(mContext);
+            JSONObject js = node.getLocalJSONFromContent();
+            try {
+                if (js.has(GTaskStringUtils.META_HEAD_NOTE)) {
+                    JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+                    if (note.has(NoteColumns.ID)) {
+                        long id = note.getLong(NoteColumns.ID);
+                        if (DataUtils.existInNoteDatabase(mContentResolver, id)) {
+                            // the id is not available, have to create a new one
+                            note.remove(NoteColumns.ID);
+                        }
+                    }
+                }
+
+                if (js.has(GTaskStringUtils.META_HEAD_DATA)) {
+                    JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
+                    for (int i = 0; i < dataArray.length(); i++) {
+                        JSONObject data = dataArray.getJSONObject(i);
+                        if (data.has(DataColumns.ID)) {
+                            long dataId = data.getLong(DataColumns.ID);
+                            if (DataUtils.existInDataDatabase(mContentResolver, dataId)) {
+                                // the data id is not available, have to create
+                                // a new one
+                                data.remove(DataColumns.ID);
+                            }
+                        }
+                    }
+
+                }
+            } catch (JSONException e) {
+                Log.w(TAG, e.toString());
+                e.printStackTrace();
+            }
+            sqlNote.setContent(js);
+
+            Long parentId = mGidToNid.get(((Task) node).getParent().getGid());
+            if (parentId == null) {
+                Log.e(TAG, "cannot find task's parent id locally");
+                throw new ActionFailureException("cannot add local node");
+            }
+            sqlNote.setParentId(parentId.longValue());
+        }
+
+        // create the local node
+        sqlNote.setGtaskId(node.getGid());
+        sqlNote.commit(false);
+
+        // update gid-nid mapping
+        mGidToNid.put(node.getGid(), sqlNote.getId());
+        mNidToGid.put(sqlNote.getId(), node.getGid());
+
+        // update meta
+        updateRemoteMeta(node.getGid(), sqlNote);
+    }
+
+
+    /**
+      * @功能名：updateLocalNode(Node node, Cursor c)
+      * @参数：Node node, Cursor c
+      * @功能描述：将 GTask 中的节点信息更新到本地 ContentProvider 中。
+      * @实现过程：
+      * 首先判断是否已经取消同步（mCancelled），如果已经取消同步，则直接返回。
+      * 根据 Cursor c 创建 SqlNote，表示需要更新的本地节点。
+      * 将节点的本地 JSON 数据设置到 SqlNote 中，并根据节点类型的不同，设置 SqlNote 的 parentId。如果节点是 Task 类型，则根据节点的父节点在 GTask 中对应的 Gid 从 mGidToNid 中查找该节点在本地 ContentProvider 中对应的 Id，并设置为 SqlNote 的 parentId；否则，设置 parentId 为根目录的 Id。
+      * 将 SqlNote 提交到本地 ContentProvider 中，完成节点的更新操作。
+      * 最后，通过 updateRemoteMeta 方法，将该节点的元数据保存到 MetaData 中，确保 GTask 和本地 ContentProvider 中的节点信息一致。
+      * @Author:cyh
+     */
+    private void updateLocalNode(Node node, Cursor c) throws NetworkFailureException {
+        if (mCancelled) {
+            return;
+        }
+
+        SqlNote sqlNote;
+        // update the note locally
+        sqlNote = new SqlNote(mContext, c);
+        sqlNote.setContent(node.getLocalJSONFromContent());
+
+        Long parentId = (node instanceof Task) ? mGidToNid.get(((Task) node).getParent().getGid())
+                : new Long(Notes.ID_ROOT_FOLDER);
+        if (parentId == null) {
+            Log.e(TAG, "cannot find task's parent id locally");
+            throw new ActionFailureException("cannot update local node");
+        }
+        sqlNote.setParentId(parentId.longValue());
+        sqlNote.commit(true);
+
+        // update meta info
+        updateRemoteMeta(node.getGid(), sqlNote);
+    }
+
+    /**
+      * @功能名：addRemoteNode(Node node, Cursor c)
+      * @参数：Node node, Cursor c
+      * @功能描述：将本地的节点信息添加到远程服务器中。
+      * @实现过程：
+      * 首先判断是否已经取消同步（mCancelled），如果已经取消同步，则直接返回。
+      * 根据 Cursor c 创建 SqlNote，并根据该节点的类型进行不同的处理。
+      * 如果 SqlNote 是一个 Note 类型，表示需要添加的是一个笔记节点。首先根据 SqlNote 的内容创建一个 Task 对象，并将该 Task 对象添加到对应父节点在 GTask 中的子节点列表中。然后，使用 GTaskClient 实例的 createTask 方法，在远程服务器上创建该 Task。最后，通过 updateRemoteMeta 方法，将该节点的元数据保存到 MetaData 中。
+      * 如果 SqlNote 不是一个 Note 类型，表示需要添加的是一个文件夹节点。根据 SqlNote 的 id 判断该文件夹节点的类型，并拼接出文件夹的名称。然后，遍历 mGTaskListHashMap，查找是否存在名称与之匹配的文件夹节点，如果存在，则将 tasklist 设置为对应的 TaskList 对象，并删除 mGTaskHashMap 中对应的节点。如果不存在匹配的文件夹节点，则创建一个新的 TaskList 对象，并使用 GTaskClient 实例的 createTaskList 方法，在远程服务器上创建该 TaskList。
+      * 将节点的远程 Gid 更新到 SqlNote 中，并提交到本地 ContentProvider 中。同时更新 gid-id 和 id-gid 的映射关系。
+      * @Author:cyh
+     */
+    private void addRemoteNode(Node node, Cursor c) throws NetworkFailureException {
+        if (mCancelled) {
+            return;
+        }
+
+        SqlNote sqlNote = new SqlNote(mContext, c);  //从本地mContext中获取内容
+        Node n;
+
+        // update remotely
+        if (sqlNote.isNoteType()) {
+            Task task = new Task();
+            task.setContentByLocalJSON(sqlNote.getContent());
+
+            String parentGid = mNidToGid.get(sqlNote.getParentId());
+            if (parentGid == null) {
+                Log.e(TAG, "cannot find task's parent tasklist");  //调试信息
+                throw new ActionFailureException("cannot add remote task");
+            }
+            mGTaskListHashMap.get(parentGid).addChildTask(task);   //在本地生成的GTaskList中增加子结点
+
+            //登录远程服务器，创建Task
+            GTaskClient.getInstance().createTask(task);
+            n = (Node) task;
+
+            // add meta
+            updateRemoteMeta(task.getGid(), sqlNote);
+        } else {
+            TaskList tasklist = null;
+
+            // we need to skip folder if it has already existed
+            String folderName = GTaskStringUtils.MIUI_FOLDER_PREFFIX;
+            if (sqlNote.getId() == Notes.ID_ROOT_FOLDER)
+                folderName += GTaskStringUtils.FOLDER_DEFAULT;
+            else if (sqlNote.getId() == Notes.ID_CALL_RECORD_FOLDER)
+                folderName += GTaskStringUtils.FOLDER_CALL_NOTE;
+            else
+                folderName += sqlNote.getSnippet();
+
+            //iterator迭代器，通过统一的接口迭代所有的map元素
+            Iterator<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator();
+            while (iter.hasNext()) {
+                Map.Entry<String, TaskList> entry = iter.next();
+                String gid = entry.getKey();
+                TaskList list = entry.getValue();
+
+                if (list.getName().equals(folderName)) {
+                    tasklist = list;
+                    if (mGTaskHashMap.containsKey(gid)) {
+                        mGTaskHashMap.remove(gid);
+                    }
+                    break;
+                }
+            }
+
+            // no match we can add now
+            if (tasklist == null) {
+                tasklist = new TaskList();
+                tasklist.setContentByLocalJSON(sqlNote.getContent());
+                GTaskClient.getInstance().createTaskList(tasklist);
+                mGTaskListHashMap.put(tasklist.getGid(), tasklist);
+            }
+            n = (Node) tasklist;
+        }
+
+        // update local note
+        sqlNote.setGtaskId(n.getGid());
+        sqlNote.commit(false);
+        sqlNote.resetLocalModified();
+        sqlNote.commit(true);
+
+        // gid-id mapping   //创建id间的映射
+        mGidToNid.put(n.getGid(), sqlNote.getId());
+        mNidToGid.put(sqlNote.getId(), n.getGid());
+    }
+
+
+    /**
+      * @功能名：updateRemoteNode(Node node, Cursor c)
+      * @参数：Node node, Cursor c
+      * @功能描述：更新远程服务器上的节点信息。
+      * @实现过程：
+      * 首先判断是否已经取消同步（mCancelled），如果已经取消同步，则直接返回。
+      * 根据 Cursor c 创建 SqlNote，并将其内容更新到节点对象 node 中。然后，使用 GTaskClient 实例的 addUpdateNode 方法，将更新后的节点信息同步到远程服务器。
+      * 通过 updateRemoteMeta 方法，更新节点的元数据。
+      * 接下来，判断节点的类型是否为笔记（Note）。如果是笔记节点，获取该节点的父节点列表 preParentList，并根据 sqlNote 的 parentId 找到对应的父节点的 Gid curParentGid。如果 curParentGid 为 null，则抛出异常。然后，根据 curParentGid 在 mGTaskListHashMap 中找到对应的 TaskList 对象 curParentList。
+      * 如果 preParentList 和 curParentList 不相同，表示需要将节点移动到新的父节点列表中。首先从 preParentList 中移除该节点，然后将节点添加到 curParentList 中，并使用 GTaskClient 实例的 moveTask 方法，在远程服务器上移动该任务。
+      * @Author:cyh
+     */
+    private void updateRemoteNode(Node node, Cursor c) throws NetworkFailureException {
+        if (mCancelled) {
+            return;
+        }
+
+        SqlNote sqlNote = new SqlNote(mContext, c);
+
+        // update remotely
+        node.setContentByLocalJSON(sqlNote.getContent());
+        GTaskClient.getInstance().addUpdateNode(node);//GTaskClient用途为从本地登陆远端服务器
+
+        // update meta
+        updateRemoteMeta(node.getGid(), sqlNote);
+
+        // move task if necessary
+        if (sqlNote.isNoteType()) {
+            Task task = (Task) node;
+            TaskList preParentList = task.getParent();
+            //preParentList为通过node获取的父节点列表
+            String curParentGid = mNidToGid.get(sqlNote.getParentId());
+            //curParentGid为通过光标在数据库中找到sqlNote的mParentId，再通过mNidToGid由long类型转为String类型的Gid
+            if (curParentGid == null) {
+                Log.e(TAG, "cannot find task's parent tasklist");
+                throw new ActionFailureException("cannot update remote task");
+            }
+            TaskList curParentList = mGTaskListHashMap.get(curParentGid);
+            //通过HashMap找到对应Gid的TaskList
+            if (preParentList != curParentList) {
+                preParentList.removeChildTask(task);
+                curParentList.addChildTask(task);
+                GTaskClient.getInstance().moveTask(task, preParentList, curParentList);
+            }
+        }
+
+        // clear local modified flag
+        sqlNote.resetLocalModified();
+        //commit到本地数据库
+        sqlNote.commit(true);
+    }
+
+    /**
+      * @功能名：updateRemoteMeta(String gid, SqlNote sqlNote)
+      * @参数：String gid, SqlNote sqlNote
+      * @功能描述：更新远程服务器上节点的元数据信息。
+      * @实现过程：
+      * 首先，判断参数 sqlNote 是否为笔记类型（isNoteType），并且不为 null。然后，根据参数 gid 从 mMetaHashMap 中获取对应的元数据对象 metaData。
+      * 如果 metaData 不为 null，则更新其内容为 sqlNote 的内容，并使用 GTaskClient 实例的 addUpdateNode 方法将更新后的元数据同步到远程服务器。
+      * 如果 metaData 为 null，则创建一个新的 MetaData 对象，并设置其内容为 sqlNote 的内容。接着，将新创建的 metaData 添加到 mMetaList 中，同时将其放入 mMetaHashMap 中进行管理，最后使用 GTaskClient 实例的 createTask 方法，在远程服务器上创建该元数据节点。
+      * @Author:cyh
+     */
+    private void updateRemoteMeta(String gid, SqlNote sqlNote) throws NetworkFailureException {
+        if (sqlNote != null && sqlNote.isNoteType()) {
+            MetaData metaData = mMetaHashMap.get(gid);
+            if (metaData != null) {
+                metaData.setMeta(gid, sqlNote.getContent());
+                GTaskClient.getInstance().addUpdateNode(metaData);
+            } else {
+                metaData = new MetaData();
+                metaData.setMeta(gid, sqlNote.getContent());
+                mMetaList.addChildTask(metaData);
+                mMetaHashMap.put(gid, metaData);
+                GTaskClient.getInstance().createTask(metaData);
+            }
+        }
+    }
+
+    /**
+      * @功能名：refreshLocalSyncId()
+      * @功能描述：刷新本地节点的同步ID
+      * @实现过程：
+      * 首先，判断是否已经取消同步（mCancelled），如果已经取消同步，则直接返回。
+      * 接着，清空 mGTaskHashMap、mGTaskListHashMap 和 mMetaHashMap，然后初始化 GTaskList。
+      * 接下来，使用 ContentResolver 的 query 方法查询本地笔记数据，通过 Notes.CONTENT_NOTE_URI 和 SqlNote.PROJECTION_NOTE 获取到需要更新的笔记列表。
+      * 如果查询结果不为 null，则遍历查询结果。对于每个查询结果，获取其对应的 gid，并从 mGTaskHashMap 中获取到对应的节点对象 node。
+      * 如果 node 不为 null，表示该节点在远程服务器上存在，需要更新同步ID。首先从 mGTaskHashMap 中移除该节点。然后，创建一个 ContentValues 对象 values，并将需要更新的同步ID存入其中。
+      * 接着，使用 ContentResolver 的 update 方法，通过 ContentUris.withAppendedId 将更新的内容应用到对应的本地笔记记录上。
+      * 如果 node 为 null，表示该本地笔记在远程服务器上没有对应的节点，抛出 ActionFailureException 异常。
+      * 最后，在 finally 块中关闭游标 c。
+      * @Author:cyh
+     */
+    private void refreshLocalSyncId() throws NetworkFailureException {
+        if (mCancelled) {
+            return;
+        }
+
+        // get the latest gtask list      //获取最近的（最晚的）gtask list
+        mGTaskHashMap.clear();
+        mGTaskListHashMap.clear();
+        mMetaHashMap.clear();
+        initGTaskList();
+
+        Cursor c = null;
+        try {
+            c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
+                    "(type<>? AND parent_id<>?)", new String[] {
+                            String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLER)
+                    }, NoteColumns.TYPE + " DESC");     //query语句：五个参数，NoteColumns.TYPE + " DESC"-----为按类型递减顺序返回查询结果。new String[] {String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLER)}------为选择参数。"(type<>? AND parent_id<>?)"-------指明返回行过滤器。SqlNote.PROJECTION_NOTE--------应返回的数据列的名字。Notes.CONTENT_NOTE_URI--------contentProvider包含所有数据集所对应的uri
+            if (c != null) {
+                while (c.moveToNext()) {
+                    String gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+                    Node node = mGTaskHashMap.get(gid);
+                    if (node != null) {
+                        mGTaskHashMap.remove(gid);
+                        ContentValues values = new ContentValues();     //在ContentValues中创建键值对。准备通过contentResolver写入数据
+                        values.put(NoteColumns.SYNC_ID, node.getLastModified());
+                        mContentResolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,       //进行批量更改，选择参数为NULL，应该可以用insert替换，参数分别为表名和需要更新的value对象。
+                                c.getLong(SqlNote.ID_COLUMN)), values, null, null);
+                    } else {
+                        Log.e(TAG, "something is missed");
+                        throw new ActionFailureException(
+                                "some local items don't have gid after sync");
+                    }
+                }
+            } else {
+                Log.w(TAG, "failed to query local note to refresh sync id");
+            }
+        } finally {
+            if (c != null) {
+                c.close();
+                c = null;
+            }
+        }
+    }
+
+    /**
+      * @功能名：getSyncAccount()
+      * @功能描述：获取当前同步账户的名称。
+      * @实现过程：调用 GTaskClient 实例的 getSyncAccount 方法获取当前的同步账户对象，然后返回其名称
+      * @Author:cyh
+     */
+    public String getSyncAccount() {
+        return GTaskClient.getInstance().getSyncAccount().name;
+    }
+
+
+    /**
+      * @功能名：cancelSync()
+      * @功能描述：取消同步操作
+      * @实现过程：将成员变量 mCancelled 的值设置为 true，表示取消同步
+      * @Author:cyh
+     */
+    public void cancelSync() {
+        mCancelled = true;
+    }
+}

src/Node.java

@@ -0,0 +1,127 @@
+/*
+ * 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;
+
+/**
+  * @ProjectName:    MiNote
+  * @Package:        net.micode.notes.gtask.data
+  * @ClassName:      Node
+  * @Description:    同步操作的基础数据类型，定义了相关指示同步操作的常量.该类包含以下属性：
+ * mGid：表示同步对象在云端服务器上的唯一标识符。
+ * mName：表示同步对象的名称。
+ * mLastModified：表示同步对象的最后修改时间。
+ * mDeleted：表示同步对象是否被删除。
+ * 该类提供了一些方法来操作同步对象：
+ * getCreateAction(int actionId)：根据指定的同步操作 ID（actionId）返回创建同步操作的 JSON 数据。
+ * getUpdateAction(int actionId)：根据指定的同步操作 ID（actionId）返回更新同步操作的 JSON 数据。
+ * setContentByRemoteJSON(JSONObject js)：从远程同步数据（js）中设置同步对象的内容。
+ * setContentByLocalJSON(JSONObject js)：从本地同步数据（js）中设置同步对象的内容。
+ * getLocalJSONFromContent()：将同步对象的内容转换为本地同步数据的 JSON 格式。
+ * getSyncAction(Cursor c)：根据同步对象在本地的状态（Cursor c），返回同步操作的 ID。
+ * 此外，该类还提供了一些 getter 和 setter 方法，用于访问同步对象的属性。
+ * 该类是一个抽象类，需要子类实现其中的抽象方法来完成特定同步对象的同步操作。
+  * @Author:         cyh
+ */
+
+
+
+import android.database.Cursor;
+
+import org.json.JSONObject;
+
+
+
+
+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;
+    }
+
+}

src/SqlNote.java

@@ -0,0 +1,650 @@
+/*
+ * 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.
+ */
+/**
+  * @ProjectName:    MiNote
+  * @Package:        net.micode.notes.gtask.data
+  * @ClassName:      SplNote
+  * @Description:    用于支持小米便签最底层的数据库相关操作，和sqldata的关系上是父集关系，即note是data的子父集。基于 Java 编写的笔记管理应用的部分源代码，主要包括对笔记进行数据库操作的相关类。这段代码涉及到对笔记的创建、更新、数据加载等操作，并且包含了对 JSON 数据的处理以及与 ContentProvider 进行交互的相关方法。
+  * @Author:         cyh
+ */
+
+
+
+package net.micode.notes.gtask.data;
+
+import android.appwidget.AppWidgetManager;
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.util.Log;
+
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.gtask.exception.ActionFailureException;
+import net.micode.notes.tool.GTaskStringUtils;
+import net.micode.notes.tool.ResourceParser;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+
+
+public class SqlNote {
+
+    private static final String TAG = SqlNote.class.getSimpleName();//调用getSimpleName()函数,得到类的简写名称存入字符串TAG中
+
+    private static final int INVALID_ID = -99999;
+
+    public static final String[] PROJECTION_NOTE = new String[] {// 集合了interface NoteColumns中所有SF常量（17个）
+            NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID,
+            NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE,
+            NoteColumns.NOTES_COUNT, NoteColumns.PARENT_ID, NoteColumns.SNIPPET, NoteColumns.TYPE,
+            NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE, NoteColumns.SYNC_ID,
+            NoteColumns.LOCAL_MODIFIED, NoteColumns.ORIGIN_PARENT_ID, NoteColumns.GTASK_ID,
+            NoteColumns.VERSION
+    };
+
+    //以下设置17个列的编号
+    public static final int ID_COLUMN = 0;
+
+    public static final int ALERTED_DATE_COLUMN = 1;
+
+    public static final int BG_COLOR_ID_COLUMN = 2;
+
+    public static final int CREATED_DATE_COLUMN = 3;
+
+    public static final int HAS_ATTACHMENT_COLUMN = 4;
+
+    public static final int MODIFIED_DATE_COLUMN = 5;
+
+    public static final int NOTES_COUNT_COLUMN = 6;
+
+    public static final int PARENT_ID_COLUMN = 7;
+
+    public static final int SNIPPET_COLUMN = 8;
+
+    public static final int TYPE_COLUMN = 9;
+
+    public static final int WIDGET_ID_COLUMN = 10;
+
+    public static final int WIDGET_TYPE_COLUMN = 11;
+
+    public static final int SYNC_ID_COLUMN = 12;
+
+    public static final int LOCAL_MODIFIED_COLUMN = 13;
+
+    public static final int ORIGIN_PARENT_ID_COLUMN = 14;
+
+    public static final int GTASK_ID_COLUMN = 15;
+
+    public static final int VERSION_COLUMN = 16;
+    //一下定义了17个内部的变量，其中12个可以由content中获得，5个需要初始化为0或者new
+    private Context mContext;
+
+    private ContentResolver mContentResolver;
+
+    private boolean mIsCreate;
+
+    private long mId;
+
+    private long mAlertDate;
+
+    private int mBgColorId;
+
+    private long mCreatedDate;
+
+    private int mHasAttachment;
+
+    private long mModifiedDate;
+
+    private long mParentId;
+
+    private String mSnippet;
+
+    private int mType;
+
+    private int mWidgetId;
+
+    private int mWidgetType;
+
+    private long mOriginParent;
+
+    private long mVersion;
+
+    private ContentValues mDiffNoteValues;
+
+    private ArrayList<SqlData> mDataList;
+
+    /**
+      * @功能名：SqlNote(Context context)
+      * @功能描述：构造函数
+      * @实现过程：初始化参数，mIsCreate用于标示构造方式
+      * @Author:cyh
+     */
+
+
+    public SqlNote(Context context) {//构造函数只有context，对所有的变量进行初始化
+        mContext = context;
+        mContentResolver = context.getContentResolver();
+        mIsCreate = true;
+        mId = INVALID_ID;
+        mAlertDate = 0;
+        mBgColorId = ResourceParser.getDefaultBgId(context);
+        mCreatedDate = System.currentTimeMillis();//调用系统函数获得创建时间
+        mHasAttachment = 0;
+        mModifiedDate = System.currentTimeMillis();//最后一次修改时间初始化为创建时间
+        mParentId = 0;
+        mSnippet = "";
+        mType = Notes.TYPE_NOTE;
+        mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID;
+        mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
+        mOriginParent = 0;
+        mVersion = 0;
+        mDiffNoteValues = new ContentValues();
+        mDataList = new ArrayList<SqlData>();
+    }
+
+
+
+    /**
+     * @功能名：SqlNote(Context context,Cursor c)
+     * @功能描述：构造函数
+     * @实现过程：初始化参数，mIsCreate用于标示构造方式
+     * @Author:cyh
+     */
+
+    public SqlNote(Context context, Cursor c) {//构造函数有context和一个数据库的cursor，多数变量通过cursor指向的一条记录直接进行初始化
+        mContext = context;
+        mContentResolver = context.getContentResolver();
+        mIsCreate = false;
+        loadFromCursor(c);
+        mDataList = new ArrayList<SqlData>();
+        if (mType == Notes.TYPE_NOTE)
+            loadDataContent();
+        mDiffNoteValues = new ContentValues();
+    }
+    /**
+     * @功能名：SqlNote(Context context, long id)
+     * @功能描述：构造函数,接受一个上下文（Context）对象和一个笔记ID，并使用这些参数来初始化SqlNote对象的成员变量
+     * @实现过程：初始化参数，mIsCreate用于标示构造方式将上下文对象和内容解析器对象存储在成员变量中，将“是否为新建笔记”标志设置为false，并调用loadFromCursor()方法来从数据库中加载笔记数据并进行初始化。接着，它创建一个空的SqlData对象列表和一个用于存储修改后的笔记值的ContentValues对象。最后，如果笔记类型是普通笔记（Notes.TYPE_NOTE），则调用loadDataContent()方法来加载笔记正文数据。
+     * @Author:cyh
+     */
+
+    public SqlNote(Context context, long id) {
+        mContext = context;
+        mContentResolver = context.getContentResolver();
+        mIsCreate = false;
+        loadFromCursor(id);
+        mDataList = new ArrayList<SqlData>();
+        if (mType == Notes.TYPE_NOTE)
+            loadDataContent();
+        mDiffNoteValues = new ContentValues();
+
+    }
+
+    /**
+      * @功能名：loadFromCursor(long id)
+      * @功能描述：通过游标从光标处加载数据
+      * @实现过程：首先尝试使用指定的ID查询笔记数据，然后检查返回的Cursor是否为空。如果Cursor不为空，则移动到第一条记录并调用另一个方法来加载数据进行初始化。最后，在finally块中关闭Cursor，确保资源被正确释放。
+      * @Author:cyh
+     */
+
+    private void loadFromCursor(long id) {
+        Cursor c = null;
+        try {
+            c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)",
+                    new String[] {
+                        String.valueOf(id)
+                    }, null);//通过id获得对应的ContentResolver中的cursor
+            if (c != null) {
+                c.moveToNext();
+                loadFromCursor(c);//然后加载数据进行初始化，这样函数
+            } else {
+                Log.w(TAG, "loadFromCursor: cursor = null");
+            }
+        } finally {
+            if (c != null)
+                c.close();
+        }
+    }
+    /**
+      * @功能名：loadFromCursor(Cursor c)
+      * @参数：Cursor c
+      * @功能描述：从Cursor中加载笔记数据并进行初始化
+      * @实现过程：使用Cursor对象的getColumnIndex()方法和相应的列名常量（例如ID_COLUMN、ALERTED_DATE_COLUMN等）来获取每个属性的索引，然后使用Cursor对象的getLong()、getInt()和getString()等方法来获取相应的属性值，并将它们存储在SqlNote对象的成员变量中。
+      * @Author:cyh
+     */
+    private void loadFromCursor(Cursor c) {
+        //直接从一条记录中的获得以下变量的初始值
+        mId = c.getLong(ID_COLUMN);
+        mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
+        mBgColorId = c.getInt(BG_COLOR_ID_COLUMN);
+        mCreatedDate = c.getLong(CREATED_DATE_COLUMN);
+        mHasAttachment = c.getInt(HAS_ATTACHMENT_COLUMN);
+        mModifiedDate = c.getLong(MODIFIED_DATE_COLUMN);
+        mParentId = c.getLong(PARENT_ID_COLUMN);
+        mSnippet = c.getString(SNIPPET_COLUMN);
+        mType = c.getInt(TYPE_COLUMN);
+        mWidgetId = c.getInt(WIDGET_ID_COLUMN);
+        mWidgetType = c.getInt(WIDGET_TYPE_COLUMN);
+        mVersion = c.getLong(VERSION_COLUMN);
+    }
+
+
+    /**
+      * @功能名：loadDataContent()
+      * @功能描述：加载笔记正文数据
+      * @实现过程：使用内容解析器对象（mContentResolver）执行查询操作，查询指定note_id对应的正文数据。其中，查询条件为"note_id=?"，并将mId转换为字符串作为参数传入。然后，它检查返回的Cursor对象是否为null。如果不为null，则检查Cursor中的记录数。如果记录数为0，表示该笔记没有正文数据，会输出一条警告日志并返回。否则，它遍历Cursor中的每条记录，在每条记录上调用SqlData的构造方法创建SqlData对象，并将其添加到SqlNote对象的数据列表中。最后，在finally块中关闭Cursor对象，确保资源被正确释放。
+      * @Author:cyh
+     */
+    private void loadDataContent() {
+        Cursor c = null;
+        mDataList.clear();
+        try {
+            c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,
+                    "(note_id=?)", new String[] {
+                        String.valueOf(mId)
+                    }, null);
+            if (c != null) {
+                if (c.getCount() == 0) {
+                    Log.w(TAG, "it seems that the note has not data");
+                    return;
+                }
+                while (c.moveToNext()) {
+                    SqlData data = new SqlData(mContext, c);
+                    mDataList.add(data);
+                }
+            } else {
+                Log.w(TAG, "loadDataContent: cursor = null");
+            }
+        } finally {
+            if (c != null)
+                c.close();
+        }
+    }
+
+    /**
+      * @功能名：setContent(JSONObject js)
+      * @参数：JSONObject js
+      * @功能描述：接受一个JSONObject作为参数，并根据传入的JSON对象更新内部的成员变量。
+      * @实现过程：从JSON对象中获取一个名为note的子对象，判断note的类型，如果是系统文件夹类型，则打印警告日志并返回。如果是文件夹类型，则更新成员变量mSnippet和mType。如果是笔记类型，则依次更新多个成员变量，包括mId、mAlertDate、mBgColorId、mCreatedDate、mHasAttachment、mModifiedDate、mParentId、mSnippet、mType、mWidgetId、mWidgetType和mOriginParent。然后，它从JSON对象中获取一个名为dataArray的数组，遍历数组中的每个元素，将每个元素转换为SqlData对象，并调用SqlData对象的setContent方法更新数据。最后，如果过程中发生了JSON解析异常，捕获异常并打印错误日志，然后返回false。否则，返回true表示更新成功。
+      * @Author:cyh
+     */
+
+    public boolean setContent(JSONObject js) {
+        try {
+            JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+            if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
+                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
+                String snippet = note.has(NoteColumns.SNIPPET) ? note
+                        .getString(NoteColumns.SNIPPET) : "";
+                if (mIsCreate || !mSnippet.equals(snippet)) {
+                    mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
+                }
+                mSnippet = snippet;
+
+                int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE)
+                        : Notes.TYPE_NOTE;
+                if (mIsCreate || mType != type) {
+                    mDiffNoteValues.put(NoteColumns.TYPE, type);
+                }
+                mType = type;
+            } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) {
+                JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
+                long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID;
+                if (mIsCreate || mId != id) {
+                    mDiffNoteValues.put(NoteColumns.ID, id);
+                }
+                mId = id;
+
+                long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note
+                        .getLong(NoteColumns.ALERTED_DATE) : 0;
+                if (mIsCreate || mAlertDate != alertDate) {
+                    mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate);
+                }
+                mAlertDate = alertDate;
+
+                int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note
+                        .getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext);
+                if (mIsCreate || mBgColorId != bgColorId) {
+                    mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId);
+                }
+                mBgColorId = bgColorId;
+
+                long createDate = note.has(NoteColumns.CREATED_DATE) ? note
+                        .getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis();
+                if (mIsCreate || mCreatedDate != createDate) {
+                    mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate);
+                }
+                mCreatedDate = createDate;
+
+                int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note
+                        .getInt(NoteColumns.HAS_ATTACHMENT) : 0;
+                if (mIsCreate || mHasAttachment != hasAttachment) {
+                    mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment);
+                }
+                mHasAttachment = hasAttachment;
+
+                long modifiedDate = note.has(NoteColumns.MODIFIED_DATE) ? note
+                        .getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis();
+                if (mIsCreate || mModifiedDate != modifiedDate) {
+                    mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate);
+                }
+                mModifiedDate = modifiedDate;
+
+                long parentId = note.has(NoteColumns.PARENT_ID) ? note
+                        .getLong(NoteColumns.PARENT_ID) : 0;
+                if (mIsCreate || mParentId != parentId) {
+                    mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId);
+                }
+                mParentId = parentId;
+
+                String snippet = note.has(NoteColumns.SNIPPET) ? note
+                        .getString(NoteColumns.SNIPPET) : "";
+                if (mIsCreate || !mSnippet.equals(snippet)) {
+                    mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
+                }
+                mSnippet = snippet;
+
+                int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE)
+                        : Notes.TYPE_NOTE;
+                if (mIsCreate || mType != type) {
+                    mDiffNoteValues.put(NoteColumns.TYPE, type);
+                }
+                mType = type;
+
+                int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID)
+                        : AppWidgetManager.INVALID_APPWIDGET_ID;
+                if (mIsCreate || mWidgetId != widgetId) {
+                    mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId);
+                }
+                mWidgetId = widgetId;
+
+                int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note
+                        .getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE;
+                if (mIsCreate || mWidgetType != widgetType) {
+                    mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType);
+                }
+                mWidgetType = widgetType;
+
+                long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note
+                        .getLong(NoteColumns.ORIGIN_PARENT_ID) : 0;
+                if (mIsCreate || mOriginParent != originParent) {
+                    mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent);
+                }
+                mOriginParent = originParent;
+
+                for (int i = 0; i < dataArray.length(); i++) {
+                    JSONObject data = dataArray.getJSONObject(i);
+                    SqlData sqlData = null;
+                    if (data.has(DataColumns.ID)) {
+                        long dataId = data.getLong(DataColumns.ID);
+                        for (SqlData temp : mDataList) {
+                            if (dataId == temp.getId()) {
+                                sqlData = temp;
+                            }
+                        }
+                    }
+
+                    if (sqlData == null) {
+                        sqlData = new SqlData(mContext);
+                        mDataList.add(sqlData);
+                    }
+
+                    sqlData.setContent(data);
+                }
+            }
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            return false;
+        }
+        return true;
+    }
+
+    /**
+      * @功能名：JSONObject getContent()
+      * @功能描述：创建返回一个JSONObject对象
+      * @实现过程：创建一个JSONObject对象，然后根据一些条件进行填充，最终返回这个JSONObject对象。
+      * @Author:cyh
+     */
+
+    public JSONObject getContent() {
+        try {
+            JSONObject js = new JSONObject();
+
+            if (mIsCreate) {
+                Log.e(TAG, "it seems that we haven't created this in database yet");
+                return null;
+            }
+
+            JSONObject note = new JSONObject();
+            if (mType == Notes.TYPE_NOTE) {//类型为note时
+                note.put(NoteColumns.ID, mId);
+                note.put(NoteColumns.ALERTED_DATE, mAlertDate);
+                note.put(NoteColumns.BG_COLOR_ID, mBgColorId);
+                note.put(NoteColumns.CREATED_DATE, mCreatedDate);
+                note.put(NoteColumns.HAS_ATTACHMENT, mHasAttachment);
+                note.put(NoteColumns.MODIFIED_DATE, mModifiedDate);
+                note.put(NoteColumns.PARENT_ID, mParentId);
+                note.put(NoteColumns.SNIPPET, mSnippet);
+                note.put(NoteColumns.TYPE, mType);
+                note.put(NoteColumns.WIDGET_ID, mWidgetId);
+                note.put(NoteColumns.WIDGET_TYPE, mWidgetType);
+                note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent);
+                js.put(GTaskStringUtils.META_HEAD_NOTE, note);
+
+                JSONArray dataArray = new JSONArray();
+                for (SqlData sqlData : mDataList) {
+                    JSONObject data = sqlData.getContent();
+                    if (data != null) {
+                        dataArray.put(data);
+                    }
+                }
+                js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
+            } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {
+                note.put(NoteColumns.ID, mId);
+                note.put(NoteColumns.TYPE, mType);
+                note.put(NoteColumns.SNIPPET, mSnippet);
+                js.put(GTaskStringUtils.META_HEAD_NOTE, note);
+            }
+
+            return js;
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    /**
+      * @功能名：setParentId(long id)
+      * @参数：long id
+      * @功能描述：设置笔记的父级ID
+      * @实现过程：接收一个long类型的参数id，将其赋值给成员变量mParentId，并将其添加到mDiffNoteValues中
+      * @Author:cyh
+     */
+    public void setParentId(long id) {
+        mParentId = id;
+        mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
+    }
+
+    /**
+      * @功能名：setGtaskId(String gid)
+      * @参数：String gid
+      * @功能描述：设置笔记的GTASK_ID
+      * @实现过程：接收一个字符串类型的参数gid，将其添加到mDiffNoteValues中，以表示与原始笔记对象的差异
+      * @Author:cyh
+     */
+    public void setGtaskId(String gid) {
+        mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
+    }
+
+
+    /**
+      * @功能名：setSyncId(long syncId)
+      * @参数：long syncId
+      * @功能描述：给当前id设置同步id
+      * @实现过程：接收一个 long 类型的参数 syncId，将其添加到 mDiffNoteValues 中，以表示与原始笔记对象的差异
+      * @Author:cyh
+     */
+    public void setSyncId(long syncId) {
+        mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
+    }
+
+    /**
+      * @功能名：resetLocalModified()
+      * @功能描述：重置笔记的本地修改状态
+      * @实现过程：将本地修改标志（LOCAL_MODIFIED）设置为0，表示该笔记没有进行任何本地修改
+      * @Author:cyh
+     */
+    public void resetLocalModified() {
+        mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
+    }
+
+
+    /**
+      * @功能名：getId()
+      * @功能描述：获取笔记的ID
+      * @实现过程：回成员变量 mId 的值
+      * @Author:cyh
+     */
+    public long getId() {
+        return mId;
+    }
+
+    /**
+      * @功能名：getParentId()
+      * @功能描述：获取笔记的父Id
+      * @实现过程：回成员变量 mParentId 的值
+      * @Author:cyh
+     */
+    public long getParentId() {
+        return mParentId;
+    }
+
+
+    /**
+      * @功能名：getSnippet()
+      * @功能描述：获取小片段即用于显示的部分便签内容
+      * @实现过程：返回成员变量 mSnippet 的值，表示该笔记对象的摘要信息。
+      * @Author:cyh
+     */
+    public String getSnippet() {
+        return mSnippet;
+    }
+
+
+    /**
+      * @功能名：isNoteType()
+      * @功能描述：判断笔记类型是否为普通笔记
+      * @实现过程：返回一个布尔值，如果笔记类型为 TYPE_NOTE，则返回 true，否则返回 false
+      * @Author:cyh
+     */
+    public boolean isNoteType() {
+        return mType == Notes.TYPE_NOTE;
+    }
+
+
+    /**
+      * @功能名：commit(boolean validateVersion)
+      * @参数：boolean validateVersion
+      * @功能描述：提交笔记的更改,接受一个布尔值参数 validateVersion，指定是否验证版本信息。
+      * @实现过程：首先，方法检查笔记是否是新创建的（mIsCreate），如果是新创建的，则执行以下操作：
+     * 如果笔记的 ID（mId）为无效 ID（INVALID_ID），并且 mDiffNoteValues（笔记差异值）包含 NoteColumns.ID（ID 列），则从 mDiffNoteValues 中移除 NoteColumns.ID。
+     * 使用 mContentResolver 插入 mDiffNoteValues 中的值到 Notes.CONTENT_NOTE_URI（笔记内容的 URI）并返回插入的 Uri。
+     * 通过解析 Uri 中的路径段，获取笔记的 ID，并将其赋值给 mId。
+     * 如果 mId 为 0，则抛出 IllegalStateException 异常，表示创建笔记失败。
+     * 如果笔记类型是普通笔记（Notes.TYPE_NOTE），则遍历 mDataList（数据列表）中的 SqlData 对象，并调用其 commit() 方法提交数据。
+     * 如果笔记不是新创建的，则执行以下操作：
+     * 检查笔记的 ID（mId）是否有效，如果小于等于 0，且不是特定的 ID（Notes.ID_ROOT_FOLDER 和 Notes.ID_CALL_RECORD_FOLDER），则抛出 IllegalStateException 异常，表示更新笔记时使用了无效的 ID。
+     * 如果 mDiffNoteValues（笔记差异值）的大小大于 0，则增加笔记的版本号（mVersion）。
+     * 根据 validateVersion 参数的值，构造不同的查询条件，并使用 mContentResolver 更新 Notes.CONTENT_NOTE_URI（笔记内容的 URI）中的数据。
+     * 如果更新结果为 0，则打印日志提示用户在同步过程中可能已经更新了笔记。
+     * 如果笔记类型是普通笔记（Notes.TYPE_NOTE），则遍历 mDataList（数据列表）中的 SqlData 对象，并调用其 commit() 方法提交数据。
+     * 最后，方法刷新本地信息，加载更新后的笔记数据，并清空 mDiffNoteValues（笔记差异值），将创建标志 mIsCreate 设置为 false。
+      * @Author:cyh
+     */
+    public void commit(boolean validateVersion) {
+        if (mIsCreate) {
+            if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
+                mDiffNoteValues.remove(NoteColumns.ID);
+            }
+
+            Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
+            try {
+                mId = Long.valueOf(uri.getPathSegments().get(1));
+            } catch (NumberFormatException e) {
+                Log.e(TAG, "Get note id error :" + e.toString());
+                throw new ActionFailureException("create note failed");
+            }
+            if (mId == 0) {
+                throw new IllegalStateException("Create thread id failed");
+            }
+
+            if (mType == Notes.TYPE_NOTE) {
+                for (SqlData sqlData : mDataList) {//直接使用sqldata中的实现
+                    sqlData.commit(mId, false, -1);
+                }
+            }
+        } else {
+            if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {
+                Log.e(TAG, "No such note");
+                throw new IllegalStateException("Try to update note with invalid id");
+            }
+            if (mDiffNoteValues.size() > 0) {
+                mVersion ++;
+                int result = 0;
+                if (!validateVersion) {//构造字符串
+                    result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+                            + NoteColumns.ID + "=?)", new String[] {
+                        String.valueOf(mId)
+                    });
+                } else {
+                    result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+                            + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
+                            new String[] {
+                                    String.valueOf(mId), String.valueOf(mVersion)
+                            });
+                }
+                if (result == 0) {
+                    Log.w(TAG, "there is no update. maybe user updates note when syncing");
+                }
+            }
+
+            if (mType == Notes.TYPE_NOTE) {
+                for (SqlData sqlData : mDataList) {
+                    sqlData.commit(mId, validateVersion, mVersion);
+                }
+            }
+        }
+
+        // refresh local info
+        loadFromCursor(mId);
+        if (mType == Notes.TYPE_NOTE)
+            loadDataContent();
+
+        mDiffNoteValues.clear();
+        mIsCreate = false;
+    }
+}

src/新建 文本文档.txt

@@ -1,150 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-
-<!-- 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.
--->
-
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="net.micode.notes"
-    android:versionCode="1"
-    android:versionName="0.1" >
-
-    <uses-sdk android:minSdkVersion="14" />
-
-    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
-    <uses-permission android:name="com.android.launcher.permission.INSTALL_SHORTCUT" />
-    <uses-permission android:name="android.permission.INTERNET" />
-    <uses-permission android:name="android.permission.READ_CONTACTS" />
-    <uses-permission android:name="android.permission.MANAGE_ACCOUNTS" />
-    <uses-permission android:name="android.permission.AUTHENTICATE_ACCOUNTS" />
-    <uses-permission android:name="android.permission.GET_ACCOUNTS" />
-    <uses-permission android:name="android.permission.USE_CREDENTIALS" />
-    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
-
-    <application
-        android:icon="@drawable/icon_app"
-        android:label="@string/app_name" >
-        <activity
-            android:name=".ui.NotesListActivity"
-            android:configChanges="keyboardHidden|orientation|screenSize"
-            android:label="@string/app_name"
-            android:launchMode="singleTop"
-            android:theme="@style/NoteTheme"
-            android:uiOptions="splitActionBarWhenNarrow"
-            android:windowSoftInputMode="adjustPan" >
-
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-
-        <activity
-            android:name=".ui.NoteEditActivity"
-            android:configChanges="keyboardHidden|orientation|screenSize"
-            android:launchMode="singleTop"
-            android:theme="@style/NoteTheme" >
-
-            <intent-filter>
-                <action android:name="android.intent.action.VIEW" />
-                <category android:name="android.intent.category.DEFAULT" />
-                <data android:mimeType="vnd.android.cursor.item/text_note" />
-                <data android:mimeType="vnd.android.cursor.item/call_note" />
-            </intent-filter>
-
-            <intent-filter>
-                <action android:name="android.intent.action.INSERT_OR_EDIT" />
-                <category android:name="android.intent.category.DEFAULT" />
-                <data android:mimeType="vnd.android.cursor.item/text_note" />
-                <data android:mimeType="vnd.android.cursor.item/call_note" />
-            </intent-filter>
-
-            <intent-filter>
-                <action android:name="android.intent.action.SEARCH" />
-                <category android:name="android.intent.category.DEFAULT" />
-            </intent-filter>
-
-            <meta-data
-                android:name="android.app.searchable"
-                android:resource="@xml/searchable" />
-        </activity>
-
-        <provider
-            android:name="net.micode.notes.data.NotesProvider"
-            android:authorities="micode_notes"
-            android:multiprocess="true" />
-
-        <receiver
-            android:name=".widget.NoteWidgetProvider_2x"
-            android:label="@string/app_widget2x2" >
-            <intent-filter>
-                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
-                <action android:name="android.appwidget.action.APPWIDGET_DELETED" />
-                <action android:name="android.intent.action.PRIVACY_MODE_CHANGED" />
-            </intent-filter>
-
-            <meta-data
-                android:name="android.appwidget.provider"
-                android:resource="@xml/widget_2x_info" />
-        </receiver>
-        <receiver
-            android:name=".widget.NoteWidgetProvider_4x"
-            android:label="@string/app_widget4x4" >
-
-            <intent-filter>
-                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
-                <action android:name="android.appwidget.action.APPWIDGET_DELETED" />
-                <action android:name="android.intent.action.PRIVACY_MODE_CHANGED" />
-            </intent-filter>
-
-            <meta-data
-                android:name="android.appwidget.provider"
-                android:resource="@xml/widget_4x_info" />
-        </receiver>
-
-        <receiver android:name=".ui.AlarmInitReceiver" >
-            <intent-filter>
-                <action android:name="android.intent.action.BOOT_COMPLETED" />
-            </intent-filter>
-        </receiver>
-
-        <receiver
-            android:name="net.micode.notes.ui.AlarmReceiver"
-            android:process=":remote" >
-        </receiver>
-
-        <activity
-            android:name=".ui.AlarmAlertActivity"
-            android:label="@string/app_name"
-            android:launchMode="singleInstance"
-            android:theme="@android:style/Theme.Holo.Wallpaper.NoTitleBar" >
-        </activity>
-
-        <activity
-            android:name="net.micode.notes.ui.NotesPreferenceActivity"
-            android:label="@string/preferences_title"
-            android:launchMode="singleTop"
-            android:theme="@android:style/Theme.Holo.Light" >
-        </activity>
-
-        <service
-            android:name="net.micode.notes.gtask.remote.GTaskSyncService"
-            android:exported="false" >
-        </service>
-
-        <meta-data
-            android:name="android.app.default_searchable"
-            android:value=".ui.NoteEditActivity" />
-    </application>
-</manifest>