From 5aa27e7fbbb7f7af29d1198f7881003cb6794257 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:00:35 +0800 Subject: [PATCH] Signed-off-by: --- SqlNote.txt | 618 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 618 insertions(+) create mode 100644 SqlNote.txt diff --git a/SqlNote.txt b/SqlNote.txt new file mode 100644 index 0000000..2469f48 --- /dev/null +++ b/SqlNote.txt @@ -0,0 +1,618 @@ +/* + * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package net.micode.notes.gtask.data; + +import android.appwidget.AppWidgetManager; +import android.content.ContentResolver; +import android.content.ContentValues; +import android.content.Context; +import android.database.Cursor; +import android.net.Uri; +import android.util.Log; + +import net.micode.notes.data.Notes; +import net.micode.notes.data.Notes.DataColumns; +import net.micode.notes.data.Notes.NoteColumns; +import net.micode.notes.gtask.exception.ActionFailureException; +import net.micode.notes.tool.GTaskStringUtils; +import net.micode.notes.tool.ResourceParser; + +import org.json.JSONArray; +import org.json.JSONException; +import org.json.JSONObject; + +import java.util.ArrayList; + +/* + * SqlNote 类用于处理与数据库相关的笔记操作。 + * 该类主要用于加载、设置、获取和提交笔记数据。 + */ +public class SqlNote { + private static final String TAG = SqlNote.class.getSimpleName(); + + private static final int INVALID_ID = -99999; // 无效的 ID + // 笔记表的投影字段 + public static final String[] PROJECTION_NOTE = new String[] { + NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID, + NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE, + NoteColumns.NOTES_COUNT, NoteColumns.PARENT_ID, NoteColumns.SNIPPET, NoteColumns.TYPE, + NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE, NoteColumns.SYNC_ID, + NoteColumns.LOCAL_MODIFIED, NoteColumns.ORIGIN_PARENT_ID, NoteColumns.GTASK_ID, + NoteColumns.VERSION + }; + // 笔记表的列索引 + public static final int ID_COLUMN = 0; + + public static final int ALERTED_DATE_COLUMN = 1; + + public static final int BG_COLOR_ID_COLUMN = 2; + + public static final int CREATED_DATE_COLUMN = 3; + + public static final int HAS_ATTACHMENT_COLUMN = 4; + + public static final int MODIFIED_DATE_COLUMN = 5; + + public static final int NOTES_COUNT_COLUMN = 6; + + public static final int PARENT_ID_COLUMN = 7; + + public static final int SNIPPET_COLUMN = 8; + + public static final int TYPE_COLUMN = 9; + + public static final int WIDGET_ID_COLUMN = 10; + + public static final int WIDGET_TYPE_COLUMN = 11; + + public static final int SYNC_ID_COLUMN = 12; + + public static final int LOCAL_MODIFIED_COLUMN = 13; + + public static final int ORIGIN_PARENT_ID_COLUMN = 14; + + public static final int GTASK_ID_COLUMN = 15; + + public static final int VERSION_COLUMN = 16; + + private Context mContext; // 应用程序上下文 + + private ContentResolver mContentResolver; // 内容解析器 + + private boolean mIsCreate; // 是否为创建操作 + + private long mId; // 笔记 ID + + private long mAlertDate; // 提醒日期 + + private int mBgColorId; // 背景颜色 ID + + private long mCreatedDate; // 创建日期 + + private int mHasAttachment; // 是否有附件 + + private long mModifiedDate; // 修改日期 + + private long mParentId; // 父笔记 ID + + private String mSnippet; // 笔记摘要 + + private int mType; // 笔记类型 + + private int mWidgetId; // 小部件 ID + + private int mWidgetType; // 小部件类型 + + private long mOriginParent; // 原始父笔记 ID + + private long mVersion; // 版本号 + + private ContentValues mDiffNoteValues; // 差异笔记值 + + private ArrayList mDataList; // 数据列表 +/* + * 构造函数，用于创建新的笔记对象。 + * 该构造函数初始化笔记对象的各个属性，并设置为创建操作。 + * @param context 应用程序上下文。 + */ + public SqlNote(Context context) { + mContext = context; // 设置应用程序上下文 + mContentResolver = context.getContentResolver(); // 获取内容解析器 + mIsCreate = true; // 设置为创建操作 + mId = INVALID_ID; // 初始化笔记 ID 为无效值 + mAlertDate = 0; // 初始化提醒日期为 0 + mBgColorId = ResourceParser.getDefaultBgId(context); // 初始化背景颜色 ID 为默认值 + mCreatedDate = System.currentTimeMillis(); // 初始化创建日期为当前时间 + mHasAttachment = 0; // 初始化是否有附件为 0 + mModifiedDate = System.currentTimeMillis(); // 初始化修改日期为当前时间 + mParentId = 0; // 初始化父笔记 ID 为 0 + mSnippet = ""; // 初始化笔记摘要为空字符串 + mType = Notes.TYPE_NOTE; // 初始化笔记类型为普通笔记 + mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID; // 初始化小部件 ID 为无效值 + mWidgetType = Notes.TYPE_WIDGET_INVALIDE; // 初始化小部件类型为无效值 + mOriginParent = 0; // 初始化原始父笔记 ID 为 0 + mVersion = 0; // 初始化版本号为 0 + mDiffNoteValues = new ContentValues(); // 初始化差异笔记值 + mDataList = new ArrayList(); // 初始化数据列表 + } +/* + * 构造函数，用于从数据库游标加载笔记对象。 + * 该构造函数初始化笔记对象的各个属性，并设置为非创建操作。 + * @param context 应用程序上下文。 + * @param c 数据库游标。 + */ + public SqlNote(Context context, Cursor c) { + mContext = context; // 设置应用程序上下文 + mContentResolver = context.getContentResolver(); // 获取内容解析器 + mIsCreate = false; // 设置为非创建操作 + loadFromCursor(c); // 从数据库游标加载笔记对象 + mDataList = new ArrayList(); // 初始化数据列表 + if (mType == Notes.TYPE_NOTE) // 如果笔记类型为普通笔记 + loadDataContent(); // 加载笔记的数据内容 + mDiffNoteValues = new ContentValues(); // 初始化差异笔记值 + } +/* + * 构造函数，用于从数据库中加载指定 ID 的笔记对象。 + * 该构造函数初始化笔记对象的各个属性，并设置为非创建操作。 + * @param context 应用程序上下文。 + * @param id 笔记 ID。 + */ + public SqlNote(Context context, long id) { + mContext = context; // 设置应用程序上下文 + mContentResolver = context.getContentResolver(); // 获取内容解析器 + mIsCreate = false; // 设置为非创建操作 + loadFromCursor(id); // 从数据库中加载指定 ID 的笔记对象 + mDataList = new ArrayList(); // 初始化数据列表 + if (mType == Notes.TYPE_NOTE) // 如果笔记类型为普通笔记 + loadDataContent(); // 加载笔记的数据内容 + mDiffNoteValues = new ContentValues(); // 初始化差异笔记值 + + } +/* + * 从数据库中加载指定 ID 的笔记对象。 + * 该方法从数据库中查询指定 ID 的笔记数据，并调用 `loadFromCursor(Cursor c)` 方法加载笔记对象。 + * @param id 笔记 ID。 + */ + private void loadFromCursor(long id) { + Cursor c = null; + try { + // 查询指定 ID 的笔记数据 + c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)", + new String[] { + String.valueOf(id) + }, null); + if (c != null) { + c.moveToNext(); // 移动到游标的第一行 + loadFromCursor(c); // 加载笔记对象 + } else { + Log.w(TAG, "loadFromCursor: cursor = null"); // 记录警告日志，游标为空 + } + } finally { + if (c != null) + c.close(); // 关闭游标 + } + } +/* + * 从数据库游标加载笔记对象。 + * 该方法从数据库游标中提取笔记数据，并初始化笔记对象的各个属性。 + * @param c 数据库游标。 + */ + private void loadFromCursor(Cursor c) { + mId = c.getLong(ID_COLUMN); // 获取笔记 ID + mAlertDate = c.getLong(ALERTED_DATE_COLUMN); // 获取提醒日期 + mBgColorId = c.getInt(BG_COLOR_ID_COLUMN); // 获取背景颜色 ID + mCreatedDate = c.getLong(CREATED_DATE_COLUMN); // 获取创建日期 + mHasAttachment = c.getInt(HAS_ATTACHMENT_COLUMN); // 获取是否有附件 + mModifiedDate = c.getLong(MODIFIED_DATE_COLUMN); // 获取修改日期 + mParentId = c.getLong(PARENT_ID_COLUMN); // 获取父笔记 ID + mSnippet = c.getString(SNIPPET_COLUMN); // 获取笔记摘要 + mType = c.getInt(TYPE_COLUMN); // 获取笔记类型 + mWidgetId = c.getInt(WIDGET_ID_COLUMN); // 获取小部件 ID + mWidgetType = c.getInt(WIDGET_TYPE_COLUMN); // 获取小部件类型 + mVersion = c.getLong(VERSION_COLUMN); // 获取版本号 + } +/* + * 加载笔记的数据内容。 + * 该方法从数据库中查询与笔记相关的数据内容，并将其加载到数据列表中。 + */ + private void loadDataContent() { + Cursor c = null; + mDataList.clear(); // 清空数据列表 + try { + // 查询与笔记相关的数据内容 + c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA, + "(note_id=?)", new String[] { + String.valueOf(mId) + }, null); + if (c != null) { + if (c.getCount() == 0) { + Log.w(TAG, "it seems that the note has not data"); // 记录警告日志，笔记没有数据内容 + return; + } + while (c.moveToNext()) { + SqlData data = new SqlData(mContext, c); // 从游标中加载数据 + mDataList.add(data); // 将数据内容添加到数据列表中 + } + } else { + Log.w(TAG, "loadDataContent: cursor = null"); // 记录警告日志，游标为空 + } + } finally { + if (c != null) + c.close(); // 关闭游标 + } + } +/* + * 设置内容的方法，接受一个JSONObject作为参数，并根据其中的数据更新当前对象的属性。 + * @param js 包含笔记信息的JSONObject + * @return 如果设置成功返回true，否则返回false + */ + public boolean setContent(JSONObject js) { + try { + // 从JSONObject中获取笔记的元数据 + JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); + // 检查笔记的类型 + if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) { + // 如果是系统文件夹，则不能设置内容，记录警告日志 + Log.w(TAG, "cannot set system folder"); + } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) { + // 如果是文件夹类型，则只能更新摘要和类型 + // for folder we can only update the snnipet and type + // 获取摘要，如果未提供则默认为空字符串 + String snippet = note.has(NoteColumns.SNIPPET) ? note + .getString(NoteColumns.SNIPPET) : ""; + // 如果是新建笔记或摘要有变化，则更新摘要 + if (mIsCreate || !mSnippet.equals(snippet)) { + mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); + } + mSnippet = snippet; + // 获取类型，如果未提供则默认为普通笔记类型 + int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) + : Notes.TYPE_NOTE; + // 如果是新建笔记或类型有变化，则更新类型 + if (mIsCreate || mType != type) { + mDiffNoteValues.put(NoteColumns.TYPE, type); + } + mType = type; + } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) { + // 如果是普通笔记类型，则更新所有相关属性 + // 获取数据数组 + JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); + // 获取笔记ID，如果未提供则默认为无效ID + long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID; + // 如果是新建笔记或ID有变化，则更新ID + if (mIsCreate || mId != id) { + mDiffNoteValues.put(NoteColumns.ID, id); + } + mId = id; + // 获取提醒日期，如果未提供则默认为0 + long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note + .getLong(NoteColumns.ALERTED_DATE) : 0; + // 如果是新建笔记或提醒日期有变化，则更新提醒日期 + if (mIsCreate || mAlertDate != alertDate) { + mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate); + } + mAlertDate = alertDate; + // 获取背景颜色ID，如果未提供则默认为默认背景颜色ID + int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note + .getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext); + // 如果是新建笔记或背景颜色ID有变化，则更新背景颜色ID + if (mIsCreate || mBgColorId != bgColorId) { + mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId); + } + mBgColorId = bgColorId; + // 获取创建日期，如果未提供则默认为当前时间 + long createDate = note.has(NoteColumns.CREATED_DATE) ? note + .getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis(); + // 如果是新建笔记或创建日期有变化，则更新创建日期 + if (mIsCreate || mCreatedDate != createDate) { + mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate); + } + mCreatedDate = createDate; + // 获取是否有附件，如果未提供则默认为0（无附件） + int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note + .getInt(NoteColumns.HAS_ATTACHMENT) : 0; + // 如果是新建笔记或是否有附件有变化，则更新是否有附件 + if (mIsCreate || mHasAttachment != hasAttachment) { + mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment); + } + mHasAttachment = hasAttachment; + // 获取修改日期，如果未提供则默认为当前时间 + long modifiedDate = note.has(NoteColumns.MODIFIED_DATE) ? note + .getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis(); + // 如果是新建笔记或修改日期有变化，则更新修改日期 + if (mIsCreate || mModifiedDate != modifiedDate) { + mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate); + } + mModifiedDate = modifiedDate; + // 获取父ID，如果未提供则默认为0 + long parentId = note.has(NoteColumns.PARENT_ID) ? note + .getLong(NoteColumns.PARENT_ID) : 0; + // 如果是新建笔记或父ID有变化，则更新父ID + if (mIsCreate || mParentId != parentId) { + mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId); + } + mParentId = parentId; + // 获取摘要，如果未提供则默认为空字符串 + String snippet = note.has(NoteColumns.SNIPPET) ? note + .getString(NoteColumns.SNIPPET) : ""; + // 如果是新建笔记或摘要有变化，则更新摘要 + if (mIsCreate || !mSnippet.equals(snippet)) { + mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); + } + mSnippet = snippet; + // 获取类型，如果未提供则默认为普通笔记类型 + int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) + : Notes.TYPE_NOTE; + // 如果是新建笔记或类型有变化，则更新类型 + if (mIsCreate || mType != type) { + mDiffNoteValues.put(NoteColumns.TYPE, type); + } + mType = type; + // 获取小部件ID，如果未提供则默认为无效小部件ID + int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID) + : AppWidgetManager.INVALID_APPWIDGET_ID; + // 如果是新建笔记或小部件ID有变化，则更新小部件ID + if (mIsCreate || mWidgetId != widgetId) { + mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId); + } + mWidgetId = widgetId; + // 获取小部件类型，如果未提供则默认为无效小部件类型 + int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note + .getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE; + // 如果是新建笔记或小部件类型有变化，则更新小部件类型 + if (mIsCreate || mWidgetType != widgetType) { + mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType); + } + mWidgetType = widgetType; + // 获取原始父ID，如果未提供则默认为0 + long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note + .getLong(NoteColumns.ORIGIN_PARENT_ID) : 0; + // 如果是新建笔记或原始父ID有变化，则更新原始父ID + 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; + // 如果数据对象包含ID，则在现有数据列表中查找匹配的SqlData对象 + if (data.has(DataColumns.ID)) { + long dataId = data.getLong(DataColumns.ID); + for (SqlData temp : mDataList) { + if (dataId == temp.getId()) { + sqlData = temp; + } + } + } + // 如果未找到匹配的SqlData对象，则创建一个新的SqlData对象并添加到数据列表中 + if (sqlData == null) { + sqlData = new SqlData(mContext); + mDataList.add(sqlData); + } + // 设置SqlData对象的内容 + sqlData.setContent(data); + } + } + } catch (JSONException e) { + // 捕获JSON异常并记录错误日志 + Log.e(TAG, e.toString()); + e.printStackTrace(); + return false; + } + return true; + } +/* + * 获取当前对象的内容，并将其封装为一个JSONObject返回。 + * @return 包含当前对象内容的JSONObject，如果发生错误则返回null + */ + public JSONObject getContent() { + try { + // 创建一个新的JSONObject用于存储内容 + JSONObject js = new JSONObject(); + // 如果当前对象尚未在数据库中创建，记录错误日志并返回null + if (mIsCreate) { + Log.e(TAG, "it seems that we haven't created this in database yet"); + return null; + } + // 创建一个新的JSONObject用于存储笔记信息 + JSONObject note = new JSONObject(); + // 如果当前对象是普通笔记类型 + if (mType == Notes.TYPE_NOTE) { + // 将笔记的各个属性添加到note JSONObject中 + note.put(NoteColumns.ID, mId); + note.put(NoteColumns.ALERTED_DATE, mAlertDate); + note.put(NoteColumns.BG_COLOR_ID, mBgColorId); + note.put(NoteColumns.CREATED_DATE, mCreatedDate); + note.put(NoteColumns.HAS_ATTACHMENT, mHasAttachment); + note.put(NoteColumns.MODIFIED_DATE, mModifiedDate); + note.put(NoteColumns.PARENT_ID, mParentId); + note.put(NoteColumns.SNIPPET, mSnippet); + note.put(NoteColumns.TYPE, mType); + note.put(NoteColumns.WIDGET_ID, mWidgetId); + note.put(NoteColumns.WIDGET_TYPE, mWidgetType); + note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent); + // 将note JSONObject添加到js JSONObject中 + js.put(GTaskStringUtils.META_HEAD_NOTE, note); + // 创建一个新的JSONArray用于存储数据列表 + JSONArray dataArray = new JSONArray(); + // 遍历数据列表，将每个SqlData对象的内容添加到dataArray中 + for (SqlData sqlData : mDataList) { + JSONObject data = sqlData.getContent(); + if (data != null) { + dataArray.put(data); + } + } + // 将dataArray添加到js JSONObject中 + js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); + } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) { + // 如果当前对象是文件夹或系统文件夹类型 + // 将笔记的ID、类型和摘要添加到note JSONObject中 + note.put(NoteColumns.ID, mId); + note.put(NoteColumns.TYPE, mType); + note.put(NoteColumns.SNIPPET, mSnippet); + // 将note JSONObject添加到js JSONObject中 + js.put(GTaskStringUtils.META_HEAD_NOTE, note); + } + // 返回包含内容的JSONObject + return js; + } catch (JSONException e) { + // 捕获JSON异常并记录错误日志 + Log.e(TAG, e.toString()); + e.printStackTrace(); + } + return null; + } +/* + * 设置父ID，并将其添加到差异值中。 + * @param id 新的父ID + */ + public void setParentId(long id) { + mParentId = id; + mDiffNoteValues.put(NoteColumns.PARENT_ID, id); + } +/* + * 设置Google任务ID，并将其添加到差异值中。 + * @param gid 新的Google任务ID + */ + public void setGtaskId(String gid) { + mDiffNoteValues.put(NoteColumns.GTASK_ID, gid); + } +/* + * 设置同步ID，并将其添加到差异值中。 + * @param syncId 新的同步ID + */ + public void setSyncId(long syncId) { + mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId); + } +/* + * 重置本地修改标志，将其设置为0。 + */ + public void resetLocalModified() { + mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0); + } +/* + * 获取当前笔记的ID。 + * @return 当前笔记的ID + */ + public long getId() { + return mId; + } +/* + * 获取当前笔记的父ID。 + * @return 当前笔记的父ID + */ + public long getParentId() { + return mParentId; + } +/* + * 获取当前笔记的摘要。 + * @return 当前笔记的摘要 + */ + public String getSnippet() { + return mSnippet; + } +/* + * 判断当前笔记是否为普通笔记类型。 + * @return 如果当前笔记是普通笔记类型，返回true；否则返回false + */ + public boolean isNoteType() { + return mType == Notes.TYPE_NOTE; + } +/* + * 提交更改，将当前对象的差异值保存到数据库中。 + * @param validateVersion 是否验证版本号 + */ + public void commit(boolean validateVersion) { + // 如果是新建笔记 + if (mIsCreate) { + // 如果ID无效且差异值中包含ID，则移除ID + if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) { + mDiffNoteValues.remove(NoteColumns.ID); + } + // 插入笔记到数据库，并获取插入后的URI + Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues); + try { + // 从URI中提取新插入笔记的ID + mId = Long.valueOf(uri.getPathSegments().get(1)); + } catch (NumberFormatException e) { + // 如果提取ID失败，记录错误日志并抛出异常 + Log.e(TAG, "Get note id error :" + e.toString()); + throw new ActionFailureException("create note failed"); + } + // 如果ID为0，表示插入失败，抛出异常 + if (mId == 0) { + throw new IllegalStateException("Create thread id failed"); + } + // 如果当前笔记是普通笔记类型 + if (mType == Notes.TYPE_NOTE) { + // 遍历数据列表，提交每个SqlData对象的更改 + for (SqlData sqlData : mDataList) { + sqlData.commit(mId, false, -1); + } + } + } else { + // 如果不是新建笔记 + // 如果ID无效且不是根文件夹或通话记录文件夹，记录错误日志并抛出异常 + if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) { + Log.e(TAG, "No such note"); + throw new IllegalStateException("Try to update note with invalid id"); + } + // 如果差异值中有更新内容 + if (mDiffNoteValues.size() > 0) { + // 增加版本号 + mVersion ++; + int result = 0; + // 如果不验证版本号 + if (!validateVersion) { + // 更新笔记内容 + result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "(" + + NoteColumns.ID + "=?)", new String[] { + String.valueOf(mId) + }); + } else { + // 如果验证版本号，更新笔记内容并检查版本号 + result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "(" + + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)", + new String[] { + String.valueOf(mId), String.valueOf(mVersion) + }); + } + // 如果没有更新内容，记录警告日志 + if (result == 0) { + Log.w(TAG, "there is no update. maybe user updates note when syncing"); + } + } + // 如果当前笔记是普通笔记类型 + if (mType == Notes.TYPE_NOTE) { + // 遍历数据列表，提交每个SqlData对象的更改 + for (SqlData sqlData : mDataList) { + sqlData.commit(mId, validateVersion, mVersion); + } + } + } + + // refresh local info + // 刷新本地信息 + loadFromCursor(mId); + if (mType == Notes.TYPE_NOTE) + loadDataContent(); + // 清空差异值并设置为非新建状态 + mDiffNoteValues.clear(); + mIsCreate = false; + } +}