@ -1,31 +1,54 @@
/ *
* Copyright ( c ) 2010 - 2011 , The MiCode Open Source Community ( www . micode . net )
* 版 权 所 有 ( c ) 2010 - 2011 , MiCode 开 源 社 区 ( 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
* 根 据 Apache 许 可 证 ， 第 2.0 版 （ “ 许 可 证 ” ） 许 可 ；
* 除 非 遵 循 许 可 证 ， 否 则 不 得 使 用 此 文 件 。
* 可 以 在 以 下 网 址 获 取 许 可 证 副 本 ：
*
* 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.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 android.app.Activity ; // 用于活动管理的类
import android.content.ContentResolver ; // 用于内容提供者的类
import android.content.ContentUris ; // 处理内容 URI 的工具类
import android.content.ContentValues ; // 包含 ContentProvider 插入或更新所需值的类
import android.content.Context ; // 应用上下文类
import android.database.Cursor ; // 数据库查询结果的类
import android.util.Log ; // 记录日志的工具类
// 导入项目中的相关类
import net.micode.notes.R ;
import net.micode.notes.data.Notes ;
< < < < < < < HEAD
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 ; // SQL 笔记类
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 ; // GTask 字符串工具类
import org.json.JSONArray ; // JSON 数组类
import org.json.JSONException ; // JSON 异常类
import org.json.JSONObject ; // JSON 对象类
import java.util.HashMap ; // 哈希表实现
import java.util.HashSet ; // 哈希集合实现
import java.util.Iterator ; // 迭代器类
= = = = = = =
import net.micode.notes.data.Notes.DataColumns ;
import net.micode.notes.data.Notes.NoteColumns ;
import net.micode.notes.gtask.data.MetaData ;
@ -47,47 +70,49 @@ import java.util.HashSet;
import java.util.Iterator ;
import java.util.Map ;
// 这是一个管理Google任务同步的类
// 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 ;
// 关联的Activity，
private Activity mActivity ;
// 应用上下文
private Context mContext ;
// 用于操作内容提供器，进行数据查询、更新等操作
private ContentResolver mContentResolver ;
// 标记是否正在同步
private boolean mSyncing ;
// 标记同步是否被取消
private boolean mCancelled ;
// 存储Google Tasks任务列表的哈希表， （ ） ，
private HashMap < String , TaskList > mGTaskListHashMap ;
// 存储Google Tasks节点（ ） ， （ ） ，
private HashMap < String , Node > mGTaskHashMap ;
// 存储元数据的哈希表， ，
private HashMap < String , MetaData > mMetaHashMap ;
// 元数据对应的任务列表
private TaskList mMetaList ;
// 存储本地已删除记录的ID集合，
private HashSet < Long > mLocalDeleteIdMap ;
// 存储从Google Tasks的全局唯一ID（ ） （ ）
private HashMap < String , Long > mGidToNid ;
// 存储从本地记录ID（ ） （ ）
private HashMap < Long , String > mNidToGid ;
// 私有构造函数， 防止外部实例化
// 私有构造函数， 初始化相关成员变量
private GTaskManager ( ) {
mSyncing = false ;
mCancelled = false ;
@ -108,12 +133,13 @@ public class GTaskManager {
return mInstance ;
}
// 设置 活动上下文，用于获取认证令牌
// 设置 关联的Activity上下文，
public synchronized void setActivityContext ( Activity activity ) {
// used for getting authtoken
mActivity = activity ;
}
// 同步Google任务与本地数据库
// 执行同步操作，
public int sync ( Context context , GTaskASyncTask asyncTask ) {
if ( mSyncing ) {
Log . d ( TAG , "Sync is in progress" ) ;
@ -123,6 +149,7 @@ public class GTaskManager {
mContentResolver = mContext . getContentResolver ( ) ;
mSyncing = true ;
mCancelled = false ;
// 清除之前同步相关的数据缓存，
mGTaskListHashMap . clear ( ) ;
mGTaskHashMap . clear ( ) ;
mMetaHashMap . clear ( ) ;
@ -134,18 +161,18 @@ public class GTaskManager {
GTaskClient client = GTaskClient . getInstance ( ) ;
client . resetUpdateArray ( ) ;
// 登录Google 任务
// 登录Google Tasks， ，
if ( ! mCancelled ) {
if ( ! client . login ( mActivity ) ) {
throw new NetworkFailureException ( "login google task failed" ) ;
}
}
// 从Google获取任务列表
// 发布同步进度信息，初始化任务列表阶段
asyncTask . publishProgess ( mContext . getString ( R . string . sync_progress_init_list ) ) ;
initGTaskList ( ) ;
// 同步内容
// 发布 同步进度信息，进行 内容同步阶段
asyncTask . publishProgess ( mContext . getString ( R . string . sync_progress_syncing ) ) ;
syncContent ( ) ;
} catch ( NetworkFailureException e ) {
@ -159,6 +186,7 @@ public class GTaskManager {
e . printStackTrace ( ) ;
return STATE_INTERNAL_ERROR ;
} finally {
// 无论同步是否成功，最终都清除同步相关的数据缓存
mGTaskListHashMap . clear ( ) ;
mGTaskHashMap . clear ( ) ;
mMetaHashMap . clear ( ) ;
@ -171,26 +199,28 @@ public class GTaskManager {
return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS ;
}
// 初始化Google 任务列表
// 初始化Google Tasks 任务列表相关信息，包括获取任务列表、元数据列表以及加载任务等操作
private void initGTaskList ( ) throws NetworkFailureException {
if ( mCancelled )
return ;
GTaskClient client = GTaskClient . getInstance ( ) ;
try {
// 从Google Tasks获取任务列表信息，
JSONArray jsTaskLists = client . getTaskLists ( ) ;
// 初始化元数据列表
// 先 初始化元数据列表，查找名为特定前缀加上"meta"的任务列表作为 元数据列表
mMetaList = null ;
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 ) ;
if ( name . equals ( GTaskStringUtils . MIUI_FOLDER_PREFFIX + GTaskStringUtils . FOLDER_META ) ) {
if ( name
. equals ( GTaskStringUtils . MIUI_FOLDER_PREFFIX + GTaskStringUtils . FOLDER_META ) ) {
mMetaList = new TaskList ( ) ;
mMetaList . setContentByRemoteJSON ( object ) ;
// 加载元数据
// 加载元数据 ，获取元数据列表对应的任务列表中的具体元数据信息
JSONArray jsMetas = client . getTaskList ( gid ) ;
for ( int j = 0 ; j < jsMetas . length ( ) ; j + + ) {
object = ( JSONObject ) jsMetas . getJSONObject ( j ) ;
@ -206,26 +236,29 @@ public class GTaskManager {
}
}
// 如果元数据列表不存在 则创建
// 如果元数据列表不存在 ， 一个新的元数据列表，
if ( mMetaList = = null ) {
mMetaList = new TaskList ( ) ;
mMetaList . setName ( GTaskStringUtils . MIUI_FOLDER_PREFFIX + GTaskStringUtils . FOLDER_META ) ;
mMetaList . setName ( GTaskStringUtils . MIUI_FOLDER_PREFFIX
+ GTaskStringUtils . FOLDER_META ) ;
GTaskClient . getInstance ( ) . createTaskList ( mMetaList ) ;
}
// 初始化 任务列表
// 初始化 普通 任务列表，遍历获取到的任务列表信息，创建任务列表对象并加载对应的任务信息
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 ) ;
if ( name . startsWith ( GTaskStringUtils . MIUI_FOLDER_PREFFIX ) & & ! name . equals ( GTaskStringUtils . MIUI_FOLDER_PREFFIX + GTaskStringUtils . FOLDER_META ) ) {
if ( name . startsWith ( GTaskStringUtils . MIUI_FOLDER_PREFFIX )
& & ! name . equals ( GTaskStringUtils . MIUI_FOLDER_PREFFIX
+ GTaskStringUtils . FOLDER_META ) ) {
TaskList tasklist = new TaskList ( ) ;
tasklist . setContentByRemoteJSON ( object ) ;
mGTaskListHashMap . put ( gid , tasklist ) ;
mGTaskHashMap . put ( gid , tasklist ) ;
// 加载任务
// 加载任务 ，获取当前任务列表对应的任务信息
JSONArray jsTasks = client . getTaskList ( gid ) ;
for ( int j = 0 ; j < jsTasks . length ( ) ; j + + ) {
object = ( JSONObject ) jsTasks . getJSONObject ( j ) ;
@ -247,7 +280,7 @@ public class GTaskManager {
}
}
// 同步内容到Google任务或本地数据库
// 进行内容同步操作， ，
private void syncContent ( ) throws NetworkFailureException {
int syncType ;
Cursor c = null ;
@ -260,9 +293,12 @@ public class GTaskManager {
return ;
}
// 同步本地删除的笔记
// 处理本地已删除的笔记（ ） ， ，
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 ) ;
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 ) ;
@ -284,12 +320,15 @@ public class GTaskManager {
}
}
// 同步文件夹
// 同步文件夹 相关信息
syncFolder ( ) ;
// 同步本地存在的笔记
// 处理数据库中已存在的笔记（ ） ， ，
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" ) ;
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 ) ;
@ -301,10 +340,10 @@ public class GTaskManager {
syncType = node . getSyncAction ( c ) ;
} else {
if ( c . getString ( SqlNote . GTASK_ID_COLUMN ) . trim ( ) . length ( ) = = 0 ) {
// 本地新增
// 本地新增 情况
syncType = Node . SYNC_ACTION_ADD_REMOTE ;
} else {
// 远程 删除
// 远程 已 删除情况
syncType = Node . SYNC_ACTION_DEL_LOCAL ;
}
}
@ -321,7 +360,7 @@ public class GTaskManager {
}
}
// 同步剩余的Google任务
// 处理剩余的在Google Tasks中存在但本地未处理的节点， （ ）
Iterator < Map . Entry < String , Node > > iter = mGTaskHashMap . entrySet ( ) . iterator ( ) ;
while ( iter . hasNext ( ) ) {
Map . Entry < String , Node > entry = iter . next ( ) ;
@ -329,14 +368,14 @@ public class GTaskManager {
doContentSync ( Node . SYNC_ACTION_ADD_LOCAL , node , null ) ;
}
// 清除本地删除的条目
// mCancelled可能被其他线程设置， ， （ ）
if ( ! mCancelled ) {
if ( ! DataUtils . batchDeleteNotes ( mContentResolver , mLocalDeleteIdMap ) ) {
throw new ActionFailureException ( "failed to batch-delete local deleted notes" ) ;
}
}
// 刷新本地同步ID
// 刷新本地同步ID （ ） ，
if ( ! mCancelled ) {
GTaskClient . getInstance ( ) . commitUpdate ( ) ;
refreshLocalSyncId ( ) ;
@ -344,7 +383,7 @@ public class GTaskManager {
}
// 同步文件夹 到Google任务或本地数据库
// 同步文件夹 相关信息，包括根文件夹、通话记录文件夹、本地已存在的文件夹以及远程新增的文件夹等情况的处理
private void syncFolder ( ) throws NetworkFailureException {
Cursor c = null ;
String gid ;
@ -355,9 +394,10 @@ public class GTaskManager {
return ;
}
// 同步根文件夹
// 处理根文件夹的同步情况， （ ）
try {
c = mContentResolver . query ( ContentUris . withAppendedId ( Notes . CONTENT_NOTE_URI , Notes . ID_ROOT_FOLDER ) , SqlNote . PROJECTION_NOTE , null , null , null ) ;
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 ) ;
@ -366,8 +406,9 @@ public class GTaskManager {
mGTaskHashMap . remove ( gid ) ;
mGidToNid . put ( gid , ( long ) Notes . ID_ROOT_FOLDER ) ;
mNidToGid . put ( ( long ) Notes . ID_ROOT_FOLDER , gid ) ;
// 更新远程名称（如果需要）
if ( ! node . getName ( ) . equals ( GTaskStringUtils . MIUI_FOLDER_PREFFIX + GTaskStringUtils . FOLDER_DEFAULT ) )
// 对于系统文件夹，仅在必要时更新远程名称
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 ) ;
@ -382,68 +423,101 @@ public class GTaskManager {
}
}
// 同步通话记录文件夹
// for call-note文件夹相关的同步操作处理
// 查询通话记录文件夹在本地数据库中的信息， （ ）
// 如果查询到该文件夹信息存在（ ） ，
try {
c = mContentResolver . query ( Notes . CONTENT_NOTE_URI , SqlNote . PROJECTION_NOTE , "(_id=?)" , new String [ ] { String . valueOf ( Notes . ID_CALL_RECORD_FOLDER ) } , null ) ;
// 通过ContentResolver查询本地数据库中通话记录文件夹的记录信息，
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 ( ) ) {
// 获取该文件夹在Google Tasks中对应的全局唯一ID（ ）
gid = c . getString ( SqlNote . GTASK_ID_COLUMN ) ;
// 根据GID从存储Google Tasks节点的哈希表中获取对应的节点对象
node = mGTaskHashMap . get ( gid ) ;
if ( node ! = null ) {
// 如果节点存在，从哈希表中移除该节点（表示已处理）
mGTaskHashMap . remove ( gid ) ;
// 在本地ID到Google Tasks的GID映射表中记录该文件夹的映射关系， ，
mGidToNid . put ( gid , ( long ) Notes . ID_CALL_RECORD_FOLDER ) ;
// 在Google Tasks的GID到本地ID映射表中记录映射关系， ，
mNidToGid . put ( ( long ) Notes . ID_CALL_RECORD_FOLDER , gid ) ;
// 更新远程名称（如果需要）
if ( ! node . getName ( ) . equals ( GTaskStringUtils . MIUI_FOLDER_PREFFIX + GTaskStringUtils . FOLDER_CALL_NOTE ) )
// 对于系统文件夹，仅在其名称与预期的通话记录文件夹名称不一致时（即可能有更新情况），进行远程更新操作
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 ;
}
}
// 同步本地存在的文件夹
// 处理本地已存在的文件夹的同步情况
// 查询本地除回收站外的文件夹记录信息，
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" ) ;
// 通过ContentResolver查询本地数据库中符合条件的文件夹记录信息，
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 ( ) ) {
// 获取文件夹在Google Tasks中对应的全局唯一ID（ ）
gid = c . getString ( SqlNote . GTASK_ID_COLUMN ) ;
// 根据GID从存储Google Tasks节点的哈希表中获取对应的节点对象
node = mGTaskHashMap . get ( gid ) ;
if ( node ! = null ) {
// 如果节点存在，从哈希表中移除该节点（表示已处理）
mGTaskHashMap . remove ( gid ) ;
// 在本地ID到Google Tasks的GID映射表中记录该文件夹的映射关系， ，
mGidToNid . put ( gid , c . getLong ( SqlNote . ID_COLUMN ) ) ;
// 在Google Tasks的GID到本地ID映射表中记录映射关系， ，
mNidToGid . put ( c . getLong ( SqlNote . ID_COLUMN ) , gid ) ;
// 获取该节点对应的同步操作类型（根据节点和游标信息判断是添加、更新、删除等哪种类型）
syncType = node . getSyncAction ( c ) ;
} else {
// 如果节点不存在， ，
if ( c . getString ( SqlNote . GTASK_ID_COLUMN ) . trim ( ) . length ( ) = = 0 ) {
// 本地新增
// 本地新增 情况，同步类型设置为添加远程节点
syncType = Node . SYNC_ACTION_ADD_REMOTE ;
} else {
// 远程删除
// 远程删除 情况，同步类型设置为删除本地节点
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 ;
}
}
// 同步远程新增的文件夹
// 处理远程新增文件夹的同步情况
// 遍历存储Google Tasks任务列表的哈希表，
// Tasks中存在但本地未处理（ ） ，
Iterator < Map . Entry < String , TaskList > > iter = mGTaskListHashMap . entrySet ( ) . iterator ( ) ;
while ( iter . hasNext ( ) ) {
Map . Entry < String , TaskList > entry = iter . next ( ) ;
@ -455,11 +529,12 @@ public class GTaskManager {
}
}
// 如果同步未被取消， （ ）
if ( ! mCancelled )
GTaskClient . getInstance ( ) . commitUpdate ( ) ;
}
// 执行内容同步操作
// 根据给定的同步类型 执行具体的 内容同步操作
private void doContentSync ( int syncType , Node node , Cursor c ) throws NetworkFailureException {
if ( mCancelled ) {
return ;
@ -467,12 +542,16 @@ public class GTaskManager {
MetaData meta ;
switch ( syncType ) {
// 同步类型为添加本地节点，调用相应方法进行本地节点添加操作
case Node . SYNC_ACTION_ADD_LOCAL :
addLocalNode ( node ) ;
break ;
// 同步类型为添加远程节点，调用相应方法进行远程节点添加操作，并传入节点和游标信息
case Node . SYNC_ACTION_ADD_REMOTE :
addRemoteNode ( node , c ) ;
break ;
// 同步类型为删除本地节点， ， ，
// 同时将本地记录的ID添加到本地已删除记录集合中
case Node . SYNC_ACTION_DEL_LOCAL :
meta = mMetaHashMap . get ( c . getString ( SqlNote . GTASK_ID_COLUMN ) ) ;
if ( meta ! = null ) {
@ -480,6 +559,8 @@ public class GTaskManager {
}
mLocalDeleteIdMap . add ( c . getLong ( SqlNote . ID_COLUMN ) ) ;
break ;
// 同步类型为删除远程节点， ， ，
// 然后再删除该节点本身
case Node . SYNC_ACTION_DEL_REMOTE :
meta = mMetaHashMap . get ( node . getGid ( ) ) ;
if ( meta ! = null ) {
@ -487,65 +568,84 @@ public class GTaskManager {
}
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" ) ;
}
}
// 在本地添加Google任务节点
// 添加本地节点的操作方法
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 ) ) {
// 如果节点名称是默认根文件夹的名称， ，
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 ) ) {
} 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的内容为节点的本地JSON格式内容（ ）
sqlNote . setContent ( node . getLocalJSONFromContent ( ) ) ;
// 设置父ID为根文件夹的本地ID
sqlNote . setParentId ( Notes . ID_ROOT_FOLDER ) ;
}
} else {
// 如果节点是普通任务（ ） ， ，
sqlNote = new SqlNote ( mContext ) ;
JSONObject js = node . getLocalJSONFromContent ( ) ;
try {
// 如果节点的本地JSON数据中包含特定的笔记头部信息（ ）
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 ) ;
// 检查该笔记ID在本地笔记数据库中是否已存在， （ ）
if ( DataUtils . existInNoteDatabase ( mContentResolver , id ) ) {
// ID不可用，
// the id is not available, have to create a new one
note . remove ( NoteColumns . ID ) ;
}
}
}
// 如果节点的本地JSON数据中包含特定的数据头部信息（ ）
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 ) ;
// 检查该数据ID在本地数据数据库中是否已存在， （ ）
if ( DataUtils . existInDataDatabase ( mContentResolver , dataId ) ) {
// Data ID不可用，
// the data id is not available, have to create
// a new one
data . remove ( DataColumns . ID ) ;
}
}
@ -556,52 +656,61 @@ public class GTaskManager {
Log . w ( TAG , e . toString ( ) ) ;
e . printStackTrace ( ) ;
}
// 设置SqlNote的内容为处理后的JSON数据
sqlNote . setContent ( js ) ;
// 获取任务节点的父节点在本地ID到Google Tasks的GID映射表中的对应父ID，
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的父ID为获取到的父节点的本地ID
sqlNote . setParentId ( parentId . longValue ( ) ) ;
}
// 创建本地节点
// 设置SqlNote的Google Tasks全局唯一ID（ ）
sqlNote . setGtaskId ( node . getGid ( ) ) ;
// 将SqlNote对象提交保存到本地数据库（ ）
sqlNote . commit ( false ) ;
// 更新GID-NID映射
// 在本地ID到Google Tasks的GID映射表中记录该节点的映射关系， ，
mGidToNid . put ( node . getGid ( ) , sqlNote . getId ( ) ) ;
// 在Google Tasks的GID到本地ID映射表中记录映射关系， ，
mNidToGid . put ( sqlNote . getId ( ) , node . getGid ( ) ) ;
// 更新 元数据
// 更新 远程 元数据，
updateRemoteMeta ( node . getGid ( ) , sqlNote ) ;
}
// 更新本地 Google任务 节点
// 更新本地 节点的操作方法
private void updateLocalNode ( Node node , Cursor c ) throws NetworkFailureException {
if ( mCancelled ) {
return ;
}
SqlNote sqlNote ;
// 更新本地笔记
// 根据传入的上下文和游标信息创建一个新的SqlNote对象，
sqlNote = new SqlNote ( mContext , c ) ;
// 设置SqlNote的内容为节点的本地JSON格式内容（ ）
sqlNote . setContent ( node . getLocalJSONFromContent ( ) ) ;
Long parentId = ( node instanceof Task ) ? mGidToNid . get ( ( ( Task ) node ) . getParent ( ) . getGid ( ) ) : new Long ( Notes . ID_ROOT_FOLDER ) ;
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的父ID为获取到的父节点的本地ID
sqlNote . setParentId ( parentId . longValue ( ) ) ;
// 将更新后的SqlNote对象提交保存到本地数据库（ ）
sqlNote . commit ( true ) ;
// 更新 元数据信息
// 更新 远程元数据，
updateRemoteMeta ( node . getGid ( ) , sqlNote ) ;
}
// 在Google任务中添加新的节点
// 添加远程节点的操作方法
private void addRemoteNode ( Node node , Cursor c ) throws NetworkFailureException {
if ( mCancelled ) {
return ;
@ -610,9 +719,10 @@ public class GTaskManager {
SqlNote sqlNote = new SqlNote ( mContext , c ) ;
Node n ;
// 远程更新
// 如果SqlNote对应的是笔记类型（ ）
if ( sqlNote . isNoteType ( ) ) {
Task task = new Task ( ) ;
// 设置任务的内容为从本地SqlNote获取的JSON格式内容
task . setContentByLocalJSON ( sqlNote . getContent ( ) ) ;
String parentGid = mNidToGid . get ( sqlNote . getParentId ( ) ) ;
@ -620,17 +730,20 @@ public class GTaskManager {
Log . e ( TAG , "cannot find task's parent tasklist" ) ;
throw new ActionFailureException ( "cannot add remote task" ) ;
}
// 将任务添加到对应的父任务列表中（ ）
mGTaskListHashMap . get ( parentGid ) . addChildTask ( task ) ;
// 通过Google Tasks客户端创建该任务（ ）
GTaskClient . getInstance ( ) . createTask ( task ) ;
n = ( Node ) task ;
// 添加元数据
// 更新远程元数据，
updateRemoteMeta ( task . getGid ( ) , sqlNote ) ;
} else {
TaskList tasklist = null ;
// 如果文件夹已经存在则跳过
// 构建文件夹名称， ， ， ，
// 否则添加SqlNote的摘要信息作为后缀
String folderName = GTaskStringUtils . MIUI_FOLDER_PREFFIX ;
if ( sqlNote . getId ( ) = = Notes . ID_ROOT_FOLDER )
folderName + = GTaskStringUtils . FOLDER_DEFAULT ;
@ -639,131 +752,179 @@ public class GTaskManager {
else
folderName + = sqlNote . getSnippet ( ) ;
// 遍历存储Google Tasks任务列表的哈希表（ ）
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 ;
// 如果在存储Google Tasks节点的哈希表（ ） ， ，
if ( mGTaskHashMap . containsKey ( gid ) ) {
mGTaskHashMap . remove ( gid ) ;
}
// 找到匹配的任务列表后就可以结束循环了
break ;
}
}
// 如果 没有匹配项则可以添加
// 如果 经过上述查找没有找到匹配的任务列表（ ） ，
if ( tasklist = = null ) {
tasklist = new TaskList ( ) ;
// 设置新任务列表的内容为从本地SqlNote获取的JSON格式内容
tasklist . setContentByLocalJSON ( sqlNote . getContent ( ) ) ;
// 通过Google Tasks客户端创建该任务列表（ ）
GTaskClient . getInstance ( ) . createTaskList ( tasklist ) ;
// 将新创建的任务列表添加到存储Google Tasks任务列表的哈希表中， ，
mGTaskListHashMap . put ( tasklist . getGid ( ) , tasklist ) ;
}
// 将创建或找到的任务列表对象转换为Node类型并赋值给n（ ， ）
n = ( Node ) tasklist ;
}
// 更新本地笔记
// 更新本地笔记相关信息
// 设置本地SqlNote的Google Tasks全局唯一ID（ ） ，
sqlNote . setGtaskId ( n . getGid ( ) ) ;
// 将SqlNote对象提交保存到本地数据库（ ， ）
sqlNote . commit ( false ) ;
// 重置本地修改标志（可能表示将本地记录标记为已与远程同步，不再是本地修改状态）
sqlNote . resetLocalModified ( ) ;
// 再次提交保存SqlNote对象到本地数据库（ ， ）
sqlNote . commit ( true ) ;
// GID-ID映射
// gid-id映射更新
// 在本地ID到Google Tasks的GID映射表（ ） （ ） ， ，
mGidToNid . put ( n . getGid ( ) , sqlNote . getId ( ) ) ;
// 在Google Tasks的GID到本地ID映射表（ ） ， ，
mNidToGid . put ( sqlNote . getId ( ) , n . getGid ( ) ) ;
}
// 在Google任务中 更新节点
// 更新远程 节点的操作方法
private void updateRemoteNode ( Node node , Cursor c ) throws NetworkFailureException {
if ( mCancelled ) {
return ;
}
// 根据传入的上下文和游标信息创建一个新的SqlNote对象，
SqlNote sqlNote = new SqlNote ( mContext , c ) ;
// 远程更新
// 远程更新操作
// 设置远程节点（ ） ，
node . setContentByLocalJSON ( sqlNote . getContent ( ) ) ;
// 通过Google Tasks客户端将更新后的节点添加到更新队列中（ ）
GTaskClient . getInstance ( ) . addUpdateNode ( node ) ;
// 更新 元数据
// 更新 远程 元数据，
updateRemoteMeta ( node . getGid ( ) , sqlNote ) ;
// 如果 需要移动任务
// 如果 SqlNote对应的是笔记类型（ ） ，
if ( sqlNote . isNoteType ( ) ) {
Task task = ( Task ) node ;
// 获取任务当前的父任务列表
TaskList preParentList = task . getParent ( ) ;
// 通过本地ID到Google Tasks的GID映射表，
String curParentGid = mNidToGid . get ( sqlNote . getParentId ( ) ) ;
if ( curParentGid = = null ) {
Log . e ( TAG , "cannot find task's parent tasklist" ) ;
throw new ActionFailureException ( "cannot update remote task" ) ;
}
// 根据获取到的GID从存储Google Tasks任务列表的哈希表中获取当前任务在远程对应的父任务列表对象
TaskList curParentList = mGTaskListHashMap . get ( curParentGid ) ;
// 如果当前任务的前后父任务列表不一致，说明任务需要在远程进行移动操作
if ( preParentList ! = curParentList ) {
// 先从原父任务列表中移除该任务
preParentList . removeChildTask ( task ) ;
// 将任务添加到新的父任务列表中
curParentList . addChildTask ( task ) ;
// 通过Google Tasks客户端执行任务移动操作，
GTaskClient . getInstance ( ) . moveTask ( task , preParentList , curParentList ) ;
}
}
// 清除本地修改标志
// 清除本地修改标志 ，标记本地记录已同步到远程，不再处于本地修改状态
sqlNote . resetLocalModified ( ) ;
// 将更新后的SqlNote对象提交保存到本地数据库（ ， ）
sqlNote . commit ( true ) ;
}
// 更新 Google任务中的元数据
// 更新 远程元数据的操作方法
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 ( ) ) ;
// 通过Google Tasks客户端将更新后的元数据添加到更新队列中（ ）
GTaskClient . getInstance ( ) . addUpdateNode ( metaData ) ;
} else {
// 如果元数据对象不存在，则创建一个新的元数据对象
metaData = new MetaData ( ) ;
// 设置新元数据对象的元数据内容，
metaData . setMeta ( gid , sqlNote . getContent ( ) ) ;
// 将新创建的元数据对象添加到元数据列表（ ） （ ）
mMetaList . addChildTask ( metaData ) ;
// 将新创建的元数据对象添加到存储元数据的哈希表中， ，
mMetaHashMap . put ( gid , metaData ) ;
// 通过Google Tasks客户端创建该元数据任务（ ）
GTaskClient . getInstance ( ) . createTask ( metaData ) ;
}
}
}
// 刷新本地同步ID
// 刷新本地同步ID 的操作方法
private void refreshLocalSyncId ( ) throws NetworkFailureException {
if ( mCancelled ) {
return ;
}
// 获取最新的Google任务列 表
// 为了获取最新的Google Tasks列表信息， 表
mGTaskHashMap . clear ( ) ;
mGTaskListHashMap . clear ( ) ;
mMetaHashMap . clear ( ) ;
// 重新初始化Google Tasks列表信息（ ）
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" ) ;
// 通过ContentResolver查询本地数据库中除系统类型且不在回收站的笔记记录信息，
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" ) ;
if ( c ! = null ) {
while ( c . moveToNext ( ) ) {
// 获取笔记在Google Tasks中对应的全局唯一ID（ ）
String gid = c . getString ( SqlNote . GTASK_ID_COLUMN ) ;
// 根据GID从存储Google Tasks节点的哈希表中获取对应的节点对象
Node node = mGTaskHashMap . get ( gid ) ;
if ( node ! = null ) {
// 如果节点存在，从哈希表中移除该节点（表示已处理）
mGTaskHashMap . remove ( gid ) ;
// 创建一个ContentValues对象用于存放要更新的数据，
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 ) ;
// 通过ContentResolver更新本地数据库中对应笔记的记录，
mContentResolver . update ( ContentUris . withAppendedId ( Notes . CONTENT_NOTE_URI ,
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" ) ;
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 ;
@ -771,13 +932,14 @@ public class GTaskManager {
}
}
// 获取同步账户
// 获取同步账户 名称的方法， ，
public String getSyncAccount ( ) {
return GTaskClient . getInstance ( ) . getSyncAccount ( ) . name ;
}
// 取消同步
// 取消同步 的方法， （ ） ，
public void cancelSync ( ) {
mCancelled = true ;
}
}
}
> > > > > > > a495b394fa4686564cc2bfe7d054eb66276713ae
