Update SqlNote.java

src/gtask/data/SqlNote.java

@@ -5,18 +5,11 @@
  */
  
 package net.micode.notes.gtask.data;
-/*
- * 功能描述：
- * 实现过程：
- * 参数注解： 
- * Made By CuiCan
- */
 
 public class SqlNote {
 	/*
 	 * 功能描述：得到类的简写名称存入字符串TAG中
 	 * 实现过程：调用getSimpleName ()函数
-	 * Made By CuiCan
 	 */
     private static final String TAG = SqlNote.class.getSimpleName();
  
@@ -106,8 +99,6 @@ public class SqlNote {
     /*
      * 功能描述：构造函数
      * 参数注解： mIsCreate用于标示构造方式
-     * 参数注解： 
-     * Made By CuiCan
      */
     //构造函数只有context，对所有的变量进行初始化
     public SqlNote(Context context) {
@@ -135,8 +126,6 @@ public class SqlNote {
     /*
      * 功能描述：构造函数
      * 参数注解： mIsCreate用于标示构造方式
-     * 参数注解： 
-     * Made By CuiCan
      */
     //构造函数有context和一个数据库的cursor，多数变量通过cursor指向的一条记录直接进行初始化
     public SqlNote(Context context, Cursor c) {
@@ -155,8 +144,6 @@ public class SqlNote {
     /*
      * 功能描述：构造函数
      * 参数注解： mIsCreate用于标示构造方式
-     * 参数注解： 
-     * Made By CuiCan
      */
     public SqlNote(Context context, long id) {
         mContext = context;
@@ -172,7 +159,6 @@ public class SqlNote {
  
     /*
      * 功能描述：通过id从光标处加载数据
-     * Made By CuiCan
      */
     private void loadFromCursor(long id) {
         Cursor c = null;
@@ -196,7 +182,6 @@ public class SqlNote {
  
     /*
      * 功能描述：通过游标从光标处加载数据
-     * Made By CuiCan
      */
     private void loadFromCursor(Cursor c) {
     	//直接从一条记录中的获得以下变量的初始值
@@ -216,188 +201,216 @@ public class SqlNote {
  
     /*
      * 功能描述：通过content机制获取共享数据并加载到数据库当前游标处
-     * 参数注解： 
-     * Made By CuiCan
      */
     private void loadDataContent() {
-        Cursor c = null;
+        Cursor c = null; // 初始化一个游标对象 c
-        mDataList.clear();
+
+        mDataList.clear(); // 清空 mDataList，这可能是一个用于存储从内容提供者检索到的数据的列表
+
         try {
-            c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,
+            // 使用内容解析器（mContentResolver）查询 Notes.CONTENT_DATA_URI，根据指定的 note_id 检索数据
-                    "(note_id=?)", new String[] {
+            c = mContentResolver.query(
-                        String.valueOf(mId)
+                Notes.CONTENT_DATA_URI, // 数据的 URI
-                    }, null);
+                SqlData.PROJECTION_DATA, // 要检索的列投影
+                "(note_id=?)", // 选择条件，基于 note_id
+                new String[] { String.valueOf(mId) }, // 选择条件中的参数，替换 note_id 的占位符
+                null
+            );
+
             if (c != null) {
                 if (c.getCount() == 0) {
-                    Log.w(TAG, "it seems that the note has not data");
+                    Log.w(TAG, "似乎该笔记没有数据"); // 如果游标中没有数据，记录一个警告日志
                     return;
                 }
+
+                // 遍历游标中的数据，创建 SqlData 对象并添加到 mDataList 中
                 while (c.moveToNext()) {
                     SqlData data = new SqlData(mContext, c);
                     mDataList.add(data);
                 }
             } else {
-                Log.w(TAG, "loadDataContent: cursor = null");
+                Log.w(TAG, "loadDataContent: cursor = null"); // 如果游标为空，记录一个警告日志
             }
         } finally {
             if (c != null)
-                c.close();
+                c.close(); // 在最终块中确保关闭游标，释放资源
         }
     }
 
+    
+ 
     /*
      * 功能描述：设置通过content机制用于共享的数据信息
-     * 参数注解： 
-     * Made By CuiCan
      */
       public boolean setContent(JSONObject js) {
       try {
+          // 从传入的 JSON 对象中获取笔记对象
           JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+
+          // 检查笔记的类型，如果是系统文件夹则记录一个警告日志
           if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
-                Log.w(TAG, "cannot set system folder");
+              Log.w(TAG, "无法设置系统文件夹");
           } 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) : "";
+              // 获取摘要，如果没有则设置为空字符串
+              String snippet = note.has(NoteColumns.SNIPPET) ? note.getString(NoteColumns.SNIPPET) : "";
+
+              // 如果是创建操作或者摘要发生变化，则将摘要加入 mDiffNoteValues 中
               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
-                        : Notes.TYPE_NOTE;
+              int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) : Notes.TYPE_NOTE;
+
+              // 如果是创建操作或者类型发生变化，则将类型加入 mDiffNoteValues 中
               if (mIsCreate || mType != type) {
                   mDiffNoteValues.put(NoteColumns.TYPE, type);
               }
               mType = type;
           } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) {
+              // 处理笔记类型为 Note 的情况
+
+              // 从 JSON 中获取数据数组
               JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
+
+              // 获取笔记 ID，如果没有则设置为 INVALID_ID
               long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID;
+
+              // 如果是创建操作或者 ID 发生变化，则将 ID 加入 mDiffNoteValues 中
               if (mIsCreate || mId != id) {
                   mDiffNoteValues.put(NoteColumns.ID, id);
               }
               mId = id;
 
-                long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note
+              // 获取提醒日期，如果没有则设置为 0
-                        .getLong(NoteColumns.ALERTED_DATE) : 0;
+              long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note.getLong(NoteColumns.ALERTED_DATE) : 0;
+
+              // 如果是创建操作或者提醒日期发生变化，则将提醒日期加入 mDiffNoteValues 中
               if (mIsCreate || mAlertDate != alertDate) {
                   mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate);
               }
               mAlertDate = alertDate;
 
-                int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note
+              // 获取背景颜色 ID，如果没有则设置为默认值
-                        .getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext);
+              int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note.getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext);
+
+              // 如果是创建操作或者背景颜色 ID 发生变化，则将背景颜色 ID 加入 mDiffNoteValues 中
               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();
+              // 获取创建日期，如果没有则设置为当前时间
+              long createDate = note.has(NoteColumns.CREATED_DATE) ? note.getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis();
+
+              // 如果是创建操作或者创建日期发生变化，则将创建日期加入 mDiffNoteValues 中
               if (mIsCreate || mCreatedDate != createDate) {
                   mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate);
               }
               mCreatedDate = createDate;
 
-                int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note
+              // 获取是否有附件，如果没有则设置为 0
-                        .getInt(NoteColumns.HAS_ATTACHMENT) : 0;
+              int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note.getInt(NoteColumns.HAS_ATTACHMENT) : 0;
+
+              // 如果是创建操作或者是否有附件发生变化，则将是否有附件加入 mDiffNoteValues 中
               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();
+              long modifiedDate = note.has(NoteColumns.MODIFIED_DATE) ? note.getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis();
+
+              // 如果是创建操作或者修改日期发生变化，则将修改日期加入 mDiffNoteValues 中
               if (mIsCreate || mModifiedDate != modifiedDate) {
                   mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate);
               }
               mModifiedDate = modifiedDate;
 
-                long parentId = note.has(NoteColumns.PARENT_ID) ? note
+              // 获取父级 ID，如果没有则设置为 0
-                        .getLong(NoteColumns.PARENT_ID) : 0;
+              long parentId = note.has(NoteColumns.PARENT_ID) ? note.getLong(NoteColumns.PARENT_ID) : 0;
+
+              // 如果是创建操作或者父级 ID 发生变化，则将父级 ID 加入 mDiffNoteValues 中
               if (mIsCreate || mParentId != parentId) {
                   mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId);
               }
               mParentId = parentId;
 
-                String snippet = note.has(NoteColumns.SNIPPET) ? note
+              // 获取摘要，如果没有则设置为空字符串
-                        .getString(NoteColumns.SNIPPET) : "";
+              String snippet = note.has(NoteColumns.SNIPPET) ? note.getString(NoteColumns.SNIPPET) : "";
+
+              // 如果是创建操作或者摘要发生变化，则将摘要加入 mDiffNoteValues 中
               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
-                        : Notes.TYPE_NOTE;
+              int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) : Notes.TYPE_NOTE;
+
+              // 如果是创建操作或者类型发生变化，则将类型加入 mDiffNoteValues 中
               if (mIsCreate || mType != type) {
                   mDiffNoteValues.put(NoteColumns.TYPE, type);
               }
               mType = type;
 
-                int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID)
+              // 获取小部件 ID，如果没有则设置为 AppWidgetManager.INVALID_APPWIDGET_ID
-                        : AppWidgetManager.INVALID_APPWIDGET_ID;
+              int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID) : AppWidgetManager.INVALID_APPWIDGET_ID;
+
+              // 如果是创建操作或者小部件 ID 发生变化，则将小部件 ID 加入 mDiffNoteValues 中
               if (mIsCreate || mWidgetId != widgetId) {
                   mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId);
               }
               mWidgetId = widgetId;
 
