From be4d9275c05ee51990c31fe0d8b50692d1a9c282 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=B0=AD=E6=B7=91=E6=B6=B5?= <1508386176@qq.com> Date: Wed, 25 Dec 2024 02:18:12 +0800 Subject: [PATCH] Signed-off-by: --- GTaskManager.txt | 1065 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1065 insertions(+) create mode 100644 GTaskManager.txt diff --git a/GTaskManager.txt b/GTaskManager.txt new file mode 100644 index 0000000..45caf8d --- /dev/null +++ b/GTaskManager.txt @@ -0,0 +1,1065 @@ +/* + * 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. + */ +/* + * GTaskManager 负责管理本地笔记数据库与 Google Tasks 之间的同步过程。 + */ +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; + +/* + * GTaskManager 负责管理本地笔记数据库与 Google Tasks 之间的同步过程。 + */ +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; + // 用于管理任务列表、节点、元数据和 GID 与 NID 映射的哈希表 + private HashMap mGTaskListHashMap; + + private HashMap mGTaskHashMap; + + private HashMap mMetaHashMap; + + private TaskList mMetaList; + + private HashSet mLocalDeleteIdMap; + + private HashMap mGidToNid; + + private HashMap mNidToGid; + + private GTaskManager() { + // 初始化同步状态标志，表示当前没有正在进行同步 + mSyncing = false; + // 初始化取消同步标志，表示当前没有取消同步 + mCancelled = false; + // 初始化用于存储 Google Task 列表的哈希表 + mGTaskListHashMap = new HashMap();、 + // 初始化用于存储 Google Task 节点的哈希表 + mGTaskHashMap = new HashMap(); + // 初始化用于存储元数据的哈希表 + mMetaHashMap = new HashMap(); + // 初始化元数据列表，初始值为 null + mMetaList = null; + // 初始化用于存储本地删除的笔记 ID 的集合 + mLocalDeleteIdMap = new HashSet(); + // 初始化用于存储 Google Task ID 到本地笔记 ID 映射的哈希表 + mGidToNid = new HashMap(); + // 初始化用于存储本地笔记 ID 到 Google Task ID 映射的哈希表 + mNidToGid = new HashMap(); + } +/* + * 获取 GTaskManager 的单例实例。 + * 该方法使用 synchronized 关键字确保线程安全，防止多个线程同时创建实例。 + * @return GTaskManager 的单例实例 + */ + public static synchronized GTaskManager getInstance() { + // 检查单例实例是否已经创建 + if (mInstance == null) { + // 如果未创建，则创建一个新的 GTaskManager 实例 + mInstance = new GTaskManager(); + } + return mInstance; // 返回单例实例 + } +/* + * 设置活动上下文，用于获取认证令牌。 + * 该方法使用 synchronized 关键字确保线程安全，防止多个线程同时修改 mActivity 变量。 + * @param activity 活动上下文 + */ + public synchronized void setActivityContext(Activity activity) { + // used for getting authtoken + // 将传入的活动上下文赋值给 mActivity 变量 + mActivity = activity; + } +/* + * 同步本地笔记数据库与 Google Tasks。 + * 该方法负责初始化同步过程，处理同步过程中的各种异常，并返回同步结果状态。 + * @param context 应用程序上下文 + * @param asyncTask 异步任务对象，用于发布同步进度 + * @return 同步结果状态，可能的值为 STATE_SUCCESS, STATE_NETWORK_ERROR, STATE_INTERNAL_ERROR, STATE_SYNC_IN_PROGRESS, STATE_SYNC_CANCELLED + */ + public int sync(Context context, GTaskASyncTask asyncTask) { + // 检查是否已经有同步正在进行 + if (mSyncing) { + Log.d(TAG, "Sync is in progress"); + 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 实例并重置更新数组 + GTaskClient client = GTaskClient.getInstance(); + client.resetUpdateArray(); + + // login google task + // 登录 Google Task + if (!mCancelled) { + if (!client.login(mActivity)) { + throw new NetworkFailureException("login google task failed"); + } + } + + // get the task list from google + // 从 Google 获取任务列表 + asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list)); + initGTaskList(); + + // do content sync work + // 执行内容同步工作 + asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing)); + syncContent(); + } catch (NetworkFailureException e) { + // 处理网络失败异常 + Log.e(TAG, e.toString()); + 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; // 返回同步结果状态 + } +/* + * 初始化 Google Task 列表。 + * 该方法从 Google Task 获取任务列表，并初始化元数据列表和任务列表。 + * @throws NetworkFailureException 如果网络操作失败 + */ + private void initGTaskList() throws NetworkFailureException { + // 检查是否已经取消同步 + if (mCancelled) + return; + // 获取 GTaskClient 实例 + GTaskClient client = GTaskClient.getInstance(); + try { + // 从 Google Task 获取任务列表 + JSONArray jsTaskLists = client.getTaskLists(); + + // init meta list first + // 首先初始化元数据列表 + mMetaList = null; //初始化元数据列表，将其设置为 null。 + for (int i = 0; i < jsTaskLists.length(); i++) { + //遍历任务列表，逐个处理每个任务列表。 + JSONObject object = jsTaskLists.getJSONObject(i); + //获取当前任务列表的 JSONObject + String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID); + //获取当前任务列表的 Google Task ID + //获取当前任务列表的名称。 + String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME); + // 检查是否是元数据列表 + //如果是，则初始化元数据列表并加载元数据。 + if (name + .equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) { + mMetaList = new TaskList(); + //创建一个新的 TaskList 对象作为元数据列表。 + mMetaList.setContentByRemoteJSON(object); + //使用远程 JSON 数据设置元数据列表的内容。 + + // load meta data + // 加载元数据 + JSONArray jsMetas = client.getTaskList(gid); + //获取元数据列表中的元数据，返回一个 JSONArray。 + for (int j = 0; j < jsMetas.length(); j++) { + //遍历元数据列表，逐个处理每个元数据。 + object = (JSONObject) jsMetas.getJSONObject(j); + MetaData metaData = new MetaData(); + //创建一个新的 MetaData 对象 + metaData.setContentByRemoteJSON(object); + //使用远程 JSON 数据设置元数据的内容 + if (metaData.isWorthSaving()) { + //检查元数据是否值得保存。如果值得保存，则将其添加到元数据列表中，并更新 mMetaHashMap + mMetaList.addChildTask(metaData); + if (metaData.getGid() != null) { + //检查元数据的 Google Task ID 是否存在。如果存在，则将其添加到 mMetaHashMap 中 + mMetaHashMap.put(metaData.getRelatedGid(), metaData); + } + } + } + } + } + + // create meta list if not existed + // 如果元数据列表不存在，则创建一个新的元数据列表 + if (mMetaList == null) { + //检查元数据列表是否为空。如果为空，则创建一个新的元数据列表并将其添加到 Google Task 中。 + mMetaList = new TaskList(); + mMetaList.setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + + GTaskStringUtils.FOLDER_META); + //设置元数据列表的名称 + GTaskClient.getInstance().createTaskList(mMetaList); + //将元数据列表添加到 Google Task 中 + } + + // init task list + // 初始化任务列表 + for (int i = 0; i < jsTaskLists.length(); i++) { + //再次遍历任务列表，逐个处理每个任务列表 + JSONObject object = jsTaskLists.getJSONObject(i); + String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID); + String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME); + // 检查是否是 MIUI 文件夹前缀的任务列表 + if (name.startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX) + && !name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + + GTaskStringUtils.FOLDER_META)) { + //检查当前任务列表是否是 MIUI 文件夹前缀的任务列表，并且不是元数据列表。如果是，则初始化任务列表并加载任务 + TaskList tasklist = new TaskList(); + 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()) { + //检查任务是否值得保存。如果值得保存，则将其添加到任务列表中，并更新 mGTaskHashMap。 + task.setMetaInfo(mMetaHashMap.get(gid)); + tasklist.addChildTask(task); + mGTaskHashMap.put(gid, task); + } + } + } + } + } catch (JSONException e) { + // 处理 JSON 解析异常 + Log.e(TAG, e.toString()); + e.printStackTrace(); + throw new ActionFailureException("initGTaskList: handing JSONObject failed"); + } + } +/* + * 同步内容。 + * 该方法负责同步本地数据库中的笔记与 Google Tasks 中的任务。 + * @throws NetworkFailureException 如果网络操作失败 + */ + private void syncContent() throws NetworkFailureException { + int syncType; + Cursor c = null; + String gid; + Node node; + // 清空本地删除的笔记 ID 集合 + mLocalDeleteIdMap.clear(); + // 检查是否已经取消同步。如果 mCancelled 为 true，则直接返回，不执行后续操作。 + if (mCancelled) { + return; + } + + // for local deleted note + // 处理本地删除的笔记 + //使用 try-finally 结构确保在查询结束后关闭游标。 + 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); + //查询本地删除的笔记。查询条件为 type 不等于 Notes.TYPE_SYSTEM 且 parent_id 等于 Notes.ID_TRASH_FOLER。 + if (c != null) { + //检查查询结果是否为空。如果不为空，则遍历查询结果。 + while (c.moveToNext()) { + //遍历查询结果，逐个处理每个笔记。 + gid = c.getString(SqlNote.GTASK_ID_COLUMN); + //获取当前笔记的 Google Task ID。 + node = mGTaskHashMap.get(gid); + //从 mGTaskHashMap 中获取对应的节点。 + if (node != null) { + //检查节点是否存在。如果存在，则从 mGTaskHashMap 中移除该节点，并执行远程删除操作。 + mGTaskHashMap.remove(gid); + doContentSync(Node.SYNC_ACTION_DEL_REMOTE, node, c); + //执行远程删除操作。 + } + + mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN)); + //将当前笔记的本地 ID 添加到 mLocalDeleteIdMap 中。 + } + } 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"); + //查询数据库中存在的笔记。查询条件为 type 等于 Notes.TYPE_NOTE 且 parent_id 不等于 Notes.ID_TRASH_FOLER。 + if (c != null) { + //检查查询结果是否为空。如果不为空，则遍历查询结果。 + while (c.moveToNext()) { + //遍历查询结果，逐个处理每个笔记。 + gid = c.getString(SqlNote.GTASK_ID_COLUMN); + //获取当前笔记的 Google Task ID。 + node = mGTaskHashMap.get(gid); + //从 mGTaskHashMap 中获取对应的节点。 + if (node != null) { + //检查节点是否存在。如果存在，则从 mGTaskHashMap 中移除该节点，并更新 mGidToNid 和 mNidToGid 映射，然后获取同步操作类型。 + mGTaskHashMap.remove(gid); + mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN)); + //更新 Google Task ID 到本地笔记 ID 的映射。 + mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid); + //更新本地笔记 ID 到 Google Task ID 的映射。 + syncType = node.getSyncAction(c); + //获取当前笔记的同步操作类型。 + } else { + //如果节点不存在，则根据 Google Task ID 是否为空来确定同步操作类型。 + if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) { + // local add + // 本地添加 + //检查 Google Task ID 是否为空。如果为空，则表示本地添加操作。 + 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> iter = mGTaskHashMap.entrySet().iterator(); + //获取 mGTaskHashMap 的迭代器。 + while (iter.hasNext()) { + //遍历 mGTaskHashMap，逐个处理剩余的项目。 + Map.Entry 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 + // one + // clear local delete table + // 检查是否已经取消同步 + if (!mCancelled) { + // 批量删除本地删除的笔记 + if (!DataUtils.batchDeleteNotes(mContentResolver, mLocalDeleteIdMap)) { + throw new ActionFailureException("failed to batch-delete local deleted notes"); + } + //批量删除本地删除的笔记。如果删除失败，则抛出 ActionFailureException。 + } + + // refresh local sync id + // 刷新本地同步 ID + if (!mCancelled) { + GTaskClient.getInstance().commitUpdate(); + refreshLocalSyncId(); + } + + } +/* + * 同步文件夹。 + * 该方法负责同步本地数据库中的文件夹与 Google Tasks 中的任务列表。 + * @throws NetworkFailureException 如果网络操作失败 + */ + private void syncFolder() throws NetworkFailureException { + Cursor c = null; + String gid; + Node node; + int syncType; + //检查是否已经取消同步。如果 mCancelled 为 true，则直接返回，不执行后续操作。 + 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); + //查询根文件夹。查询条件为 _id 等于 Notes.ID_ROOT_FOLDER。 + if (c != null) { + //检查查询结果是否为空。如果不为空，则处理查询结果。 + c.moveToNext(); + //移动游标到下一行。 + gid = c.getString(SqlNote.GTASK_ID_COLUMN); + //获取当前文件夹的 Google Task ID。 + node = mGTaskHashMap.get(gid); + //从 mGTaskHashMap 中获取对应的节点。 + if (node != null) { + //检查节点是否存在。如果存在，则从 mGTaskHashMap 中移除该节点，并更新 mGidToNid 和 mNidToGid 映射。 + mGTaskHashMap.remove(gid); + mGidToNid.put(gid, (long) Notes.ID_ROOT_FOLDER); + //更新 Google Task ID 到本地笔记 ID 的映射。 + mNidToGid.put((long) Notes.ID_ROOT_FOLDER, gid); + // for system folder, only update remote name if necessary + //更新本地笔记 ID 到 Google Task ID 的映射。 + 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); + //查询通话记录文件夹。查询条件为 _id 等于 Notes.ID_CALL_RECORD_FOLDER。 + if (c != null) { + //检查查询结果是否为空。如果不为空，则处理查询结果。 + if (c.moveToNext()) { + gid = c.getString(SqlNote.GTASK_ID_COLUMN); + node = mGTaskHashMap.get(gid); + if (node != null) { + //检查节点是否存在。如果存在，则从 mGTaskHashMap 中移除该节点，并更新 mGidToNid 和 mNidToGid 映射。 + 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"); + //查询本地存在的文件夹。查询条件为 type 等于 Notes.TYPE_FOLDER 且 parent_id 不等于 Notes.ID_TRASH_FOLER。 + if (c != null) { + //检查查询结果是否为空。如果不为空，则遍历查询结果。 + while (c.moveToNext()) { + //遍历查询结果，逐个处理每个文件夹。 + gid = c.getString(SqlNote.GTASK_ID_COLUMN); + node = mGTaskHashMap.get(gid); + if (node != null) { + //检查节点是否存在。如果存在，则从 mGTaskHashMap 中移除该节点，并更新 mGidToNid 和 mNidToGid 映射，然后获取同步操作类型。 + mGTaskHashMap.remove(gid); + mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN)); + mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid); + syncType = node.getSyncAction(c); + } else { + //如果节点不存在，则根据 Google Task ID 是否为空来确定同步操作类型。 + if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) { + // local add + //检查 Google Task ID 是否为空。如果为空，则表示本地添加操作 + syncType = Node.SYNC_ACTION_ADD_REMOTE; + } else { + //如果 Google Task ID 不为空，则表示远程删除操作。 + // 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> iter = mGTaskListHashMap.entrySet().iterator(); + //获取 mGTaskListHashMap 的迭代器。 + while (iter.hasNext()) { + //遍历 mGTaskListHashMap，逐个处理远程添加的文件夹。 + Map.Entry entry = iter.next(); + //获取当前的键值对 + gid = entry.getKey(); + node = entry.getValue(); + if (mGTaskHashMap.containsKey(gid)) { + //检查 mGTaskHashMap 中是否包含该节点。如果包含，则从 mGTaskHashMap 中移除该节点，并执行本地添加操作。 + mGTaskHashMap.remove(gid); + doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null); + } + } + + if (!mCancelled) //检查是否已经取消同步。如果没有取消，则提交更新。 + GTaskClient.getInstance().commitUpdate(); + } +/* + * 执行内容同步操作。 + * 该方法根据同步类型执行相应的同步操作。 + * @param syncType 同步类型 + * @param node 节点对象 + * @param c 游标对象 + * @throws NetworkFailureException 如果网络操作失败 + */ + 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: + // 本地删除操作。从 mMetaHashMap 中获取元数据。如果元数据存在，则调用 GTaskClient.getInstance().deleteNode(meta) 方法删除元数据。将本地笔记 ID 添加到 mLocalDeleteIdMap 中。 + 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: + // 远程删除操作。从 mMetaHashMap 中获取元数据。如果元数据存在，则调用 GTaskClient.getInstance().deleteNode(meta) 方法删除元数据。调用 GTaskClient.getInstance().deleteNode(node) 方法删除节点。 + 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"); + } + } +/* + * 添加本地节点。 + * 该方法负责将远程节点添加到本地数据库中。 + * @param node 远程节点对象 + * @throws NetworkFailureException 如果网络操作失败 + */ + private void addLocalNode(Node node) throws NetworkFailureException { + if (mCancelled) { + //检查是否已经取消同步。如果 mCancelled 为 true，则直接返回，不执行后续操作。 + return; + } + + SqlNote 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 { + //其他文件夹。创建新的本地笔记，并设置内容和父节点 ID。 + sqlNote = new SqlNote(mContext); + sqlNote.setContent(node.getLocalJSONFromContent()); + sqlNote.setParentId(Notes.ID_ROOT_FOLDER); + } + } else { + //如果是任务。创建新的本地笔记，并设置内容和父节点 ID。 + sqlNote = new SqlNote(mContext); + JSONObject js = node.getLocalJSONFromContent(); + try { + //处理 JSON 解析异常。 + if (js.has(GTaskStringUtils.META_HEAD_NOTE)) { + //检查是否包含笔记信息。如果包含笔记信息，则检查笔记 ID 是否可用。 + JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); + if (note.has(NoteColumns.ID)) { + //检查笔记信息是否包含 ID。如果包含 ID，则检查 ID 是否可用。 + long id = note.getLong(NoteColumns.ID); + if (DataUtils.existInNoteDatabase(mContentResolver, id)) { + // the id is not available, have to create a new one + //检查笔记 ID 是否存在于本地数据库中。如果存在，则移除笔记 ID。 + note.remove(NoteColumns.ID); + } + } + } + + if (js.has(GTaskStringUtils.META_HEAD_DATA)) { + //检查是否包含数据信息。如果包含数据信息，则检查数据 ID 是否可用。 + 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)) { + //检查数据信息是否包含 ID。如果包含 ID，则检查 ID 是否可用。 + long dataId = data.getLong(DataColumns.ID); + if (DataUtils.existInDataDatabase(mContentResolver, dataId)) { + // the data id is not available, have to create + // a new one + //检查数据 ID 是否存在于本地数据库中。如果存在，则移除数据 ID。 + 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()); + //获取父节点的本地 ID。 + if (parentId == null) { + //检查父节点的本地 ID 是否存在。如果不存在，则抛出 ActionFailureException 异常。 + 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());//更新 Google Task ID 到本地笔记 ID 的映射。 + sqlNote.commit(false); + + // update gid-nid mapping + mGidToNid.put(node.getGid(), sqlNote.getId());//更新本地笔记 ID 到 Google Task ID 的映射。 + mNidToGid.put(sqlNote.getId(), node.getGid()); + + // update meta + updateRemoteMeta(node.getGid(), sqlNote);//更新元数据。 + } +/* + * 更新本地节点。 + * 该方法负责将远程节点的更新同步到本地数据库中。 + * @param node 远程节点对象 + * @param c 游标对象 + * @throws NetworkFailureException 如果网络操作失败 + */ + private void updateLocalNode(Node node, Cursor c) throws NetworkFailureException { + if (mCancelled) { + //检查是否已经取消同步。如果 mCancelled 为 true，则直接返回，不执行后续操作。 + return; + } + + SqlNote sqlNote; + // update the note locally + //声明一个 SqlNote 变量，用于存储本地笔记。 + sqlNote = new SqlNote(mContext, c); + //创建一个新的 SqlNote 对象，并使用游标 c 初始化。 + sqlNote.setContent(node.getLocalJSONFromContent()); + //设置本地笔记的内容为远程节点的本地 JSON 内容。 + Long parentId = (node instanceof Task) ? mGidToNid.get(((Task) node).getParent().getGid()) + : new Long(Notes.ID_ROOT_FOLDER); + //获取父节点的本地 ID。如果节点是任务，则从 mGidToNid 映射中获取父节点的本地 ID。如果节点不是任务，则将父节点 ID 设置为根文件夹的 ID。 + if (parentId == null) { + //检查父节点的本地 ID 是否存在。如果不存在，则记录错误日志并抛出 ActionFailureException 异常。 + Log.e(TAG, "cannot find task's parent id locally"); + throw new ActionFailureException("cannot update local node"); + } + sqlNote.setParentId(parentId.longValue());//设置本地笔记的父节点 ID。 + sqlNote.commit(true);//提交本地笔记的更新。 + + // update meta info + //更新元数据信息。 + updateRemoteMeta(node.getGid(), sqlNote); + } +/* + * 添加远程节点。 + * 该方法负责将本地笔记添加到 Google Tasks 中。 + * @param node 远程节点对象 + * @param c 游标对象 + * @throws NetworkFailureException 如果网络操作失败 + */ + private void addRemoteNode(Node node, Cursor c) throws NetworkFailureException { + if (mCancelled) { + //检查是否已经取消同步。如果 mCancelled 为 true，则直接返回，不执行后续操作。 + return; + } + + SqlNote sqlNote = new SqlNote(mContext, c); + //创建一个新的 SqlNote 对象，并使用游标 c 初始化。 + Node n; + //声明一个 Node 变量，用于存储远程节点 + + // update remotely + if (sqlNote.isNoteType()) { + //检查本地笔记是否是笔记类型。如果是笔记类型，则创建一个新的 Task 对象，并设置内容。 + Task task = new Task(); + task.setContentByLocalJSON(sqlNote.getContent()); + + String parentGid = mNidToGid.get(sqlNote.getParentId()); + if (parentGid == null) { + //检查父任务列表的 Google Task ID 是否存在。如果不存在，则记录错误日志并抛出 ActionFailureException 异常。 + Log.e(TAG, "cannot find task's parent tasklist"); + throw new ActionFailureException("cannot add remote task"); + } + mGTaskListHashMap.get(parentGid).addChildTask(task); + //将任务添加到父任务列表中。 + + GTaskClient.getInstance().createTask(task); + //创建远程任务。 + n = (Node) task; + //将 Task 对象赋值给 Node 变量。 + + // add meta + //添加元数据。 + updateRemoteMeta(task.getGid(), sqlNote); + } else { + //如果是文件夹类型。创建一个新的 TaskList 对象，并设置内容。 + 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) + //检查本地笔记的 ID 是否是根文件夹的 ID。如果是根文件夹，则设置文件夹名称为默认文件夹名称。 + folderName += GTaskStringUtils.FOLDER_DEFAULT; + else if (sqlNote.getId() == Notes.ID_CALL_RECORD_FOLDER) + //检查本地笔记的 ID 是否是通话记录文件夹的 ID。如果是通话记录文件夹，则设置文件夹名称为通话记录文件夹名称。 + folderName += GTaskStringUtils.FOLDER_CALL_NOTE; + else + //其他文件夹。设置文件夹名称为本地笔记的片段。 + folderName += sqlNote.getSnippet(); + + Iterator> iter = mGTaskListHashMap.entrySet().iterator(); + while (iter.hasNext()) { + //遍历 mGTaskListHashMap，查找匹配的文件夹。 + Map.Entry entry = iter.next(); + String gid = entry.getKey(); + TaskList list = entry.getValue(); + + if (list.getName().equals(folderName)) { + //检查任务列表的名称是否与文件夹名称匹配。如果匹配，则将任务列表赋值给 tasklist 变量，并从 mGTaskHashMap 中移除该节点。 + tasklist = list; + if (mGTaskHashMap.containsKey(gid)) { + //检查 mGTaskHashMap 中是否包含该节点。如果包含，则从 mGTaskHashMap 中移除该节点。 + mGTaskHashMap.remove(gid); + } + break; + } + } + + // no match we can add now + if (tasklist == null) { + //如果没有匹配的文件夹，则可以添加。创建一个新的 TaskList 对象，并设置内容。 + tasklist = new TaskList(); + tasklist.setContentByLocalJSON(sqlNote.getContent()); + GTaskClient.getInstance().createTaskList(tasklist); + mGTaskListHashMap.put(tasklist.getGid(), tasklist); + } + n = (Node) tasklist;//将 TaskList 对象赋值给 Node 变量。 + } + + // update local note + sqlNote.setGtaskId(n.getGid());//设置本地笔记的 Google Task ID + sqlNote.commit(false);//提交本地笔记的更新。 + sqlNote.resetLocalModified();//重置本地笔记的修改标志。 + sqlNote.commit(true);//重置本地笔记的修改标志。 + + // gid-id mapping + mGidToNid.put(n.getGid(), sqlNote.getId());//更新 Google Task ID 到本地笔记 ID 的映射。 + mNidToGid.put(sqlNote.getId(), n.getGid());//更新本地笔记 ID 到 Google Task ID 的映射。 + } +/* + * 更新远程节点。 + * 该方法负责将本地笔记的更新同步到 Google Tasks 中。 + * @param node 远程节点对象 + * @param c 游标对象 + * @throws NetworkFailureException 如果网络操作失败 + */ + private void updateRemoteNode(Node node, Cursor c) throws NetworkFailureException { + if (mCancelled) { + //检查是否已经取消同步。如果 mCancelled 为 true，则直接返回，不执行后续操作。 + return; + } + + SqlNote sqlNote = new SqlNote(mContext, c);//创建一个新的 SqlNote 对象，并使用游标 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(); + + String curParentGid = mNidToGid.get(sqlNote.getParentId()); + if (curParentGid == null) { + //检查父任务列表的 Google Task ID 是否存在。如果不存在，则记录错误日志并抛出 ActionFailureException 异常。 + Log.e(TAG, "cannot find task's parent tasklist"); + throw new ActionFailureException("cannot update remote task"); + } + TaskList curParentList = mGTaskListHashMap.get(curParentGid); + //获取当前父任务列表。 + if (preParentList != curParentList) { + //检查任务的当前父任务列表是否与当前父任务列表不同。如果不同，则从当前父任务列表中移除任务，并将其添加到新的父任务列表中。 + preParentList.removeChildTask(task); + curParentList.addChildTask(task); + GTaskClient.getInstance().moveTask(task, preParentList, curParentList); + } + } + + // clear local modified flag + sqlNote.resetLocalModified();//清除本地笔记的修改标志。 + sqlNote.commit(true);//提交本地笔记的更新。 + } +/* + * 更新远程元数据。 + * 该方法负责将本地笔记的元数据同步到 Google Tasks 中。 + * @param gid Google Task ID + * @param sqlNote 本地笔记对象 + * @throws NetworkFailureException 如果网络操作失败 + */ + 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); + } + } + } +/* + * 刷新本地同步 ID。 + * 该方法负责刷新本地笔记的同步 ID，确保本地笔记的同步 ID 与 Google Tasks 中的最新数据一致。 + * @throws NetworkFailureException 如果网络操作失败 + */ + private void refreshLocalSyncId() throws NetworkFailureException { + // 检查是否已经取消同步。如果 mCancelled 为 true，则直接返回，不执行后续操作。 + if (mCancelled) { + return; + } + + // get the latest gtask list + mGTaskHashMap.clear();//清空 mGTaskHashMap + mGTaskListHashMap.clear();//清空 mGTaskListHashMap。 + mMetaHashMap.clear();//清空 mMetaHashMap。 + initGTaskList();//初始化 Google Task 列表。 + + Cursor c = null;//声明一个游标变量 c，用于存储查询结果。 + try { + c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, + "(type<>? AND parent_id<>?)", new String[] { + //查询本地笔记。查询条件为 type 不等于 Notes.TYPE_SYSTEM 且 parent_id 不等于 Notes.ID_TRASH_FOLER。 + String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLER) + }, NoteColumns.TYPE + " DESC"); + if (c != null) { + //检查查询结果是否为空。如果不为空，则遍历查询结果。 + while (c.moveToNext()) { + //遍历查询结果，逐个处理每个笔记。 + String gid = c.getString(SqlNote.GTASK_ID_COLUMN); + Node node = mGTaskHashMap.get(gid); + if (node != null) { + //检查节点是否存在。如果存在，则从 mGTaskHashMap 中移除该节点，并更新本地笔记的同步 ID。 + mGTaskHashMap.remove(gid); + ContentValues values = new ContentValues(); + values.put(NoteColumns.SYNC_ID, node.getLastModified()); + mContentResolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, + c.getLong(SqlNote.ID_COLUMN)), values, null, null); + } else { + //如果节点不存在，则记录错误日志并抛出 ActionFailureException 异常。 + 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; + } + } + } +/* + * 获取同步账户名称。 + * 该方法返回当前用于同步的 Google 账户名称。 + * @return 同步账户名称 + */ + public String getSyncAccount() { + // 获取 GTaskClient 的单例实例，并返回同步账户的名称 + return GTaskClient.getInstance().getSyncAccount().name; + } +/* + * 取消同步。 + * 该方法用于设置取消同步标志，以便在同步过程中停止同步操作。 + */ + public void cancelSync() { + // 设置取消同步标志为 true + mCancelled = true; + } +}