/* * 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;//包名为“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;//导入“Notes”类； import net.micode.notes.data.Notes.DataColumns;//导入“Notes”类的“DataColumns”内部类； import net.micode.notes.data.Notes.NoteColumns;//导入“Notes”类的“NoteColumns”内部类； import net.micode.notes.gtask.exception.ActionFailureException;//导入“gtask 操作失败异常”； import net.micode.notes.tool.GTaskStringUtils;//导入“Notes 工具类的字符串操作工具”； import net.micode.notes.tool.ResourceParser;//导入资源解析器； import org.json.JSONArray;//导入 JSON 数组； import org.json.JSONException;//导入 JSON 异常； import org.json.JSONObject;//导入 JSON 对象； import java.util.ArrayList;//导入数组列表。 public class SqlNote {//：定义一个名为“SqlNote”的公共类； private static final String TAG = SqlNote.class.getSimpleName();//定义一个静态字符串变量“tag”，其值为当前类的简单名称； private static final int INVALID_ID = -99999;//定义一个静态整型常量“INVALID_ID”，其值为-99999； public static final String[] PROJECTION_NOTE = new String[] {//定义一个公共静态字符串数组“PROJECTION_NOTE”，其中包含了一些列名； NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID,//“PROJECTION_NOTE”数组中的元素，包括“NoteColumns.ID”、“NoteColumns.ALERTED_DATE”和“NoteColumns.BG_COLOR_ID”； NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE,//定义“PROJECTION_NOTE”数组中的元素，包括“NoteColumns.CREATED_DATE”、“NoteColumns.HAS_ATTACHMENT”和“NoteColumns.MODIFIED_DATE”； NoteColumns.NOTES_COUNT, NoteColumns.PARENT_ID, NoteColumns.SNIPPET, NoteColumns.TYPE,//定义“PROJECTION_NOTE”数组中的元素，包括“NoteColumns.NOTES_COUNT”、“NoteColumns.PARENT_ID”、“NoteColumns.SNIPPET”和“NoteColumns.TYPE”； NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE, NoteColumns.SYNC_ID,//定义“PROJECTION_NOTE”数组中的元素，包括“NoteColumns.WIDGET_ID”、“NoteColumns.WIDGET_TYPE”和“NoteColumns.SYNC_ID”； NoteColumns.LOCAL_MODIFIED, NoteColumns.ORIGIN_PARENT_ID, NoteColumns.GTASK_ID,//定义“PROJECTION_NOTE”数组中的元素，包括“NoteColumns.LOCAL_MODIFIED”、“NoteColumns.ORIGIN_PARENT_ID”和“NoteColumns.GTASK_ID”； NoteColumns.VERSION//定义“PROJECTION_NOTE”数组中的元素，包括“NoteColumns.VERSION”； }; public static final int ID_COLUMN = 0;//定义一个公共静态整型常量“ID_COLUMN”，其值为 0； public static final int ALERTED_DATE_COLUMN = 1;//定义一个公共静态整型常量“ALERTED_DATE_COLUMN”，其值为 1； public static final int BG_COLOR_ID_COLUMN = 2;//定义一个公共静态整型常量“BG_COLOR_ID_COLUMN”，其值为 2； public static final int CREATED_DATE_COLUMN = 3;//定义一个公共静态整型常量“CREATED_DATE_COLUMN”，其值为 3； public static final int HAS_ATTACHMENT_COLUMN = 4;//定义一个公共静态整型常量“HAS_ATTACHMENT_COLUMN”，其值为 4； public static final int MODIFIED_DATE_COLUMN = 5;//定义一个公共静态整型常量“MODIFIED_DATE_COLUMN”，其值为 5； public static final int NOTES_COUNT_COLUMN = 6;//定义一个公共静态整型常量“NOTES_COUNT_COLUMN”，其值为 6； public static final int PARENT_ID_COLUMN = 7;//定义一个公共静态整型常量“PARENT_ID_COLUMN”，其值为 7； public static final int SNIPPET_COLUMN = 8;//定义一个公共静态整型常量“SNIPPET_COLUMN”，其值为 8； public static final int TYPE_COLUMN = 9;//定义一个公共静态整型常量“TYPE_COLUMN”，其值为 9； public static final int WIDGET_ID_COLUMN = 10;//定义一个公共静态整型常量“WIDGET_ID_COLUMN”，其值为 10； public static final int WIDGET_TYPE_COLUMN = 11;//定义一个公共静态整型常量“WIDGET_TYPE_COLUMN”，其值为 11； public static final int SYNC_ID_COLUMN = 12;//定义一个公共静态整型常量“SYNC_ID_COLUMN”，其值为 12； public static final int LOCAL_MODIFIED_COLUMN = 13;//定义一个公共静态整型常量“LOCAL_MODIFIED_COLUMN”，其值为 13； public static final int ORIGIN_PARENT_ID_COLUMN = 14;//定义一个公共静态整型常量“ORIGIN_PARENT_ID_COLUMN”，其值为 14； public static final int GTASK_ID_COLUMN = 15;//定义一个公共静态整型常量“GTASK_ID_COLUMN”，其值为 15； public static final int VERSION_COLUMN = 16;//定义一个公共静态整型常量“VERSION_COLUMN”，其值为 16； private Context mContext;//定义一个私有成员变量“mContext”，其类型为“Context”； private ContentResolver mContentResolver;//定义一个私有成员变量“mContentResolver”，其类型为“ContentResolver”； private boolean mIsCreate;//定义一个私有成员变量“mIsCreate”，其类型为“boolean”； private long mId;//定义一个私有成员变量“mId”，其类型为“long”； private long mAlertDate;//定义一个私有成员变量“mAlertDate”，其类型为“long”； private int mBgColorId;//定义一个私有成员变量“mBgColorId”，其类型为“int”； private long mCreatedDate;//定义一个私有成员变量“mCreatedDate”，其类型为“long”； private int mHasAttachment;//定义一个私有成员变量“mHasAttachment”，其类型为“int”； private long mModifiedDate;//定义一个私有成员变量“mModifiedDate”，其类型为“long”； private long mParentId;//定义一个私有成员变量“mParentId”，其类型为“long”； private String mSnippet;//定义一个私有成员变量“mSnippet”，其类型为“String”； private int mType;//定义一个私有成员变量“mType”，其类型为“int”； private int mWidgetId;//定义一个私有成员变量“mWidgetId”，其类型为“int”； private int mWidgetType;//定义一个私有成员变量“mWidgetType”，其类型为“int”； private long mOriginParent;//定义一个私有成员变量“mOriginParent”，其类型为“long”； private long mVersion;//定义一个私有成员变量“mVersion”，其类型为“long”； private ContentValues mDiffNoteValues;//定义一个私有成员变量“mDiffNoteValues”，其类型为“ContentValues”； private ArrayList mDataList;//定义一个私有成员变量“mDataList”，其类型为“ArrayList”； public SqlNote(Context context) {//定义类的构造函数，接收一个“Context”类型的参数； mContext = context;//在构造函数中，将传入的“context”赋值给成员变量“mContext”； mContentResolver = context.getContentResolver();//获取“context”的内容解析器，并赋值给成员变量“mContentResolver”； mIsCreate = true;//将成员变量“mIsCreate”设置为“true”，表示当前是创建新的笔记； mId = INVALID_ID;//将成员变量“mId”设置为“INVALID_ID”，表示笔记的 ID 无效； mAlertDate = 0;//将成员变量“mAlertDate”设置为 0，表示笔记的提醒日期为 0； mBgColorId = ResourceParser.getDefaultBgId(context);//获取默认的背景颜色 ID，并赋值给成员变量“mBgColorId”； mCreatedDate = System.currentTimeMillis();//获取当前系统时间，并赋值给成员变量“mCreatedDate”，表示笔记的创建日期； mHasAttachment = 0;//将成员变量“mHasAttachment”设置为 0，表示笔记没有附件； mModifiedDate = System.currentTimeMillis();//获取当前系统时间，并赋值给成员变量“mModifiedDate”，表示笔记的修改日期； mParentId = 0;//“mParentId”设置为 0，表示笔记的父 ID 为 0； mSnippet = "";//将成员变量“mSnippet”设置为空字符串，表示笔记的片段为空； mType = Notes.TYPE_NOTE;//Notes.TYPE_NOTE”，表示笔记的类型为普通笔记； mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID;//将成员变量“mWidgetId”设置为“AppWidgetManager.INVALID_APPWIDGET_ID”，表示笔记的小部件 ID 无效； mWidgetType = Notes.TYPE_WIDGET_INVALIDE;//将成员变量“mWidgetType”设置为“Notes.TYPE_WIDGET_INVALIDE”，表示笔记的小部件类型无效； mOriginParent = 0;//将成员变量“mOriginParent”设置为 0，表示笔记的原始父 ID 为 0； mVersion = 0;//将成员变量“mVersion”设置为 0，表示笔记的版本号为 0； mDiffNoteValues = new ContentValues();//创建一个新的“ContentValues”对象，并赋值给成员变量“mDiffNoteValues”； mDataList = new ArrayList();//创建一个新的“ArrayList”对象，并赋值给成员变量“mDataList”； } public SqlNote(Context context, Cursor c) {//定义类的另一个构造函数，接收一个“Context”类型的参数和一个“Cursor”类型的参数； mContext = context;//在构造函数中，将传入的“context”赋值给成员变量“mContext”； mContentResolver = context.getContentResolver();//获取“context”的内容解析器，并赋值给成员变量“mContentResolver”； mIsCreate = false;//将成员变量“mIsCreate”设置为“false”，表示当前不是创建新的笔记； loadFromCursor(c);//调用“loadFromCursor”方法，从“Cursor”中加载笔记的数据； mDataList = new ArrayList();//创建一个新的“ArrayList”对象，并赋值给成员变量“mDataList”； if (mType == Notes.TYPE_NOTE)//如果笔记的类型为普通笔记，则调用“loadDataContent”方法加载笔记的数据内容； loadDataContent(); mDiffNoteValues = new ContentValues();//创建一个新的“ContentValues”对象，并赋值给成员变量“mDiffNoteValues” } public SqlNote(Context context, long id) {//定义类的另一个构造函数，接收一个“Context”类型的参数和一个“long”类型的参数； mContext = context;//在构造函数中，将传入的“context”赋值给成员变量“mContext”； mContentResolver = context.getContentResolver();//获取“context”的内容解析器，并赋值给成员变量“mContentResolver”； mIsCreate = false;//：将成员变量“mIsCreate”设置为“false”，表示当前不是创建新的笔记； loadFromCursor(id);//调用“loadFromCursor”方法，根据“id”从数据库中加载笔记的数据； mDataList = new ArrayList();//创建一个新的“ArrayList”对象，并赋值给成员变量“mDataList”； if (mType == Notes.TYPE_NOTE)//如果笔记的类型为普通笔记，则调用“loadDataContent”方法加载笔记的数据内容； loadDataContent(); mDiffNoteValues = new ContentValues();//创建一个新的“ContentValues”对象，并赋值给成员变量“mDiffNoteValues” } private void loadFromCursor(long id) {//定义一个私有方法“loadFromCursor”，接收一个“long”类型的参数； Cursor c = null;//声明一个“Cursor”类型的变量“c”，并初始化为“null”； try { c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)",//使用“mContentResolver”查询“Notes.CONTENT_NOTE_URI”表，获取指定“id”的笔记数据，并将结果存储在“c”中； new String[] {//设置查询条件的参数值； String.valueOf(id)//将“id”转换为字符串，并作为查询条件的参数值； }, null);//设置查询的排序方式为“null”； if (c != null) {//如果“c”不为“null”，则执行以下操作； c.moveToNext();//将游标移动到下一条记录； loadFromCursor(c);//调用“loadFromCursor”方法，从游标中加载笔记的数据； } else {//如果“c”为“null”，则执行以下操作； Log.w(TAG, "loadFromCursor: cursor = null");//输出日志信息，提示游标为空； } } finally {//V在“finally”代码块中，执行以下操作； if (c != null)//如果“c”不为“null”，则执行以下操作； c.close();//关闭游标； } } private void loadFromCursor(Cursor c) {//定义一个私有方法“loadFromCursor”，接收一个“Cursor”类型的参数； mId = c.getLong(ID_COLUMN);//从游标中获取“ID_COLUMN”列的值，并赋值给成员变量“mId”； mAlertDate = c.getLong(ALERTED_DATE_COLUMN);//从游标中获取“ALERTED_DATE_COLUMN”列的值，并赋值给成员变量“mAlertDate”； mBgColorId = c.getInt(BG_COLOR_ID_COLUMN);//从游标中获取“BG_COLOR_ID_COLUMN”列的值，并赋值给成员变量“mBgColorId”； mCreatedDate = c.getLong(CREATED_DATE_COLUMN);//从游标中获取“CREATED_DATE_COLUMN”列的值，并赋值给成员变量“mCreatedDate”； mHasAttachment = c.getInt(HAS_ATTACHMENT_COLUMN);//从游标中获取“HAS_ATTACHMENT_COLUMN”列的值，并赋值给成员变量“mHasAttachment”； mModifiedDate = c.getLong(MODIFIED_DATE_COLUMN);//从游标中获取“MODIFIED_DATE_COLUMN”列的值，并赋值给成员变量“mModifiedDate”； mParentId = c.getLong(PARENT_ID_COLUMN);//从游标中获取“PARENT_ID_COLUMN”列的值，并赋值给成员变量“mParentId”； mSnippet = c.getString(SNIPPET_COLUMN);//从游标中获取“SNIPPET_COLUMN”列的值，并赋值给成员变量“mSnippet”； mType = c.getInt(TYPE_COLUMN);//：从游标中获取“TYPE_COLUMN”列的值，并赋值给成员变量“mType”； mWidgetId = c.getInt(WIDGET_ID_COLUMN);//从游标中获取“WIDGET_ID_COLUMN”列的值，并赋值给成员变量“mWidgetId”； mWidgetType = c.getInt(WIDGET_TYPE_COLUMN);//从游标中获取“WIDGET_TYPE_COLUMN”列的值，并赋值给成员变量“mWidgetType” mVersion = c.getLong(VERSION_COLUMN);//从游标中获取“VERSION_COLUMN”列的值，并赋值给成员变量“mVersion”； } private void loadDataContent() {//定义一个私有方法“loadDataContent”； Cursor c = null;//明一个“Cursor”类型的变量“c”，并初始化为“null”； mDataList.clear();//清空“mDataList”列表； try {在“try”代码块中，执行以下操作； c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,//使用“mContentResolver”查询“Notes.CONTENT_DATA_URI”表，获取指定笔记的“SqlData”数据，并将结果存储在“c”中； "(note_id=?)", new String[] { String.valueOf(mId)// //是一个字符串数组，用于在数据库查询中指定条件。其中， note_id=?  是查询条件，表示要查找的笔记的 ID 为指定的值； new String[] { String.valueOf(mId) }  是条件的值，将当前笔记的 ID 转换为字符串并作为查询条件的值； null  表示不指定排序方式。 }, null); if (c != null) {//如果游标不为空，则执行以下操作。 if (c.getCount() == 0) {//如果游标中的行数为 0，则表示该笔记似乎没有数据。 Log.w(TAG, "it seems that the note has not data");//：输出一条警告日志，提示该笔记似乎没有数据。 return; } while (c.moveToNext()) {//当游标可以向下移动时，执行以下循环。 SqlData data = new SqlData(mContext, c);//创建一个新的  SqlData  对象，用于表示当前游标指向的数据。 mDataList.add(data);//将新创建的  SqlData  对象添加到  mDataList  列表中。 } } else {//如果游标为空，则执行以下操作。 Log.w(TAG, "loadDataContent: cursor = null");//输出一条警告日志，提示游标为空。 } } finally {//无论游标是否为空，都执行以下操作。 if (c != null) c.close();//如果游标不为空，则关闭游标。 } } public boolean setContent(JSONObject js) { try { JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);//从传入的  JSONObject  中获取名为  GTaskStringUtils.META_HEAD_NOTE  的子对象，并将其赋值给  note  变量。 if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {//如果  note  对象的  type  字段的值为  Notes.TYPE_SYSTEM ，则表示这是一个系统文件夹，不能进行设置操作。 Log.w(TAG, "cannot set system folder");//输出一条警告日志，提示不能设置系统文件夹。 } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {//如果  note  对象的  type  字段的值为  Notes.TYPE_FOLDER ，则表示这是一个文件夹，可以进行设置操作，但只能更新  snippet  和  type  字段。 // for folder we can only update the snnipet and type String snippet = note.has(NoteColumns.SNIPPET) ? note .getString(NoteColumns.SNIPPET) : "";//获取  note  对象的  snippet  字段的值，如果该字段不存在，则使用空字符串作为默认值。 if (mIsCreate || !mSnippet.equals(snippet)) {//如果当前是创建新笔记，或者当前的  snippet  值与从  note  对象中获取的  snippet  值不相等，则执行以下操作。 mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);//将  snippet  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。 } mSnippet = snippet;//将从  note  对象中获取的  snippet  值赋值给当前笔记的  snippet  字段。 int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) : Notes.TYPE_NOTE;//Notes.TYPE_NOTE; ：获取  note  对象的  type  字段的值，如果该字段不存在，则使用  Notes.TYPE_NOTE  作为默认值。 if (mIsCreate || mType != type) {//如果当前是创建新笔记，或者当前的  type  值与从  note  对象中获取的  type  值不相等，则执行以下操作。 mDiffNoteValues.put(NoteColumns.TYPE, type);//将  type  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。 } mType = type;//将从  note  对象中获取的  type  值赋值给当前笔记的  type  字段。 } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) {//如果  note  对象的  type  字段的值为  Notes.TYPE_NOTE ，则表示这是一个普通笔记，可以进行设置操作。 JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);//从传入的  JSONObject  中获取名为  GTaskStringUtils.META_HEAD_DATA  的子对象，并将其转换为  JSONArray  类型。 long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID;//获取  note  对象的  id  字段的值，如果该字段不存在，则使用  INVALID_ID  作为默认值。 if (mIsCreate || mId != id) {//如果当前是创建新笔记，或者当前的  id  值与从  note  对象中获取的  id  值不相等，则执行以下操作。 mDiffNoteValues.put(NoteColumns.ID, id);//将  id  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。 } mId = id;//将从  note  对象中获取的  id  值赋值给当前笔记的  id  字段。 long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note .getLong(NoteColumns.ALERTED_DATE) : 0;//获取  note  对象的  alertDate  字段的值，如果该字段不存在，则使用 0 作为默认值。 if (mIsCreate || mAlertDate != alertDate) {//如果当前是创建新笔记，或者当前的  alertDate  值与从  note  对象中获取的  alertDate  值不相等，则执行以下操作。 mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate);//将  alertDate  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。 3 } mAlertDate = alertDate;//将从  note  对象中获取的  alertDate  值赋值给当前笔记的  alertDate  字段。 int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note .getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext);//获取  note  对象的  bgColorId  字段的值，如果该字段不存在，则使用默认的背景颜色 ID。 if (mIsCreate || mBgColorId != bgColorId) {//如果当前是创建新笔记，或者当前的  bgColorId  值与从  note  对象中获取的  bgColorId  值不相等，则执行以下操作。 mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId);//将  bgColorId  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。 。 } mBgColorId = bgColorId;//将从  note  对象中获取的  bgColorId  值赋值给当前笔记的  bgColorId  字段。 long createDate = note.has(NoteColumns.CREATED_DATE) ? note .getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis();//获取  note  对象的  createDate  字段的值，如果该字段不存在，则使用当前时间作为默认值。 if (mIsCreate || mCreatedDate != createDate) {//如果当前是创建新笔记，或者当前的  createdDate  值与从  note  对象中获取的  createdDate  值不相等，则执行以下操作。 mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate);//将  createdDate  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。 } mCreatedDate = createDate;//将从  note  对象中获取的  createdDate  值赋值给当前笔记的  createdDate  字段。 int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note .getInt(NoteColumns.HAS_ATTACHMENT) : 0;//获取  note  对象的  hasAttachment  字段的值，如果该字段不存在，则使用 0 作为默认值。 if (mIsCreate || mHasAttachment != hasAttachment) {//如果当前是创建新笔记，或者当前的  hasAttachment  值与从  note  对象中获取的  hasAttachment  值不相等，则执行以下操作。 mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment);//将  hasAttachment  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。 } mHasAttachment = hasAttachment;//将从  note  对象中获取的  hasAttachment  值赋值给当前笔记的  hasAttachment  字段。 long modifiedDate = note.has(NoteColumns.MODIFIED_DATE) ? note .getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis();//获取  note  对象的  modifiedDate  字段的值，如果该字段不存在，则使用当前时间作为默认值。 if (mIsCreate || mModifiedDate != modifiedDate) {//如果当前是创建新笔记，或者当前的  modifiedDate  值与从  note  对象中获取的  modifiedDate  值不相等，则执行以下操作。 mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate);//将  modifiedDate  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。 } mModifiedDate = modifiedDate;//将从  note  对象中获取的  modifiedDate  值赋值给当前笔记的  modifiedDate  字段。 long parentId = note.has(NoteColumns.PARENT_ID) ? note .getLong(NoteColumns.PARENT_ID) : 0;//获取  note  对象的  parentId  字段的值，如果该字段不存在，则使用 0 作为默认值。 if (mIsCreate || mParentId != parentId) {//如果当前是创建新笔记，或者当前的  parentId  值与从  note  对象中获取的  parentId  值不相等，则执行以下操作。 mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId);//将  parentId  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。 } mParentId = parentId;//将从  note  对象中获取的  parentId  值赋值给当前笔记的  parentId  字段。 String snippet = note.has(NoteColumns.SNIPPET) ? note .getString(NoteColumns.SNIPPET) : "";//获取  note  对象的  snippet  字段的值，如果该字段不存在，则使用空字符串作为默认值。 if (mIsCreate || !mSnippet.equals(snippet)) {//如果当前是创建新笔记，或者当前的  snippet  值与从  note  对象中获取的  snippet  值不相等，则执行以下操作。 mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);//将  snippet  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。 } mSnippet = snippet;//将从  note  对象中获取的  snippet  值赋值给当前笔记的  snippet  字段。 int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) : Notes.TYPE_NOTE;//获取  note  对象的  type  字段的值，如果该字段不存在，则使用  Notes.TYPE_NOTE  作为默认值。 if (mIsCreate || mType != type) {//如果当前是创建新笔记，或者当前的  type  值与从  note  对象中获取的  type  值不相等，则执行以下操作。 mDiffNoteValues.put(NoteColumns.TYPE, type);//将  type  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。 } mType = type;//从  note  对象中获取的  type  值赋值给当前笔记的  type  字段。 int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID) : AppWidgetManager.INVALID_APPWIDGET_ID;.//获取  note  对象的  widgetId  字段的值，如果该字段不存在，则使用无效的小部件 ID 作为默认值。 if (mIsCreate || mWidgetId != widgetId) {//如果当前是创建新笔记，或者当前的  widgetId  值与从  note  对象中获取的  widgetId  值不相等，则执行以下操作。 mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId);//将  widgetId  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。 } mWidgetId = widgetId;//将从  note  对象中获取的  widgetId  值赋值给当前笔记的  widgetId  字段。 int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note .getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE;//获取  note  对象的  widgetType  字段的值，如果该字段不存在，则使用无效的小部件类型作为默认值。 if (mIsCreate || mWidgetType != widgetType) {//如果当前是创建新笔记，或者当前的  widgetType  值与从  note  对象中获取的  widgetType  值不相等，则执行以下操作。 mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType);//将  widgetType  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。 } mWidgetType = widgetType;//将从  note  对象中获取的  widgetType  值赋值给当前笔记的  widgetType  字段。 long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note .getLong(NoteColumns.ORIGIN_PARENT_ID) : 0;//获取  note  对象的  originParent  字段的值，如果该字段不存在，则使用 0 作为默认值。 if (mIsCreate || mOriginParent != originParent) {//如果当前是创建新笔记，或者当前的  originParent  值与从  note  对象中获取的  originParent  值不相等，则执行以下操作。 mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent);//将  originParent  值添加到  mDiffNoteValues  对象中，以便在提交笔记时进行更新。 } mOriginParent = originParent;//将从  note  对象中获取的  originParent  值赋值给当前笔记的  originParent  字段。 for (int i = 0; i < dataArray.length(); i++) {//遍历  dataArray  数组，对每个元素执行以下操作。 JSONObject data = dataArray.getJSONObject(i);//获取当前元素，并将其转换为  JSONObject  类型。 SqlData sqlData = null;.//创建一个  SqlData  对象，并将其初始化为  null 。 if (data.has(DataColumns.ID)) {//如果  data  对象包含名为  DataColumns.ID  的字段，则执行以下操作 long dataId = data.getLong(DataColumns.ID);//获取该字段的值，并将其转换为  long  类型。 for (SqlData temp : mDataList) {//遍历  mDataList  列表，对每个元素执行以下操作。 if (dataId == temp.getId()) {//如果当前元素的  id  值与  dataId  相等，则执行以下操作。 sqlData = temp;//将当前元素赋值给  sqlData  变量。 } } } if (sqlData == null) {//如果  sqlData  变量仍然为  null ，则执行以下操作。 sqlData = new SqlData(mContext);//创建一个新的  SqlData  对象，并将其赋值给  sqlData  变量。 mDataList.add(sqlData);//新创建的  SqlData  对象添加到  mDataList  列表中。 } sqlData.setContent(data);//将 data 的内容设置到 sqlData 中。 } } } catch (JSONException e) {//如果在解析 JSONObject 时发生 JSONException 异常，则执行以下操作。 Log.e(TAG, e.toString());//使用 Log.e 方法输出错误日志，其中包含异常的详细信息。 e.printStackTrace();//打印异常的堆栈跟踪信息。 return false;//返回 false ，表示设置内容失败。 } return true;//返回 true ，表示设置内容成功。 } public JSONObject getContent() {//定义一个公共方法 getContent ，用于获取笔记的内容。 try {//在 try 代码块中执行以下操作。 JSONObject js = new JSONObject();//创建一个新的 JSONObject 对象 js 。 if (mIsCreate) {//如果笔记是新创建的，则执行以下操作。 Log.e(TAG, "it seems that we haven't created this in database yet");//输出一条错误日志，提示笔记似乎还没有在数据库中创建。 return null;//返回 null ，表示获取内容失败。 } JSONObject note = new JSONObject();//创建一个新的 JSONObject 对象 note 。 if (mType == Notes.TYPE_NOTE) {//如果笔记的类型是普通笔记，则执行以下操作。 note.put(NoteColumns.ID, mId);//将笔记的 ID 添加到 note 对象中。 note.put(NoteColumns.ALERTED_DATE, mAlertDate);//将笔记的提醒日期添加到 note 对象中。 note.put(NoteColumns.BG_COLOR_ID, mBgColorId);//将笔记的背景颜色 ID 添加到 note 对象中。 note.put(NoteColumns.CREATED_DATE, mCreatedDate);//将笔记的创建日期添加到 note 对象中。 note.put(NoteColumns.HAS_ATTACHMENT, mHasAttachment);//将笔记是否有附件添加到 note 对象中。 note.put(NoteColumns.MODIFIED_DATE, mModifiedDate);//将笔记的修改日期添加到 note 对象中。 note.put(NoteColumns.PARENT_ID, mParentId);//将笔记的父 ID 添加到 note 对象中。 note.put(NoteColumns.SNIPPET, mSnippet);//将笔记的片段添加到 note 对象中。 note.put(NoteColumns.TYPE, mType);//将笔记的类型添加到 note 对象中。 note.put(NoteColumns.WIDGET_ID, mWidgetId);//将笔记的小部件 ID 添加到 note 对象中。 note.put(NoteColumns.WIDGET_TYPE, mWidgetType);//将笔记的小部件类型添加到 note 对象中。 note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent);//将笔记的原始父 ID 添加到 note 对象中。 js.put(GTaskStringUtils.META_HEAD_NOTE, note);//将 note 对象添加到 js 对象中，键为 GTaskStringUtils.META_HEAD_NOTE 。 JSONArray dataArray = new JSONArray();//创建一个新的 JSONArray 对象 dataArray 。 for (SqlData sqlData : mDataList) {//遍历 mDataList 列表中的每个 SqlData 对象。 JSONObject data = sqlData.getContent();//获取当前 SqlData 对象的内容，并将其转换为 JSONObject 对象。 if (data != null) {//如果 data 对象不为 null ，则执行以下操作。 dataArray.put(data);//将 data 对象添加到 dataArray 对象中。 } } js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);//将 dataArray 对象添加到 js 对象中，键为 GTaskStringUtils.META_HEAD_DATA 。 } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {//如果笔记的类型是文件夹或系统文件夹，则执行以下操作。 note.put(NoteColumns.ID, mId);//将笔记的 ID 添加到 note 对象中。 note.put(NoteColumns.TYPE, mType);//将笔记的类型添加到 note 对象中。 note.put(NoteColumns.SNIPPET, mSnippet);//将笔记的片段添加到 note 对象中。 js.put(GTaskStringUtils.META_HEAD_NOTE, note);//：将 note 对象添加到 js 对象中，键为 GTaskStringUtils.META_HEAD_NOTE 。 } return js;//返回 js 对象，其中包含笔记的内容。 } catch (JSONException e) {//如果在创建 JSONObject 或 JSONArray 时发生 JSONException 异常，则执行以下操作。 Log.e(TAG, e.toString());//使用 Log.e 方法输出错误日志，其中包含异常的详细信息。 e.printStackTrace();//打印异常的堆栈跟踪信息。 } return null;//返回 null ，表示获取内容失败。 } public void setParentId(long id) {//定义一个公共方法 setParentId ，用于设置笔记的父 ID 。 mParentId = id;//将 id 赋值给成员变量 mParentId 。 mDiffNoteValues.put(NoteColumns.PARENT_ID, id);//将 id 添加到 mDiffNoteValues 对象中，以便在提交更改时更新数据库中的父 ID  } public void setGtaskId(String gid) {//定义一个公共方法 setGtaskId ，用于设置笔记的 gtask_id 。 mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);//将 gid 添加到 mDiffNoteValues 对象中，以便在提交更改时更新数据库中的 gtask_id 。 } public void setSyncId(long syncId) {//定义一个公共方法 setSyncId ，用于设置笔记的同步 ID 。 mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);//将 syncId 添加到 mDiffNoteValues 对象中，以便在提交更改时更新数据库中的同步 ID 。 } public void resetLocalModified() {//定义一个公共方法 resetLocalModified ，用于重置笔记的本地修改状态。 mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);//将 0 添加到 mDiffNoteValues 对象中，以便在提交更改时将本地修改状态重置为 false 。 } public long getId() {//定义一个公共方法 getId ，用于获取笔记的 ID 。 return mId;//返回成员变量 mId 的值，即笔记的 ID 。 } public long getParentId() {//定义一个公共方法 getParentId ，用于获取笔记的父 ID 。 return mParentId;//返回成员变量 mParentId 的值，即笔记的父 ID 。 } public String getSnippet() {//定义一个公共方法 getSnippet ，用于获取笔记的片段。 return mSnippet;//返回成员变量 mSnippet 的值，即笔记的片段。 } public boolean isNoteType() {//定义一个公共方法 isNoteType ，用于判断笔记是否为普通笔记。 return mType == Notes.TYPE_NOTE;//返回一个布尔值，表示笔记的类型是否为普通笔记。 } public void commit(boolean validateVersion) {//定义一个公共方法 commit ，用于提交笔记的更改。 if (mIsCreate) {//如果笔记是新创建的，则执行以下操作。 if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {//如果笔记的 ID 为无效值（ INVALID_ID ），并且 mDiffNoteValues 对象中包含 NoteColumns.ID 键，则执行以下操作。 mDiffNoteValues.remove(NoteColumns.ID);//从 mDiffNoteValues 对象中删除 NoteColumns.ID 键及其对应的值。 } Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);//使用 mContentResolver 对象的 insert 方法将 mDiffNoteValues 对象中的数据插入到数据库中，并获取插入后生成的 Uri 对象。 try {//在 try 代码块中执行以下操作。 mId = Long.valueOf(uri.getPathSegments().get(1));//从 uri 对象中获取路径段的第二个元素，并将其转换为 long 类型，然后赋值给成员变量 mId 。 } catch (NumberFormatException e) {//如果在将路径段元素转换为 long 类型时发生 NumberFormatException 异常，则执行以下操作 Log.e(TAG, "Get note id error :" + e.toString());//使用 Log.e 方法输出错误日志，其中包含异常的详细信息。 throw new ActionFailureException("create note failed");//抛出一个 ActionFailureException 异常，提示创建笔记失败。 } if (mId == 0) {//如果笔记的 ID 为 0，则执行以下操作。 throw new IllegalStateException("Create thread id failed");//出一个 IllegalStateException 异常，提示创建线程 ID 失败。 } if (mType == Notes.TYPE_NOTE) {//果笔记的类型是普通笔记，则执行以下操作。 for (SqlData sqlData : mDataList) {//遍历 mDataList 列表中的每个 SqlData 对象。 sqlData.commit(mId, false, -1);//调用 sqlData 对象的 commit 方法，将笔记的 ID 、是否验证版本和版本号作为参数传递给该方法。 } } } else {//如果笔记不是新创建的，则执行以下操作。 if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {//如果笔记的 ID 小于等于 0，并且不等于根文件夹 ID 和通话记录文件夹 ID ，则执行以下操作。 Log.e(TAG, "No such note");//使用 Log.e 方法输出错误日志，提示没有找到这样的笔记。 throw new IllegalStateException("Try to update note with invalid id");//抛出一个 IllegalStateException 异常，提示尝试使用无效的 ID 更新笔记。 } if (mDiffNoteValues.size() > 0) {//如果 mDiffNoteValues 对象中包含的键值对数量大于 0，则执行以下操作。 mVersion ++;//将成员变量 mVersion 的值加 1。 int result = 0;//定义一个整型变量 result ，并将其初始化为 0。 if (!validateVersion) {//如果不验证版本，则执行以下操作。 result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "(" + NoteColumns.ID + "=?)", new String[] { String.valueOf(mId) });//使用 mContentResolver 对象的 update 方法更新数据库中的笔记数据，将 mDiffNoteValues 对象中的键值对作为更新的数据， NoteColumns.ID 作为条件， mId 作为条件的值。 } else { result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "(" + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)", new String[] { String.valueOf(mId), String.valueOf(mVersion) });//使用 mContentResolver 对象的 update 方法更新数据库中的笔记数据，将 mDiffNoteValues 对象中的键值对作为更新的数据， NoteColumns.ID 和 NoteColumns.VERSION 作为条件， mId 和 mVersion 作为条件的值。 } if (result == 0) {//如果更新操作没有成功执行（即更新的行数为 0），则执行以下操作。 Log.w(TAG, "there is no update. maybe user updates note when syncing");//使用 Log.w 方法输出警告日志，提示没有更新笔记，可能是用户在同步时更新了笔记。 } } if (mType == Notes.TYPE_NOTE) {//如果笔记的类型是普通笔记，则执行以下操作。 for (SqlData sqlData : mDataList) {//遍历 mDataList 列表中的每个 SqlData 对象。 sqlData.commit(mId, validateVersion, mVersion);//调用 sqlData 对象的 commit 方法，将笔记的 ID 、是否验证版本和版本号作为参数传递给该方法。 } } } // refresh local info loadFromCursor(mId);//从数据库中加载笔记的最新信息。 if (mType == Notes.TYPE_NOTE)//如果笔记的类型是普通笔记，则执行以下操作。 loadDataContent();//加载笔记的数据内容。 mDiffNoteValues.clear();//清空 mDiffNoteValues 对象中的键值对。 mIsCreate = false;//将成员变量 mIsCreate 的值设置为 false ，表示笔记不再是新创建的。 } }