-                int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note
+              // 获取小部件类型，如果没有则设置为 Notes.TYPE_WIDGET_INVALIDE
-                        .getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE;
+              int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note.getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE;
+
+              // 如果是创建操作或者小部件类型发生变化，则将小部件类型加入 mDiffNoteValues 中
               if (mIsCreate || mWidgetType != widgetType) {
                   mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType);
               }
               mWidgetType = widgetType;
 
-                long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note
+              // 获取原始父级 ID，如果没有则设置为 0
-                        .getLong(NoteColumns.ORIGIN_PARENT_ID) : 0;
+              long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note.getLong(NoteColumns.ORIGIN_PARENT_ID) : 0;
+
+              // 如果是创建操作或者原始父级 ID 发生变化，则将原始父级 ID 加入 mDiffNoteValues 中
               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) {
+          // 如果发生异常，记录错误日志并返回 false
           Log.e(TAG, e.toString());
           e.printStackTrace();
           return false;
       }
-        return true;
+      return true; // 如果没有发生异常，返回 true 表示设置成功
   }
 
+ 
     /*
      * 功能描述：获取content机制提供的数据并加载到note中
-     * 参数注解： 
-     * Made By CuiCan
      */
     public JSONObject getContent() {
         try {
             JSONObject js = new JSONObject();
 
+            // 如果是创建操作而没有在数据库中创建记录，记录一个错误日志并返回 null
             if (mIsCreate) {
-                Log.e(TAG, "it seems that we haven't created this in database yet");
+                Log.e(TAG, "似乎我们还没有在数据库中创建这个记录");
                 return null;
             }
 
             JSONObject note = new JSONObject();
-            if (mType == Notes.TYPE_NOTE) {//类型为note时
+
+            // 根据笔记的类型填充 note 对象的属性
+            if (mType == Notes.TYPE_NOTE) { // 类型为 Note 时
                 note.put(NoteColumns.ID, mId);
                 note.put(NoteColumns.ALERTED_DATE, mAlertDate);
                 note.put(NoteColumns.BG_COLOR_ID, mBgColorId);
@@ -420,7 +433,7 @@ public class SqlNote {
                     }
                 }
                 js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
-            } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {//类型为文件夹或者
+            } 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);
@@ -435,10 +448,9 @@ public class SqlNote {
         return null;
     }
 
+ 
     /*
      * 功能描述：给当前id设置父id
-     * 参数注解： 
-     * Made By CuiCan
      */
     public void setParentId(long id) {
         mParentId = id;
@@ -447,8 +459,6 @@ public class SqlNote {
  
     /*
      * 功能描述：给当前id设置Gtaskid
-     * 参数注解： 
-     * Made By CuiCan
      */
     public void setGtaskId(String gid) {
         mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
@@ -456,8 +466,6 @@ public class SqlNote {
  
     /*
      * 功能描述：给当前id设置同步id
-     * 参数注解： 
-     * Made By CuiCan
      */
     public void setSyncId(long syncId) {
         mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
@@ -465,8 +473,6 @@ public class SqlNote {
  
     /*
      * 功能描述：初始化本地修改，即撤销所有当前修改
-     * 参数注解： 
-     * Made By CuiCan
      */
     public void resetLocalModified() {
         mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
@@ -474,8 +480,6 @@ public class SqlNote {
  
     /*
      * 功能描述：获得当前id
-     * 参数注解： 
-     * Made By CuiCan
      */
     public long getId() {
         return mId;
@@ -483,8 +487,6 @@ public class SqlNote {
  
     /*
      * 功能描述：获得当前id的父id
-     * 参数注解： 
-     * Made By CuiCan
      */
     public long getParentId() {
         return mParentId;
@@ -492,8 +494,6 @@ public class SqlNote {
  
     /*
      * 功能描述：获取小片段即用于显示的部分便签内容
-     * 参数注解： 
-     * Made By CuiCan
      */
     public String getSnippet() {
         return mSnippet;
@@ -501,8 +501,6 @@ public class SqlNote {
  
     /*
      * 功能描述：判断是否为便签类型
-     * 参数注解： 
-     * Made By CuiCan
      */
     public boolean isNoteType() {
         return mType == Notes.TYPE_NOTE;
@@ -510,8 +508,6 @@ public class SqlNote {
  
     /*
      * 功能描述：commit函数用于把当前造作所做的修改保存到数据库
-     * 参数注解： 
-     * Made By CuiCan
      */
      public void commit(boolean validateVersion) {
       if (mIsCreate) {
@@ -519,31 +515,40 @@ public class SqlNote {
               mDiffNoteValues.remove(NoteColumns.ID);
           }
 
+          // 将差异的笔记值插入数据库
           Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
+
           try {
+              // 获取插入记录的ID并更新到当前对象的mId属性
               mId = Long.valueOf(uri.getPathSegments().get(1));
           } catch (NumberFormatException e) {
-                Log.e(TAG, "Get note id error :" + e.toString());
+              Log.e(TAG, "获取笔记ID出错：" + e.toString());
-                throw new ActionFailureException("create note failed");
+              throw new ActionFailureException("创建笔记失败");
           }
+
           if (mId == 0) {
-                throw new IllegalStateException("Create thread id failed");
+              throw new IllegalStateException("创建笔记ID失败");
           }
 
+          // 如果笔记类型为 Notes.TYPE_NOTE，提交关联的 SqlData 列表
           if (mType == Notes.TYPE_NOTE) {
-                for (SqlData sqlData : mDataList) {//直接使用sqldata中的实现
+              for (SqlData sqlData : mDataList) {
                   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");
+              Log.e(TAG, "没有这样的笔记");
-                throw new IllegalStateException("Try to update note with invalid id");
+              throw new IllegalStateException("尝试使用无效ID更新笔记");
           }
+
           if (mDiffNoteValues.size() > 0) {
               mVersion++;
+
+              // 构造更新条件和参数
               int result = 0;
-                if (!validateVersion) {//构造字符串
+              if (!validateVersion) {
                   result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
                           + NoteColumns.ID + "=?)", new String[] {
                       String.valueOf(mId)
@@ -555,11 +560,13 @@ public class SqlNote {
                                   String.valueOf(mId), String.valueOf(mVersion)
                           });
               }
+
               if (result == 0) {
-                    Log.w(TAG, "there is no update. maybe user updates note when syncing");
+                  Log.w(TAG, "没有更新。可能是用户在同步时更新了笔记");
               }
           }
 
+          // 如果笔记类型为 Notes.TYPE_NOTE，提交关联的 SqlData 列表
           if (mType == Notes.TYPE_NOTE) {
               for (SqlData sqlData : mDataList) {
                   sqlData.commit(mId, validateVersion, mVersion);
@@ -567,12 +574,12 @@ public class SqlNote {
           }
       }
 
-        // refresh local info
+      // 刷新本地信息
       loadFromCursor(mId);
       if (mType == Notes.TYPE_NOTE)
           loadDataContent();
 
+      // 清空差异值、重置创建标志
       mDiffNoteValues.clear();
       mIsCreate = false;
   }
-}