/* * 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(); // 定义一个无效的ID值，用于表示未初始化或无效的ID private static final int INVALID_ID = -99999; // 定义一个字符串数组，用于指定从数据库查询笔记数据时需要返回的列 public static final String[] PROJECTION_NOTE = new String[] { NoteColumns.ID, // 笔记的唯一标识符 NoteColumns.ALERTED_DATE, // 笔记的提醒日期 NoteColumns.BG_COLOR_ID, // 笔记的背景颜色ID NoteColumns.CREATED_DATE, // 笔记的创建日期 NoteColumns.HAS_ATTACHMENT, // 标记笔记是否有附件 NoteColumns.MODIFIED_DATE, // 笔记的最后修改日期 NoteColumns.NOTES_COUNT, // 对于文件夹，可能表示子笔记的数量 NoteColumns.PARENT_ID, // 笔记的父笔记ID NoteColumns.SNIPPET, // 笔记的摘要内容 NoteColumns.TYPE, // 笔记的类型（例如普通笔记、文件夹等） NoteColumns.WIDGET_ID, // 与笔记关联的小部件的ID NoteColumns.WIDGET_TYPE, // 小部件的类型 NoteColumns.SYNC_ID, // 用于同步的ID NoteColumns.LOCAL_MODIFIED, // 标记笔记是否在本地被修改 NoteColumns.ORIGIN_PARENT_ID, // 原始父笔记ID（可能用于某些特定的同步或层次结构逻辑） NoteColumns.GTASK_ID, // 与Google任务相关的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; // 上下文对象，用于获取系统资源和访问ContentResolver private Context mContext; // 用于与内容提供者进行交互的ContentResolver对象，通过它可以查询、插入、更新数据库数据 private ContentResolver mContentResolver; // 标记当前对象是否是用于创建新笔记 private boolean mIsCreate; // 存储笔记的ID private long mId; // 存储笔记的提醒日期 private long mAlertDate; // 存储笔记的背景颜色ID private int mBgColorId; // 存储笔记的创建日期 private long mCreatedDate; // 存储笔记是否有附件的标志（0表示无，非0表示有） private int mHasAttachment; // 存储笔记的最后修改日期 private long mModifiedDate; // 存储笔记的父笔记ID private long mParentId; // 存储笔记的摘要内容 private String mSnippet; // 存储笔记的类型 private int mType; // 存储与笔记关联的小部件的ID private int mWidgetId; // 存储小部件的类型 private int mWidgetType; // 存储笔记的原始父笔记ID private long mOriginParent; // 存储笔记的版本号 private long mVersion; // 用于存储笔记数据变更的ContentValues对象，方便批量更新数据库记录 private ContentValues mDiffNoteValues; // 用于存储与该笔记相关的所有SqlData对象，例如附件数据等 private ArrayList mDataList; // 构造函数，用于创建一个新的SqlNote对象，通常用于创建新笔记的场景 public SqlNote(Context context) { // 保存上下文对象，以便后续获取系统资源和ContentResolver mContext = context; // 获取上下文的ContentResolver，用于后续与内容提供者进行交互 mContentResolver = context.getContentResolver(); // 标记当前对象用于创建新笔记 mIsCreate = true; // 初始化笔记ID为无效ID，后续会在实际操作中被正确赋值 mId = INVALID_ID; // 初始化提醒日期为0 mAlertDate = 0; // 从ResourceParser获取默认的背景颜色ID mBgColorId = ResourceParser.getDefaultBgId(context); // 初始化创建日期为当前系统时间 mCreatedDate = System.currentTimeMillis(); // 初始化是否有附件为0（表示没有附件） mHasAttachment = 0; // 初始化修改日期为当前系统时间 mModifiedDate = System.currentTimeMillis(); // 初始化父笔记ID为0 mParentId = 0; // 初始化笔记摘要为空字符串 mSnippet = ""; // 初始化笔记类型为普通笔记类型 mType = Notes.TYPE_NOTE; // 初始化小部件ID为无效的小部件ID mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID; // 初始化小部件类型为无效的小部件类型 mWidgetType = Notes.TYPE_WIDGET_INVALIDE; // 初始化原始父笔记ID为0 mOriginParent = 0; // 初始化版本号为0 mVersion = 0; // 初始化用于存储数据变更的ContentValues对象 mDiffNoteValues = new ContentValues(); // 初始化用于存储相关数据对象的列表 mDataList = new ArrayList(); } // 构造函数，用于从数据库游标中创建一个SqlNote对象，通常用于加载现有笔记的场景 public SqlNote(Context context, Cursor c) { // 保存上下文对象 mContext = context; // 获取上下文的ContentResolver mContentResolver = context.getContentResolver(); // 标记当前对象不是用于创建新笔记，而是加载现有笔记 mIsCreate = false; // 调用私有方法从游标中加载笔记数据 loadFromCursor(c); // 初始化用于存储相关数据对象的列表 mDataList = new ArrayList(); // 如果笔记类型是普通笔记类型，则加载相关的数据内容 if (mType == Notes.TYPE_NOTE) loadDataContent(); // 初始化用于存储数据变更的ContentValues对象 mDiffNoteValues = new ContentValues(); } // 构造函数，用于根据给定的笔记ID从数据库中加载一个SqlNote对象 public SqlNote(Context context, long id) { // 保存上下文对象 mContext = context; // 获取上下文的ContentResolver mContentResolver = context.getContentResolver(); // 标记当前对象不是用于创建新笔记，而是加载现有笔记 mIsCreate = false; // 调用私有方法根据ID从数据库中加载笔记数据 loadFromCursor(id); // 初始化用于存储相关数据对象的列表 mDataList = new ArrayList(); // 如果笔记类型是普通笔记类型，则加载相关的数据内容 if (mType == Notes.TYPE_NOTE) loadDataContent(); // 初始化用于存储数据变更的ContentValues对象 mDiffNoteValues = new ContentValues(); } // 私有方法，根据给定的笔记ID从数据库中查询并加载笔记数据 private void loadFromCursor(long id) { // 初始化游标 Cursor c = null; try { // 使用ContentResolver查询笔记表，通过ID筛选出对应的笔记数据 c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)", new String[] { String.valueOf(id) }, null); // 如果查询到了数据 if (c!= null) { // 将游标移动到第一条记录（假设查询结果只有一条对应记录） c.moveToNext(); // 调用另一个重载的loadFromCursor方法，从游标中加载具体的笔记数据 loadFromCursor(c); } else { // 如果游标为空，说明没有查询到对应ID的笔记数据，记录警告日志 Log.w(TAG, "loadFromCursor: cursor = null"); } } finally { // 无论是否查询到数据，都要确保游标在使用完毕后关闭，释放资源 if (c!= null) c.close(); } } // 私有方法，从数据库游标中加载具体的笔记数据 private void loadFromCursor(Cursor c) { // 从游标中获取笔记的ID mId = c.getLong(ID_COLUMN); // 从游标中获取笔记的提醒日期 mAlertDate = c.getLong(ALERTED_DATE_COLUMN); // 从游标中获取笔记的背景颜色ID mBgColorId = c.getInt(BG_COLOR_ID_COLUMN); // 从游标中获取笔记的创建日期 mCreatedDate = c.getLong(CREATED_DATE_COLUMN); // 从游标中获取笔记是否有附件的标志 mHasAttachment = c.getInt(HAS_ATTACHMENT_COLUMN); // 从游标中获取笔记的最后修改日期 mModifiedDate = c.getLong(MODIFIED_DATE_COLUMN); // 从游标中获取笔记的父笔记ID mParentId = c.getLong(PARENT_ID_COLUMN); // 从游标中获取笔记的摘要内容 mSnippet = c.getString(SNIPPET_COLUMN); // 从游标中获取笔记的类型 mType = c.getInt(TYPE_COLUMN); // 从游标中获取与笔记关联的小部件的ID mWidgetId = c.getInt(WIDGET_ID_COLUMN); // 从游标中获取小部件的类型 mWidgetType = c.getInt(WIDGET_TYPE_COLUMN); // 从游标中获取笔记的版本号 mVersion = c.getLong(VERSION_COLUMN); } // 私有方法，加载与该笔记相关的数据内容（例如附件数据等） private void loadDataContent() { // 初始化游标 Cursor c = null; // 清空现有的数据对象列表，准备重新加载 mDataList.clear(); try { // 使用ContentResolver查询数据表，通过笔记ID筛选出与该笔记相关的数据 c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA, "(note_id=?)", new String[] { String.valueOf(mId) }, null); // 如果查询到了数据 if (c!= null) { // 如果查询结果的记录数为0，说明该笔记没有相关数据，记录警告日志并返回 if (c.getCount() == 0) { Log.w(TAG, "it seems that the note has not data"); return; } // 遍历游标中的每一条记录 while (c.moveToNext()) { // 根据游标创建一个SqlData对象 SqlData data = new SqlData(mContext, c); // 将该对象添加到数据对象列表中 mDataList.add(data); } } else { // 如果游标为空，说明没有查询到与该笔记相关的数据，记录警告日志 Log.w(TAG, "loadDataContent: cursor = null"); } } finally { // 无论是否查询到数据，都要确保游标在使用完毕后关闭，释放资源 if (c!= null) c.close(); } } // 根据传入的JSONObject设置笔记内容的方法，返回一个布尔值表示操作是否成功 public boolean setContent(JSONObject js) { try { // 从传入的JSONObject中获取包含笔记信息的JSONObject JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); // 获取笔记的类型 int noteType = note.getInt(NoteColumns.TYPE); // 如果笔记类型是系统文件夹类型 if (noteType == Notes.TYPE_SYSTEM) { // 记录警告日志，提示不能设置系统文件夹 Log.w(TAG, "cannot set system folder"); } // 如果笔记类型是普通文件夹类型 else if (noteType == Notes.TYPE_FOLDER) { // 对于文件夹，只能更新摘要和类型 // 从note中获取摘要信息，如果不存在则使用空字符串 String snippet = note.has(NoteColumns.SNIPPET)? note.getString(NoteColumns.SNIPPET) : ""; // 如果是创建新笔记或者当前摘要与传入的摘要不同 if (mIsCreate ||!mSnippet.equals(snippet)) { // 将新的摘要添加到用于存储数据变更的ContentValues对象中 mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); } // 更新当前摘要 mSnippet = snippet; // 从note中获取笔记类型信息，如果不存在则使用普通笔记类型 int type = note.has(NoteColumns.TYPE)? note.getInt(NoteColumns.TYPE) : Notes.TYPE_NOTE; // 如果是创建新笔记或者当前笔记类型与传入的类型不同 if (mIsCreate || mType!= type) { // 将新的笔记类型添加到用于存储数据变更的ContentValues对象中 mDiffNoteValues.put(NoteColumns.TYPE, type); } // 更新当前笔记类型 mType = type; } // 如果笔记类型是普通笔记类型 else if (noteType == Notes.TYPE_NOTE) { // 从传入的JSONObject中获取包含数据信息的JSONArray JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); // 从note中获取笔记ID，如果不存在则使用无效ID long id = note.has(NoteColumns.ID)? note.getLong(NoteColumns.ID) : INVALID_ID; // 如果是创建新笔记或者当前笔记ID与传入的ID不同 if (mIsCreate || mId!= id) { // 将新的ID添加到用于存储数据变更的ContentValues对象中 mDiffNoteValues.put(NoteColumns.ID, id); } // 更新当前笔记ID mId = id; // 从note中获取提醒日期，如果不存在则使用0 long alertDate = note.has(NoteColumns.ALERTED_DATE)? note.getLong(NoteColumns.ALERTED_DATE) : 0; // 如果是创建新笔记或者当前提醒日期与传入的提醒日期不同 if (mIsCreate || mAlertDate!= alertDate) { // 将新的提醒日期添加到用于存储数据变更的ContentValues对象中 mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate); } // 更新当前提醒日期 mAlertDate = alertDate; // 从note中获取背景颜色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) { // 将新的背景颜色ID添加到用于存储数据变更的ContentValues对象中 mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId); } // 更新当前背景颜色ID mBgColorId = bgColorId; // 从note中获取创建日期，如果不存在则使用当前系统时间 long createDate = note.has(NoteColumns.CREATED_DATE)? note.getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis(); // 如果是创建新笔记或者当前创建日期与传入的创建日期不同 if (mIsCreate || mCreatedDate!= createDate) { // 将新的创建日期添加到用于存储数据变更的ContentValues对象中 mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate); } // 更新当前创建日期 mCreatedDate = createDate; // 从note中获取是否有附件的标志，如果不存在则使用0 int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT)? note.getInt(NoteColumns.HAS_ATTACHMENT) : 0; // 如果是创建新笔记或者当前是否有附件的标志与传入的标志不同 if (mIsCreate || mHasAttachment!= hasAttachment) { // 将新的是否有附件的标志添加到用于存储数据变更的ContentValues对象中 mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment); } // 更新当前是否有附件的标志 mHasAttachment = hasAttachment; // 从note中获取修改日期，如果不存在则使用当前系统时间 long modifiedDate = note.has(NoteColumns.MODIFIED_DATE)? note.getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis(); // 如果是创建新笔记或者当前修改日期与传入的修改日期不同 if (mIsCreate || mModifiedDate!= modifiedDate) { // 将新的修改日期添加到用于存储数据变更的ContentValues对象中 mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate); } // 更新当前修改日期 mModifiedDate = modifiedDate; // 从note中获取父笔记ID，如果不存在则使用0 long parentId = note.has(NoteColumns.PARENT_ID)? note.getLong(NoteColumns.PARENT_ID) : 0; // 如果是创建新笔记或者当前父笔记ID与传入的父笔记ID不同 if (mIsCreate || mParentId!= parentId) { // 将新的父笔记ID添加到用于存储数据变更的ContentValues对象中 mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId); } // 更新当前父笔记ID mParentId = parentId; // 从note中获取摘要信息，如果不存在则使用空字符串 String snippet = note.has(NoteColumns.SNIPPET)? note.getString(NoteColumns.SNIPPET) : ""; // 如果是创建新笔记或者当前摘要与传入的摘要不同 if (mIsCreate ||!mSnippet.equals(snippet)) { // 将新的摘要添加到用于存储数据变更的ContentValues对象中 mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); } // 更新当前摘要 mSnippet = snippet; // 从note中获取笔记类型信息，如果不存在则使用普通笔记类型 int type = note.has(NoteColumns.TYPE)? note.getInt(NoteColumns.TYPE) : Notes.TYPE_NOTE; // 如果是创建新笔记或者当前笔记类型与传入的类型不同 if (mIsCreate || mType!= type) { // 将新的笔记类型添加到用于存储数据变更的ContentValues对象中 mDiffNoteValues.put(NoteColumns.TYPE, type); } // 更新当前笔记类型 mType = type; // 从note中获取小部件ID，如果不存在则使用无效的小部件ID int widgetId = note.has(NoteColumns.WIDGET_ID)? note.getInt(NoteColumns.WIDGET_ID) : AppWidgetManager.INVALID_APPWIDGET_ID; // 如果是创建新笔记或者当前小部件ID与传入的小部件ID不同 if (mIsCreate || mWidgetId!= widgetId) { // 将新的小部件ID添加到用于存储数据变更的ContentValues对象中 mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId); } // 更新当前小部件ID mWidgetId = widgetId; // 从note中获取小部件类型信息，如果不存在则使用无效的小部件类型 int widgetType = note.has(NoteColumns.WIDGET_TYPE)? note.getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE; // 如果是创建新笔记或者当前小部件类型与传入的小部件类型不同 if (mIsCreate || mWidgetType!= widgetType) { // 将新的小部件类型添加到用于存储数据变更的ContentValues对象中 mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType); } // 更新当前小部件类型 mWidgetType = widgetType; // 从note中获取原始父笔记ID，如果不存在则使用0 long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID)? note.getLong(NoteColumns.ORIGIN_PARENT_ID) : 0; // 如果是创建新笔记或者当前原始父笔记ID与传入的原始父笔记ID不同 if (mIsCreate || mOriginParent!= originParent) { // 将新的原始父笔记ID添加到用于存储数据变更的ContentValues对象中 mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent); } // 更新当前原始父笔记ID mOriginParent = originParent; // 遍历包含数据信息的JSONArray for (int i = 0; i < dataArray.length(); i++) { // 获取JSONArray中的每个JSONObject JSONObject data = dataArray.getJSONObject(i); SqlData sqlData = null; // 如果该JSONObject中包含数据ID if (data.has(DataColumns.ID)) { // 获取数据ID long dataId = data.getLong(DataColumns.ID); // 在已有的SqlData对象列表中查找是否有ID匹配的对象 for (SqlData temp : mDataList) { if (dataId == temp.getId()) { sqlData = temp; } } } // 如果没有找到匹配的SqlData对象 if (sqlData == null) { // 创建一个新的SqlData对象 sqlData = new SqlData(mContext); // 将新的SqlData对象添加到列表中 mDataList.add(sqlData); } // 使用该JSONObject设置SqlData对象的内容 sqlData.setContent(data); } } } catch (JSONException e) { // 如果在解析JSONObject过程中发生异常，记录错误日志并打印异常堆栈信息 Log.e(TAG, e.toString()); e.printStackTrace(); // 返回false表示设置内容失败 return false; } // 如果整个过程没有发生异常，返回true表示设置内容成功 return true; } // 获取当前笔记内容的方法，以JSONObject的形式返回 public JSONObject getContent() { try { // 创建一个新的JSONObject对象用于存储笔记内容 JSONObject js = new JSONObject(); // 如果当前对象是用于创建新笔记，说明数据还未在数据库中创建 if (mIsCreate) { // 记录错误日志 Log.e(TAG, "it seems that we haven't created this in database yet"); // 返回null表示无法获取内容 return null; } // 创建一个JSONObject对象用于存储笔记的详细信息 JSONObject note = new JSONObject(); // 如果笔记类型是普通笔记类型 if (mType == Notes.TYPE_NOTE) { // 将笔记的各个属性放入note JSONObject中 note.put(NoteColumns.ID, mId); // 笔记ID note.put(NoteColumns.ALERTED_DATE, mAlertDate); // 提醒日期 note.put(NoteColumns.BG_COLOR_ID, mBgColorId); // 背景颜色ID note.put(NoteColumns.CREATED_DATE, mCreatedDate); // 创建日期 note.put(NoteColumns.HAS_ATTACHMENT, mHasAttachment); // 是否有附件 note.put(NoteColumns.MODIFIED_DATE, mModifiedDate); // 修改日期 note.put(NoteColumns.PARENT_ID, mParentId); // 父笔记ID note.put(NoteColumns.SNIPPET, mSnippet); // 摘要 note.put(NoteColumns.TYPE, mType); // 笔记类型 note.put(NoteColumns.WIDGET_ID, mWidgetId); // 小部件ID note.put(NoteColumns.WIDGET_TYPE, mWidgetType); // 小部件类型 note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent); // 原始父笔记ID // 将包含笔记详细信息的note JSONObject放入js中 js.put(GTaskStringUtils.META_HEAD_NOTE, note); // 创建一个JSONArray对象用于存储与笔记相关的数据 JSONArray dataArray = new JSONArray(); // 遍历与笔记相关的所有SqlData对象 for (SqlData sqlData : mDataList) { // 获取每个SqlData对象的内容 JSONObject data = sqlData.getContent(); // 如果获取到的内容不为null if (data!= null) { // 将该数据对象添加到JSONArray中 dataArray.put(data); } } // 将包含相关数据的JSONArray放入js中 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中 js.put(GTaskStringUtils.META_HEAD_NOTE, note); } // 返回包含笔记内容的JSONObject return js; } catch (JSONException e) { // 如果在创建JSONObject过程中发生异常，记录错误日志并打印异常堆栈信息 Log.e(TAG, e.toString()); e.printStackTrace(); } // 如果发生异常，返回null return null; } // 设置笔记父ID的方法 public void setParentId(long id) { // 更新本地存储的父ID mParentId = id; // 将新的父ID放入用于存储数据变更的ContentValues对象中 mDiffNoteValues.put(NoteColumns.PARENT_ID, id); } // 设置Google任务ID的方法 public void setGtaskId(String gid) { // 将Google任务ID放入用于存储数据变更的ContentValues对象中 mDiffNoteValues.put(NoteColumns.GTASK_ID, gid); } // 设置同步ID的方法 public void setSyncId(long syncId) { // 将同步ID放入用于存储数据变更的ContentValues对象中 mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId); } // 重置本地修改标记的方法 public void resetLocalModified() { // 将本地修改标记设置为0，并放入用于存储数据变更的ContentValues对象中 mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0); } // 获取笔记ID的方法 public long getId() { return mId; } // 获取笔记父ID的方法 public long getParentId() { return mParentId; } // 获取笔记摘要的方法 public String getSnippet() { return mSnippet; } // 判断笔记类型是否为普通笔记类型的方法 public boolean isNoteType() { // 直接返回mType是否等于普通笔记类型的常量 return mType == Notes.TYPE_NOTE; } // 将笔记的变更提交到数据库的方法，validateVersion用于指定是否验证版本 public void commit(boolean validateVersion) { // 如果当前处于创建新笔记的状态 if (mIsCreate) { // 如果笔记ID为无效ID且变更值中包含ID字段 if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) { // 从变更值中移除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方法提交数据，传入当前笔记ID、不验证版本、版本号为-1 sqlData.commit(mId, false, -1); } } } // 如果不是创建新笔记，而是更新现有笔记 else { // 如果笔记ID小于等于0，且不是根文件夹ID和通话记录文件夹ID（假设这是两个特殊的有效ID） if (mId <= 0 && mId!= Notes.ID_ROOT_FOLDER && mId!= Notes.ID_CALL_RECORD_FOLDER) { // 记录错误日志 Log.e(TAG, "No such note"); // 抛出异常，表示尝试使用无效ID更新笔记 throw new IllegalStateException("Try to update note with invalid id"); } // 如果有数据变更需要更新 if (mDiffNoteValues.size() > 0) { // 版本号加1 mVersion++; int result = 0; // 如果不需要验证版本 if (!validateVersion) { // 使用ContentResolver更新笔记表，根据笔记ID更新数据 result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "(" + NoteColumns.ID + "=?)", new String[] { String.valueOf(mId) }); } // 如果需要验证版本 else { // 使用ContentResolver更新笔记表，根据笔记ID和版本号更新数据 result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "(" + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)", new String[] { String.valueOf(mId), String.valueOf(mVersion) }); } // 如果更新结果为0，说明没有数据被更新，记录警告日志 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方法提交数据，传入当前笔记ID、是否验证版本、当前版本号 sqlData.commit(mId, validateVersion, mVersion); } } } // 从数据库重新加载当前笔记的信息，以确保本地数据与数据库一致 loadFromCursor(mId); // 如果笔记类型是普通笔记类型，重新加载相关的数据内容 if (mType == Notes.TYPE_NOTE) loadDataContent(); // 清空用于存储数据变更的ContentValues对象，为下一次操作做准备 mDiffNoteValues.clear(); // 标记当前对象不再处于创建新笔记的状态 mIsCreate = false; }}