1

Notes-master/src/net/micode/notes/gtask/data/MetaData.java

@@ -24,34 +24,61 @@ import net.micode.notes.tool.GTaskStringUtils;
 import org.json.JSONException;
 import org.json.JSONObject;
 
-
+/**
+ * 元数据类，继承自Task类，用于处理与Google Task相关的元数据信息
+ */
 public class MetaData extends Task {
+    // 日志标签
     private final static String TAG = MetaData.class.getSimpleName();
 
+    // 关联的Google Task ID
     private String mRelatedGid = null;
 
+    /**
+     * 设置元数据信息
+     * @param gid 关联的Google Task ID
+     * @param metaInfo 包含元数据的JSON对象
+     */
     public void setMeta(String gid, JSONObject metaInfo) {
         try {
+            // 将关联的Google Task ID添加到元数据中
             metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
         } catch (JSONException e) {
             Log.e(TAG, "failed to put related gid");
         }
+        // 将元数据JSON对象转换为字符串并设置为notes
         setNotes(metaInfo.toString());
+        // 设置元数据的名称
         setName(GTaskStringUtils.META_NOTE_NAME);
     }
 
+    /**
+     * 获取关联的Google Task ID
+     * @return 关联的Google Task ID
+     */
     public String getRelatedGid() {
         return mRelatedGid;
     }
 
+    /**
+     * 判断是否需要保存
+     * @return 如果notes不为null则返回true，否则返回false
+     */
     @Override
     public boolean isWorthSaving() {
         return getNotes() != null;
     }
 
+    /**
+     * 根据远程JSON数据设置内容
+     * @param js 包含远程数据的JSON对象
+     */
     @Override
     public void setContentByRemoteJSON(JSONObject js) {
+        // 调用父类方法设置基本内容
         super.setContentByRemoteJSON(js);
+        
+        // 如果notes不为空，尝试解析其中的关联Google Task ID
         if (getNotes() != null) {
             try {
                 JSONObject metaInfo = new JSONObject(getNotes().trim());
@@ -63,20 +90,35 @@ public class MetaData extends Task {
         }
     }
 
+    /**
+     * 根据本地JSON数据设置内容（不应被调用）
+     * @param js 包含本地数据的JSON对象
+     * @throws IllegalAccessError 总是抛出此异常
+     */
     @Override
     public void setContentByLocalJSON(JSONObject js) {
-        // this function should not be called
+        // 此方法不应被调用，因为元数据不存储本地内容
         throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
     }
 
+    /**
+     * 从内容获取本地JSON对象（不应被调用）
+     * @throws IllegalAccessError 总是抛出此异常
+     */
     @Override
     public JSONObject getLocalJSONFromContent() {
+        // 此方法不应被调用，因为元数据不存储本地内容
         throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
     }
 
+    /**
+     * 获取同步操作（不应被调用）
+     * @param c 数据库游标
+     * @throws IllegalAccessError 总是抛出此异常
+     */
     @Override
     public int getSyncAction(Cursor c) {
+        // 此方法不应被调用，因为元数据不需要同步操作
         throw new IllegalAccessError("MetaData:getSyncAction should not be called");
     }
-
 }

Notes-master/src/net/micode/notes/gtask/data/Node.java

@@ -20,33 +20,31 @@ 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_NONE = 0;          // 无同步操作
-    public static final int SYNC_ACTION_ADD_REMOTE = 1;
+    public static final int SYNC_ACTION_ADD_REMOTE = 1;    // 添加远程节点
-
+    public static final int SYNC_ACTION_ADD_LOCAL = 2;     // 添加本地节点
-    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_DEL_REMOTE = 3;
+    public static final int SYNC_ACTION_UPDATE_REMOTE = 5; // 更新远程节点
-
+    public static final int SYNC_ACTION_UPDATE_LOCAL = 6;  // 更新本地节点
-    public static final int SYNC_ACTION_DEL_LOCAL = 4;
+    public static final int SYNC_ACTION_UPDATE_CONFLICT = 7; // 更新冲突
-
+    public static final int SYNC_ACTION_ERROR = 8;         // 同步错误
-    public static final int SYNC_ACTION_UPDATE_REMOTE = 5;
+
-
+    // 节点属性
-    public static final int SYNC_ACTION_UPDATE_LOCAL = 6;
+    private String mGid;           // 全局唯一标识符
-
+    private String mName;          // 节点名称
-    public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;
+    private long mLastModified;    // 最后修改时间戳
-
+    private boolean mDeleted;      // 删除标记
-    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 = "";
@@ -54,48 +52,108 @@ public abstract class Node {
         mDeleted = false;
     }
 
+    /**
+     * 获取创建操作的JSON对象
+     * @param actionId 操作ID
+     * @return 包含创建操作的JSON对象
+     */
     public abstract JSONObject getCreateAction(int actionId);
 
+    /**
+     * 获取更新操作的JSON对象
+     * @param actionId 操作ID
+     * @return 包含更新操作的JSON对象
+     */
     public abstract JSONObject getUpdateAction(int actionId);
 
+    /**
+     * 根据远程JSON数据设置节点内容
+     * @param js 包含远程数据的JSON对象
+     */
     public abstract void setContentByRemoteJSON(JSONObject js);
 
+    /**
+     * 根据本地JSON数据设置节点内容
+     * @param js 包含本地数据的JSON对象
+     */
     public abstract void setContentByLocalJSON(JSONObject js);
 
+    /**
+     * 从节点内容获取本地JSON对象
+     * @return 包含本地数据的JSON对象
+     */
     public abstract JSONObject getLocalJSONFromContent();
 
+    /**
+     * 获取同步操作类型
+     * @param c 数据库游标，指向当前节点数据
+     * @return 同步操作类型常量
+     */
     public abstract int getSyncAction(Cursor c);
 
+    // 以下是属性的getter和setter方法
+
+    /**
+     * 设置全局唯一标识符
+     * @param gid 全局唯一标识符
+     */
     public void setGid(String gid) {
         this.mGid = gid;
     }
 
+    /**
+     * 设置节点名称
+     * @param name 节点名称
+     */
     public void setName(String name) {
         this.mName = name;
     }
 
+    /**
+     * 设置最后修改时间
+     * @param lastModified 最后修改时间戳
+     */
     public void setLastModified(long lastModified) {
         this.mLastModified = lastModified;
     }
 
+    /**
+     * 设置删除标记
+     * @param deleted 是否已删除
+     */
     public void setDeleted(boolean deleted) {
         this.mDeleted = deleted;
     }
 
+    /**
+     * 获取全局唯一标识符
+     * @return 全局唯一标识符
+     */
     public String getGid() {
         return this.mGid;
     }
 
+    /**
+     * 获取节点名称
+     * @return 节点名称
+     */
     public String getName() {
         return this.mName;
     }
 
+    /**
+     * 获取最后修改时间
+     * @return 最后修改时间戳
+     */
     public long getLastModified() {
         return this.mLastModified;
     }
 
+    /**
+     * 获取删除标记
+     * @return 是否已删除
+     */
     public boolean getDeleted() {
         return this.mDeleted;
     }
-
 }

Notes-master/src/net/micode/notes/gtask/data/SqlData.java

@@ -34,54 +34,60 @@ import net.micode.notes.gtask.exception.ActionFailureException;
 import org.json.JSONException;
 import org.json.JSONObject;
 
-
+/**
+ * 数据库数据操作类，负责Note数据的CRUD操作
+ * 封装了对SQLite数据库的访问逻辑
+ */
 public class SqlData {
-    private static final String TAG = SqlData.class.getSimpleName();
+    private static final String TAG = SqlData.class.getSimpleName(); // 日志标签
 
-    private static final int INVALID_ID = -99999;
+    private static final int INVALID_ID = -99999; // 无效ID标识
 
+    // 数据列投影定义，用于查询操作
     public static final String[] PROJECTION_DATA = new String[] {
-            DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
+            DataColumns.ID,           // 0: 数据ID
-            DataColumns.DATA3
+            DataColumns.MIME_TYPE,    // 1: MIME类型
+            DataColumns.CONTENT,     // 2: 内容
+            DataColumns.DATA1,       // 3: 数据字段1
+            DataColumns.DATA3        // 4: 数据字段3
     };
 
-    public static final int DATA_ID_COLUMN = 0;
+    // 列索引常量定义
-
+    public static final int DATA_ID_COLUMN = 0;             // ID列索引
-    public static final int DATA_MIME_TYPE_COLUMN = 1;
+    public static final int DATA_MIME_TYPE_COLUMN = 1;      // MIME类型列索引
-
+    public static final int DATA_CONTENT_COLUMN = 2;        // 内容列索引
-    public static final int DATA_CONTENT_COLUMN = 2;
+    public static final int DATA_CONTENT_DATA_1_COLUMN = 3; // 数据字段1列索引
-
+    public static final int DATA_CONTENT_DATA_3_COLUMN = 4; // 数据字段3列索引
-    public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
+
-
+    private ContentResolver mContentResolver; // 内容解析器，用于访问ContentProvider
-    public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
+    private boolean mIsCreate;               // 是否为新创建记录标志
-
+    private long mDataId;                    // 数据ID
-    private ContentResolver mContentResolver;
+    private String mDataMimeType;            // MIME类型
-
+    private String mDataContent;             // 内容数据
-    private boolean mIsCreate;
+    private long mDataContentData1;          // 数据字段1
-
+    private String mDataContentData3;        // 数据字段3
-    private long mDataId;
+    private ContentValues mDiffDataValues;   // 存储差异数据的键值对
-
+
-    private String mDataMimeType;
+    /**
-
+     * 构造函数，用于创建新记录
-    private String mDataContent;
+     * @param context 上下文对象
-
+     */
-    private long mDataContentData1;
-
-    private String mDataContentData3;
-
-    private ContentValues mDiffDataValues;
-
     public SqlData(Context context) {
         mContentResolver = context.getContentResolver();
         mIsCreate = true;
         mDataId = INVALID_ID;
-        mDataMimeType = DataConstants.NOTE;
+        mDataMimeType = DataConstants.NOTE; // 默认MIME类型为NOTE
         mDataContent = "";
         mDataContentData1 = 0;
         mDataContentData3 = "";
         mDiffDataValues = new ContentValues();
     }
 
+    /**
+     * 构造函数，从游标加载已有记录
+     * @param context 上下文对象
+     * @param c 数据库游标，包含已有记录数据
+     */
     public SqlData(Context context, Cursor c) {
         mContentResolver = context.getContentResolver();
         mIsCreate = false;
@@ -89,6 +95,10 @@ public class SqlData {
         mDiffDataValues = new ContentValues();
     }
 
+    /**
+     * 从游标加载数据到对象
+     * @param c 数据库游标
+     */
     private void loadFromCursor(Cursor c) {
         mDataId = c.getLong(DATA_ID_COLUMN);
         mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
@@ -97,13 +107,20 @@ public class SqlData {
         mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
     }
 
+    /**
+     * 设置内容数据
+     * @param js 包含数据的JSON对象
+     * @throws JSONException JSON解析异常
+     */
     public void setContent(JSONObject js) throws JSONException {
+        // 设置ID字段
         long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
         if (mIsCreate || mDataId != dataId) {
             mDiffDataValues.put(DataColumns.ID, dataId);
         }
         mDataId = dataId;
 
+        // 设置MIME类型字段
         String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)
                 : DataConstants.NOTE;
         if (mIsCreate || !mDataMimeType.equals(dataMimeType)) {
@@ -111,18 +128,21 @@ public class SqlData {
         }
         mDataMimeType = dataMimeType;
 
+        // 设置内容字段
         String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : "";
         if (mIsCreate || !mDataContent.equals(dataContent)) {
             mDiffDataValues.put(DataColumns.CONTENT, dataContent);
         }
         mDataContent = dataContent;
 
+        // 设置数据字段1
         long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0;
         if (mIsCreate || mDataContentData1 != dataContentData1) {
             mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
         }
         mDataContentData1 = dataContentData1;
 
+        // 设置数据字段3
         String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : "";
         if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {
             mDiffDataValues.put(DataColumns.DATA3, dataContentData3);
@@ -130,6 +150,11 @@ public class SqlData {
         mDataContentData3 = dataContentData3;
     }
 
+    /**
+     * 获取内容数据的JSON表示
+     * @return 包含数据的JSON对象
+     * @throws JSONException JSON构造异常
+     */
     public JSONObject getContent() throws JSONException {
         if (mIsCreate) {
             Log.e(TAG, "it seems that we haven't created this in database yet");
@@ -144,9 +169,15 @@ public class SqlData {
         return js;
     }
 
+    /**
+     * 提交数据到数据库
+     * @param noteId 关联的Note ID
+     * @param validateVersion 是否验证版本
+     * @param version 版本号
+     */
     public void commit(long noteId, boolean validateVersion, long version) {
-
         if (mIsCreate) {
+            // 创建新记录
             if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
                 mDiffDataValues.remove(DataColumns.ID);
             }
@@ -154,24 +185,29 @@ public class SqlData {
             mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
             Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
             try {
+                // 从返回的URI中解析出新记录的ID
                 mDataId = Long.valueOf(uri.getPathSegments().get(1));
             } catch (NumberFormatException e) {
                 Log.e(TAG, "Get note id error :" + e.toString());
                 throw new ActionFailureException("create note failed");
             }
         } else {
+            // 更新现有记录
             if (mDiffDataValues.size() > 0) {
                 int result = 0;
                 if (!validateVersion) {
-                    result = mContentResolver.update(ContentUris.withAppendedId(
+                    // 不验证版本直接更新
-                            Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
+                    result = mContentResolver.update(
+                        ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, mDataId), 
+                        mDiffDataValues, null, null);
                 } else {
-                    result = mContentResolver.update(ContentUris.withAppendedId(
+                    // 带版本验证的更新
-                            Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
+                    result = mContentResolver.update(
+                        ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, mDataId), 
+                        mDiffDataValues,
                         " ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
-                                    + " WHERE " + NoteColumns.VERSION + "=?)", new String[] {
+                                + " WHERE " + NoteColumns.VERSION + "=?)", 
-                                    String.valueOf(noteId), String.valueOf(version)
+                        new String[] { String.valueOf(noteId), String.valueOf(version) });
-                            });
                 }
                 if (result == 0) {
                     Log.w(TAG, "there is no update. maybe user updates note when syncing");
@@ -179,10 +215,15 @@ public class SqlData {
             }
         }
 
+        // 重置状态
         mDiffDataValues.clear();
         mIsCreate = false;
     }
 
+    /**
+     * 获取数据ID
+     * @return 数据ID
+     */
     public long getId() {
         return mDataId;
     }