text123/SqlNote.java

/*
 * 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<SqlData> 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<SqlData>();
    }

    // 构造函数，用于从数据库游标中创建一个SqlNote对象，通常用于加载现有笔记的场景
    public SqlNote(Context context, Cursor c) {
        // 保存上下文对象
        mContext = context;
        // 获取上下文的ContentResolver
        mContentResolver = context.getContentResolver();
        // 标记当前对象不是用于创建新笔记，而是加载现有笔记
        mIsCreate = false;
        // 调用私有方法从游标中加载笔记数据
        loadFromCursor(c);
        // 初始化用于存储相关数据对象的列表
        mDataList = new ArrayList<SqlData>();
        // 如果笔记类型是普通笔记类型，则加载相关的数据内容
        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<SqlData>();
        // 如果笔记类型是普通笔记类型，则加载相关的数据内容
        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;
}}