Delete 'TaskList.java'

同步任务列表，将Task组织成同步任务列表进行管理
注释代码AlarmAlertActivity(2)的全文代码
16 changed files with 237 additions and 3271 deletions
--- a/Contact.java
+++ b/Contact.java
@ -1,91 +0,0 @@
 /*
 * 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.data;
 // 导入所需的Android类库
 import android.content.Context;
 import android.database.Cursor;
 import android.provider.ContactsContract.CommonDataKinds.Phone;
 import android.provider.ContactsContract.Data;
 import android.telephony.PhoneNumberUtils;
 import android.util.Log;
 // 导入Java的HashMap类，用于存储联系人缓存
 import java.util.HashMap;
 // 定义Contact类
 public class Contact {
    // 定义一个静态的HashMap，用于缓存联系人信息，避免重复查询
    private static HashMap<String, String> sContactCache;
    // 定义一个TAG，用于日志输出
    private static final String TAG = "Contact";
    // 定义一个静态常量，用于构建查询语句
    private static final String CALLER_ID_SELECTION = "PHONE_NUMBERS_EQUAL(" + Phone.NUMBER
    + ",?) AND " + Data.MIMETYPE + "='" + Phone.CONTENT_ITEM_TYPE + "'"
    + " AND " + Data.RAW_CONTACT_ID + " IN "
            + "(SELECT raw_contact_id "
            + " FROM phone_lookup"
            + " WHERE min_match = '+')";
    // 定义一个静态方法，用于根据电话号码获取联系人名称
    public static String getContact(Context context, String phoneNumber) {
        // 如果缓存不存在，则初始化缓存
        if(sContactCache == null) {
            sContactCache = new HashMap<String, String>();
        }
        // 如果电话号码已经在缓存中，则直接返回缓存中的联系人名称
        if(sContactCache.containsKey(phoneNumber)) {
            return sContactCache.get(phoneNumber);
        }
        // 替换查询语句中的占位符，构建具体的查询语句
        String selection = CALLER_ID_SELECTION.replace("+",
                PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
        // 使用ContentResolver查询联系人数据
        Cursor cursor = context.getContentResolver().query(
                Data.CONTENT_URI,
                new String [] { Phone.DISPLAY_NAME },
                selection,
                new String[] { phoneNumber },
                null);
        // 如果查询结果不为空，并且至少有一条数据
        if (cursor != null && cursor.moveToFirst()) {
            try {
                // 获取联系人名称
                String name = cursor.getString(0);
                // 将联系人名称放入缓存
                sContactCache.put(phoneNumber, name);
                return name;
            } catch (IndexOutOfBoundsException e) {
                // 如果获取联系人名称时出现异常，记录错误日志
                Log.e(TAG, " Cursor get string error " + e.toString());
                return null;
            } finally {
                // 最后，关闭游标
                cursor.close();
            }
        } else {
            // 如果没有匹配的联系人，记录日志并返回null
            Log.d(TAG, "No contact matched with number:" + phoneNumber);
            return null;
        }
    }
 }
--- a/MetaData.java
+++ b/MetaData.java
@ -1,103 +0,0 @@
 // 多行注释，说明版权信息和许可证
 /*
 * 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.database.Cursor;
 import android.util.Log;
 import net.micode.notes.tool.GTaskStringUtils;
 import org.json.JSONException;
 import org.json.JSONObject;
 // MetaData类继承自Task类，用于处理与任务相关的元数据
 public class MetaData extends Task {
    // 类的标签，用于日志记录
    private final static String TAG = MetaData.class.getSimpleName();
    // 用于存储相关任务的全局唯一标识符
    private String mRelatedGid = null;
    // 设置元数据信息
    public void setMeta(String gid, JSONObject metaInfo) {
        try {
            // 将全局唯一标识符添加到元数据信息中
            metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
        } catch (JSONException e) {
            // 如果添加失败，记录错误日志
            Log.e(TAG, "failed to put related gid");
        }
        // 设置任务的备注信息为元数据的字符串表示
        setNotes(metaInfo.toString());
        // 设置任务的名称为特定的元数据任务名称
        setName(GTaskStringUtils.META_NOTE_NAME);
    }
    // 获取相关任务的全局唯一标识符
    public String getRelatedGid() {
        return mRelatedGid;
    }
    // 重写isWorthSaving方法，判断任务是否值得保存
    @Override
    public boolean isWorthSaving() {
        // 如果任务的备注信息不为空，则认为值得保存
        return getNotes() != null;
    }
    // 从远程JSON对象设置内容
    @Override
    public void setContentByRemoteJSON(JSONObject js) {
        // 首先调用父类的设置内容方法
        super.setContentByRemoteJSON(js);
        // 如果备注信息不为空
        if (getNotes() != null) {
            try {
                // 将备注信息转换为JSON对象，并获取全局唯一标识符
                JSONObject metaInfo = new JSONObject(getNotes().trim());
                mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
            } catch (JSONException e) {
                // 如果转换失败，记录警告日志，并设置全局唯一标识符为null
                Log.w(TAG, "failed to get related gid");
                mRelatedGid = null;
            }
        }
    }
    // 从本地JSON对象设置内容，此方法不应该被调用
    @Override
    public void setContentByLocalJSON(JSONObject js) {
        // 如果被调用，抛出异常
        throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
    }
    // 从内容获取本地JSON对象，此方法不应该被调用
    @Override
    public JSONObject getLocalJSONFromContent() {
        // 如果被调用，抛出异常
        throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
    }
    // 获取同步操作，此方法不应该被调用
    @Override
    public int getSyncAction(Cursor c) {
        // 如果被调用，抛出异常
        throw new IllegalAccessError("MetaData:getSyncAction should not be called");
    }
 }
--- a/Node.java
+++ b/Node.java
@ -1,110 +0,0 @@
 // 多行注释，说明版权信息和许可证
 /*
 * 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.database.Cursor;
 import org.json.JSONObject;
 // Node类是一个抽象类，用于表示任务或节点的数据结构
 public abstract class Node {
    // 定义同步操作的常量
    public static final int SYNC_ACTION_NONE = 0; // 无操作
    public static final int SYNC_ACTION_ADD_REMOTE = 1; // 远程添加
    public static final int SYNC_ACTION_ADD_LOCAL = 2; // 本地添加
    public static final int SYNC_ACTION_DEL_REMOTE = 3; // 远程删除
    public static final int SYNC_ACTION_DEL_LOCAL = 4; // 本地删除
    public static final int SYNC_ACTION_UPDATE_REMOTE = 5; // 远程更新
    public static final int SYNC_ACTION_UPDATE_LOCAL = 6; // 本地更新
    public static final int SYNC_ACTION_UPDATE_CONFLICT = 7; // 更新冲突
    public static final int SYNC_ACTION_ERROR = 8; // 错误
    // 成员变量
    private String mGid; // 节点的全局唯一标识符
    private String mName; // 节点的名称
    private long mLastModified; // 节点的最后修改时间
    private boolean mDeleted; // 节点是否被删除
    // 构造函数
    public Node() {
        mGid = null; // 初始时，全局唯一标识符为空
        mName = ""; // 初始时，名称为空字符串
        mLastModified = 0; // 初始时，最后修改时间为0
        mDeleted = false; // 初始时，节点未被删除
    }
    // 获取创建操作的JSON对象
    public abstract JSONObject getCreateAction(int actionId);
    // 获取更新操作的JSON对象
    public abstract JSONObject getUpdateAction(int actionId);
    // 根据远程JSON对象设置内容
    public abstract void setContentByRemoteJSON(JSONObject js);
    // 根据本地JSON对象设置内容
    public abstract void setContentByLocalJSON(JSONObject js);
    // 从内容获取本地JSON对象
    public abstract JSONObject getLocalJSONFromContent();
    // 获取同步操作
    public abstract int getSyncAction(Cursor c);
    // 设置全局唯一标识符
    public void setGid(String gid) {
        this.mGid = gid;
    }
    // 设置节点名称
    public void setName(String name) {
        this.mName = name;
    }
    // 设置最后修改时间
    public void setLastModified(long lastModified) {
        this.mLastModified = lastModified;
    }
    // 设置节点是否被删除
    public void setDeleted(boolean deleted) {
        this.mDeleted = deleted;
    }
    // 获取全局唯一标识符
    public String getGid() {
        return this.mGid;
    }
    // 获取节点名称
    public String getName() {
        return this.mName;
    }
    // 获取最后修改时间
    public long getLastModified() {
        return this.mLastModified;
    }
    // 获取节点是否被删除
    public boolean getDeleted() {
        return this.mDeleted;
    }
 }
--- a/Note.java
+++ b/Note.java
@ -1,248 +0,0 @@
 // 包声明，定义了该类所在的包名
 package net.micode.notes.model;
 // 导入所需的Android类库
 import android.content.ContentProviderOperation;
 import android.content.ContentProviderResult;
 import android.content.ContentUris;
 import android.content.ContentValues;
 import android.content.Context;
 import android.content.OperationApplicationException;
 import android.net.Uri;
 import android.os.RemoteException;
 import android.util.Log;
 // 导入项目中定义的数据表和列名
 import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.CallNote;
 import net.micode.notes.data.Notes.DataColumns;
 import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.data.Notes.TextNote;
 import java.util.ArrayList;
 // 定义Note类，用于表示一个便签
 public class Note {
    // 用于存储便签数据的ContentValues对象
    private ContentValues mNoteDiffValues;
    // 用于存储便签数据的NoteData对象
    private NoteData mNoteData;
    // 定义日志标签
    private static final String TAG = "Note";
    /**
     * 创建一个新的便签ID，用于将新的便签添加到数据库中
     */
    public static synchronized long getNewNoteId(Context context, long folderId) {
        // 创建一个新的便签记录
        ContentValues values = new ContentValues();
        long createdTime = System.currentTimeMillis();
        values.put(NoteColumns.CREATED_DATE, createdTime); // 设置创建时间
        values.put(NoteColumns.MODIFIED_DATE, createdTime); // 设置修改时间
        values.put(NoteColumns.TYPE, Notes.TYPE_NOTE); // 设置便签类型
        values.put(NoteColumns.LOCAL_MODIFIED, 1); // 设置本地修改标志
        values.put(NoteColumns.PARENT_ID, folderId); // 设置父ID，即文件夹ID
        Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values); // 插入便签记录
        long noteId = 0;
        try {
            noteId = Long.valueOf(uri.getPathSegments().get(1)); // 获取新创建的便签ID
        } catch (NumberFormatException e) {
            Log.e(TAG, "Get note id error :" + e.toString()); // 捕获异常并记录日志
            noteId = 0;
        }
        if (noteId == -1) {
            throw new IllegalStateException("Wrong note id:" + noteId); // 抛出异常
        }
        return noteId;
    }
    // Note类的构造函数
    public Note() {
        mNoteDiffValues = new ContentValues(); // 初始化ContentValues对象
        mNoteData = new NoteData(); // 初始化NoteData对象
    }
    // 设置便签的值
    public void setNoteValue(String key, String value) {
        mNoteDiffValues.put(key, value); // 将键值对放入ContentValues
        mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1); // 设置本地修改标志
        mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis()); // 设置修改时间
    }
    // 设置文本数据
    public void setTextData(String key, String value) {
        mNoteData.setTextData(key, value); // 调用NoteData的方法设置文本数据
    }
    // 设置文本数据ID
    public void setTextDataId(long id) {
        mNoteData.setTextDataId(id); // 调用NoteData的方法设置文本数据ID
    }
    // 获取文本数据ID
    public long getTextDataId() {
        return mNoteData.mTextDataId; // 返回文本数据ID
    }
    // 设置通话数据ID
    public void setCallDataId(long id) {
        mNoteData.setCallDataId(id); // 调用NoteData的方法设置通话数据ID
    }
    // 设置通话数据
    public void setCallData(String key, String value) {
        mNoteData.setCallData(key, value); // 调用NoteData的方法设置通话数据
    }
    // 判断便签是否本地修改过
    public boolean isLocalModified() {
        return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified(); // 返回是否修改过
    }
    // 同步便签数据
    public boolean syncNote(Context context, long noteId) {
        if (noteId <= 0) {
            throw new IllegalArgumentException("Wrong note id:" + noteId); // 抛出异常
        }
        if (!isLocalModified()) {
            return true; // 如果没有修改过，直接返回true
        }
        // 理论上，一旦数据发生变化，便签的LOCAL_MODIFIED和MODIFIED_DATE都应该更新
        if (context.getContentResolver().update(
                ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), mNoteDiffValues, null,
                null) == 0) {
            Log.e(TAG, "Update note error, should not happen"); // 记录日志
            // Do not return, fall through
        }
        mNoteDiffValues.clear(); // 清空ContentValues
        if (mNoteData.isLocalModified()
                && (mNoteData.pushIntoContentResolver(context, noteId) == null)) {
            return false; // 如果NoteData同步失败，返回false
        }
        return true; // 同步成功，返回true
    }
    // 定义NoteData内部类，用于存储便签的文本数据和通话数据
    private class NoteData {
        private long mTextDataId; // 文本数据ID
        private ContentValues mTextDataValues; // 文本数据的ContentValues对象
        private long mCallDataId; // 通话数据ID
        private ContentValues mCallDataValues; // 通话数据的ContentValues对象
        private static final String TAG = "NoteData"; // 日志标签
        public NoteData() {
            mTextDataValues = new ContentValues(); // 初始化文本数据的ContentValues对象
            mCallDataValues = new ContentValues(); // 初始化通话数据的ContentValues对象
            mTextDataId = 0; // 初始化文本数据ID
            mCallDataId = 0; // 初始化通话数据ID
        }
        // 判断NoteData是否本地修改过
        boolean isLocalModified() {
            return mTextDataValues.size() > 0 || mCallDataValues.size() > 0; // 返回是否修改过
        }
        // 设置文本数据ID
        void setTextDataId(long id) {
            if(id <= 0) {
                throw new IllegalArgumentException("Text data id should larger than 0"); // 抛出异常
            }
            mTextDataId = id; // 设置文本数据ID
        }
        // 设置通话数据ID
        void setCallDataId(long id) {
            if (id <= 0) {
                throw new IllegalArgumentException("Call data id should larger than 0"); // 抛出异常
            }
            mCallDataId = id; // 设置通话数据ID
        }
        // 设置通话数据
        void setCallData(String key, String value) {
            mCallDataValues.put(key, value); // 将键值对放入通话数据的ContentValues
            mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1); // 设置本地修改标志
            mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis()); // 设置修改时间
        }
        // 设置文本数据
        void setTextData(String key, String value) {
            mTextDataValues.put(key, value); // 将键值对放入文本数据的ContentValues
            mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1); // 设置本地修改标志
            mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis()); // 设置修改时间
        }
        // 将NoteData的数据推送到ContentResolver
        Uri pushIntoContentResolver(Context context, long noteId) {
            if (noteId <= 0) {
                throw new IllegalArgumentException("Wrong note id:" + noteId); // 抛出异常
            }
            ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>(); // 操作列表
            ContentProviderOperation.Builder builder = null;
            if(mTextDataValues.size() > 0) {
                mTextDataValues.put(DataColumns.NOTE_ID, noteId); // 设置便签ID
                if (mTextDataId == 0) {
                    mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE); // 设置MIME类型
                    Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
                            mTextDataValues); // 插入文本数据
                    try {
                        setTextDataId(Long.valueOf(uri.getPathSegments().get(1))); // 获取并设置文本数据ID
                    } catch (NumberFormatException e) {
                        Log.e(TAG, "Insert new text data fail with noteId" + noteId); // 记录日志
                        mTextDataValues.clear(); // 清空ContentValues
                        return null;
                    }
                } else {
                    builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
                            Notes.CONTENT_DATA_URI, mTextDataId)); // 创建更新操作
                    builder.withValues(mTextDataValues); // 设置更新的值
                    operationList.add(builder.build()); // 添加到操作列表
                }
                mTextDataValues.clear(); // 清空ContentValues
 }
 	        if(mCallDataValues.size() > 0) {
            mCallDataValues.put(DataColumns.NOTE_ID, noteId); // 设置便签ID
            if (mCallDataId == 0) {
                mCallDataValues.put(DataColumns.MIME_TYPE, CallNote.CONTENT_ITEM_TYPE); // 设置MIME类型
                Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
                        mCallDataValues); // 插入通话数据
                try {
                    setCallDataId(Long.valueOf(uri.getPathSegments().get(1))); // 获取并设置通话数据ID
                } catch (NumberFormatException e) {
                    Log.e(TAG, "Insert new call data fail with noteId" + noteId); // 记录日志
                    mCallDataValues.clear(); // 清空ContentValues
                    return null;
                }
            } else {
                builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
                        Notes.CONTENT_DATA_URI, mCallDataId)); // 创建更新操作
                builder.withValues(mCallDataValues); // 设置更新的值
                operationList.add(builder.build()); // 添加到操作列表
            }
            mCallDataValues.clear(); // 清空ContentValues
        }
        if (operationList.size() > 0) {
            try {
                ContentProviderResult[] results = context.getContentResolver().applyBatch(
                        Notes.AUTHORITY, operationList); // 批量执行操作
                return (results == null || results.length == 0 || results[0] == null) ? null
                        : ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId); // 返回更新后的URI
            } catch (RemoteException e) {
                Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage())); // 记录日志
                return null;
            } catch (OperationApplicationException e) {
                Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage())); // 记录日志
                return null;
            }
        }
        return null;
    }
 }
--- a/Notes.java
+++ b/Notes.java
@ -1,256 +0,0 @@
 package net.micode.notes.data; // 定义包名，表示这个类属于net.micode.notes.data包。
 import android.net.Uri; // 导入Android的Uri类，用于处理URI。
 public class Notes {
    // 定义一些常量，用于应用程序的不同部分。
    public static final String AUTHORITY = "micode_notes"; // 定义authority，用于URI的构建。
    public static final String TAG = "Notes"; // 定义日志标签。
    public static final int TYPE_NOTE = 0; // 笔记类型。
    public static final int TYPE_FOLDER = 1; // 文件夹类型。
    public static final int TYPE_SYSTEM = 2; // 系统类型。
    // 定义系统文件夹的ID。
    /**
     * Following IDs are system folders' identifiers
     * {@link Notes#ID_ROOT_FOLDER } is default folder
     * {@link Notes#ID_TEMPARAY_FOLDER } is for notes belonging no folder
     * {@link Notes#ID_CALL_RECORD_FOLDER} is to store call records
     */
    public static final int ID_ROOT_FOLDER = 0; // 根文件夹的ID。
    public static final int ID_TEMPARAY_FOLDER = -1; // 临时文件夹的ID。
    public static final int ID_CALL_RECORD_FOLDER = -2; // 通话记录文件夹的ID。
    public static final int ID_TRASH_FOLER = -3; // 回收站文件夹的ID（注意：这里有个拼写错误，应该是FOLDER）。
    // 定义Intent的额外数据键，用于在Activity之间传递数据。
    public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date"; // 闹钟日期。
    public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id"; // 背景颜色ID。
    public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id"; // 小部件ID。
    public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type"; // 小部件类型。
    public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id"; // 文件夹ID。
    public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date"; // 通话日期。
    // 定义小部件类型的常量。
    public static final int TYPE_WIDGET_INVALIDE = -1; // 无效的小部件类型。
    public static final int TYPE_WIDGET_2X = 0; // 2x小部件类型。
    public static final int TYPE_WIDGET_4X = 1; // 4x小部件类型。
    public static class DataConstants {
        // 定义数据常量类，包含笔记和通话记录的MIME类型。
        public static final String NOTE = TextNote.CONTENT_ITEM_TYPE; // 文本笔记的内容项类型。
        public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE; // 通话笔记的内容项类型。
    }
    // 定义用于查询所有笔记和文件夹的Uri。
    /**
     * Uri to query all notes and folders
     */
    public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
    // 定义用于查询数据的Uri。
    /**
     * Uri to query data
     */
    public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
    // 定义NoteColumns接口，包含笔记或文件夹的列。
    public interface NoteColumns {
        /**
         * The unique ID for a row
         * <P> Type: INTEGER (long) </P>
         */
        public static final String ID = "_id"; // 行的唯一ID。
        /**
         * The parent's id for note or folder
         * <P> Type: INTEGER (long) </P>
         */
        public static final String PARENT_ID = "parent_id"; // 父ID。
        /**
         * Created data for note or folder
         * <P> Type: INTEGER (long) </P>
         */
        public static final String CREATED_DATE = "created_date"; // 创建日期。
        /**
         * Latest modified date
         * <P> Type: INTEGER (long) </P>
         */
        public static final String MODIFIED_DATE = "modified_date"; // 最后修改日期。
        /**
         * Alert date
         * <P> Type: INTEGER (long) </P>
         */
        public static final String ALERTED_DATE = "alert_date"; // 提醒日期。
        /**
         * Folder's name or text content of note
         * <P> Type: TEXT </P>
         */
        public static final String SNIPPET = "snippet"; // 片段，文件夹的名称或笔记的文本内容。
        /**
         * Note's widget id
         * <P> Type: INTEGER (long) </P>
         */
        public static final String WIDGET_ID = "widget_id"; // 小部件ID。
        /**
         * Note's widget type
         * <P> Type: INTEGER (long) </P>
         */
        public static final String WIDGET_TYPE = "widget_type"; // 小部件类型。
        /**
         * Note's background color's id
         * <P> Type: INTEGER (long) </P>
         */
        public static final String BG_COLOR_ID = "bg_color_id"; // 背景颜色ID。
        /**
         * For text note, it doesn't has attachment, for multi-media
         * note, it has at least one attachment
         * <P> Type: INTEGER </P>
         */
        public static final String HAS_ATTACHMENT = "has_attachment"; // 是否有附件。
        /**
         * Folder's count of notes
         * <P> Type: INTEGER (long) </P>
         */
        public static final String NOTES_COUNT = "notes_count"; // 文件夹中的笔记数量。
        /**
         * The file type: folder or note
         * <P> Type: INTEGER </P>
         */
        public static final String TYPE = "type"; // 文件类型：文件夹或笔记。
        /**
         * The last sync id
         * <P> Type: INTEGER (long) </P>
         */
        public static final String SYNC_ID = "sync_id"; // 最后同步ID。
        /**
         * Sign to indicate local modified or not
         * <P> Type: INTEGER </P>
         */
        public static final String LOCAL_MODIFIED = "local_modified"; // 是否本地修改。
        /**
         * Original parent id before moving into temporary folder
         * <P> Type : INTEGER </P>
         */
        public static final String ORIGIN_PARENT_ID = "origin_parent_id"; // 移动到临时文件夹之前的原始父ID。
        /**
         * The gtask id
         * <P> Type : TEXT </P>
         */
        public static final String GTASK_ID = "gtask_id"; // gtask ID。
        /**
         * The version code
         * <P> Type : INTEGER (long) </P>
         */
        public static final String VERSION = "version"; // 版本号。
    }
    // 定义DataColumns接口，包含数据的列。
    public interface DataColumns {
        /**
         * The unique ID for a row
         * <P> Type: INTEGER (long) </P>
         */
        public static final String ID = "_id"; // 行的唯一ID。
        /**
         * The MIME type of the item represented by this row.
         * <P> Type: Text </P>
         */
        public static final String MIME_TYPE = "mime_type"; // 项目的MIME类型。
        /**
         * The reference id to note that this data belongs to
         * <P> Type: INTEGER (long) </P>
         */
        public static final String NOTE_ID = "note_id"; // 笔记ID。
        /**
         * Created data for note or folder
         * <P> Type: INTEGER (long) </P>
         */
        public static final String CREATED_DATE = "created_date"; // 创建日期。
        /**
         * Latest modified date
         * <P> Type: INTEGER (long) </P>
         */
        public static final String MODIFIED_DATE = "modified_date"; // 最后修改日期。
        /**
         * Data's content
         * <P> Type: TEXT </P>
         */
        public static final String CONTENT = "content"; // 数据内容。
        /**
         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
         * integer data type
         * <P> Type: INTEGER </P>
         */
        public static final String DATA1 = "data1"; // 用于整数数据类型的通用数据列。
        /**
         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
         * integer data type
         * <P> Type: INTEGER </P>
         */
        public static final String DATA2 = "data2"; // 同上。
             /**
         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
         * TEXT data type
         * <P> Type: TEXT </P>
         */
        public static final String DATA3 = "data3"; // 用于文本数据类型的通用数据列。
        /**
         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
         * TEXT data type
         * <P> Type: TEXT </P>
         */
        public static final String DATA4 = "data4"; // 同上。
        /**
         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
         * TEXT data type
         * <P> Type: TEXT </P>
         */
        public static final String DATA5 = "data5"; // 同上。
    }
    // 定义TextNote类，实现DataColumns接口，用于文本笔记。
    public static final class TextNote implements DataColumns {
        /**
         * Mode to indicate the text in check list mode or not
         * <P> Type: Integer 1:check list mode 0: normal mode </P>
         */
        public static final String MODE = DATA1; // 模式，用于检查列表模式或普通模式。
        public static final int MODE_CHECK_LIST = 1; // 检查列表模式。
        /**
         * MIME type for a directory of text notes
         */
        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note"; // 文本笔记的目录MIME类型。
        /**
         * MIME type for a single text note
         */
        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note"; // 单个文本笔记的MIME类型。
        /**
         * The content URI for text notes
         */
        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note"); // 文本笔记的内容URI。
    }
    // 定义CallNote类，实现DataColumns接口，用于通话记录笔记。
    public static final class CallNote implements DataColumns {
        /**
         * Call date for this record
         * <P> Type: INTEGER (long) </P>
         */
        public static final String CALL_DATE = DATA1; // 通话日期。
        /**
         * Phone number for this record
         * <P> Type: TEXT </P>
         */
        public static final String PHONE_NUMBER = DATA3; // 电话号码。
        /**
         * MIME type for a directory of call notes
         */
        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note"; // 通话记录的目录MIME类型。
        /**
         * MIME type for a single call note
         */
        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note"; // 单个通话记录的MIME类型。
        /**
         * The content URI for call notes
         */
        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note"); // 通话记录的内容URI。
    }
 }
--- a/NotesDatabaseHelper.java
+++ b/NotesDatabaseHelper.java
@ -1,349 +0,0 @@
 /*
 * 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.data;
 import android.content.ContentValues;
 import android.content.Context;
 import android.database.sqlite.SQLiteDatabase;
 import android.database.sqlite.SQLiteOpenHelper;
 import android.util.Log;
 import net.micode.notes.data.Notes.DataColumns;
 import net.micode.notes.data.Notes.DataConstants;
 import net.micode.notes.data.Notes.NoteColumns;
 // 数据库帮助类
 public class NotesDatabaseHelper extends SQLiteOpenHelper {
    // 数据库名称
    private static final String DB_NAME = "note.db";
    // 数据库版本
    private static final int DB_VERSION = 4;
    // 表名常量接口
    public interface TABLE {
        public static final String NOTE = "note";
        public static final String DATA = "data";
    }
    // 标签常量，用于日志输出
    private static final String TAG = "NotesDatabaseHelper";
    // 单例实例
    private static NotesDatabaseHelper mInstance;
    // 创建笔记表的SQL语句
    private static final String CREATE_NOTE_TABLE_SQL =
        "CREATE TABLE " + TABLE.NOTE + "(" +
            NoteColumns.ID + " INTEGER PRIMARY KEY," +
            NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
            NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," +
            NoteColumns.BG_COLOR_ID + " INTEGER NOT NULL DEFAULT 0," +
            NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
            NoteColumns.HAS_ATTACHMENT + " INTEGER NOT NULL DEFAULT 0," +
            NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
            NoteColumns.NOTES_COUNT + " INTEGER NOT NULL DEFAULT 0," +
            NoteColumns.SNIPPET + " TEXT NOT NULL DEFAULT ''," +
            NoteColumns.TYPE + " INTEGER NOT NULL DEFAULT 0," +
            NoteColumns.WIDGET_ID + " INTEGER NOT NULL DEFAULT 0," +
            NoteColumns.WIDGET_TYPE + " INTEGER NOT NULL DEFAULT -1," +
            NoteColumns.SYNC_ID + " INTEGER NOT NULL DEFAULT 0," +
            NoteColumns.LOCAL_MODIFIED + " INTEGER NOT NULL DEFAULT 0," +
            NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
            NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," +
            NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" +
        ")";
    // 创建数据表的SQL语句
    private static final String CREATE_DATA_TABLE_SQL =
        "CREATE TABLE " + TABLE.DATA + "(" +
            DataColumns.ID + " INTEGER PRIMARY KEY," +
            DataColumns.MIME_TYPE + " TEXT NOT NULL," +
            DataColumns.NOTE_ID + " INTEGER NOT NULL DEFAULT 0," +
            NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
            NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
            DataColumns.CONTENT + " TEXT NOT NULL DEFAULT ''," +
            DataColumns.DATA1 + " INTEGER," +
            DataColumns.DATA2 + " INTEGER," +
            DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," +
            DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," +
            DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +
        ")";
    // 创建数据表中笔记ID索引的SQL语句
    private static final String CREATE_DATA_NOTE_ID_INDEX_SQL =
        "CREATE INDEX IF NOT EXISTS note_id_index ON " +
        TABLE.DATA + "(" + DataColumns.NOTE_ID + ");";
    // 更新文件夹笔记数量的触发器SQL语句（当移动笔记时）
    private static final String NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
        "CREATE TRIGGER increase_folder_count_on_update "+
        " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +
        " BEGIN " +
        "  UPDATE " + TABLE.NOTE +
        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +
        "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
        " END";
    // 减少文件夹笔记数量的触发器SQL语句（当从文件夹中移除笔记时）
    private static final String NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
        "CREATE TRIGGER decrease_folder_count_on_update " +
        " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +
        " BEGIN " +
        "  UPDATE " + TABLE.NOTE +
        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" +
        "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +
        "  AND " + NoteColumns.NOTES_COUNT + ">0" + ";" +
        " END";
    // 插入新笔记时增加文件夹笔记数量的触发器SQL语句
    private static final String NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER =
        "CREATE TRIGGER increase_folder_count_on_insert " +
        " AFTER INSERT ON " + TABLE.NOTE +
        " BEGIN " +
        "  UPDATE " + TABLE.NOTE +
        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +
        "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
        " END";
    // 从文件夹中删除笔记时减少文件夹笔记数量的触发器SQL语句
    private static final String NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER =
        "CREATE TRIGGER decrease_folder_count_on_delete " +
        " AFTER DELETE ON " + TABLE.NOTE +
        " BEGIN " +
        "  UPDATE " + TABLE.NOTE +
        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" +
        "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +
        "  AND " + NoteColumns.NOTES_COUNT + ">0;" +
        " END";
    // 插入数据时更新笔记内容的触发器SQL语句
    private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER =
        "CREATE TRIGGER update_note_content_on_insert " +
        " AFTER INSERT ON " + TABLE.DATA +
        " WHEN new." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
        " BEGIN" +
        "  UPDATE " + TABLE.NOTE +
        "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +
        "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
        " END";
    // 更新数据时更新笔记内容的触发器SQL语句
    private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER =
        "CREATE TRIGGER update_note_content_on_update " +
        " AFTER UPDATE ON " + TABLE.DATA +
        " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
        " BEGIN" +
        "  UPDATE " + TABLE.NOTE +
        "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +
        "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
        " END";
    // 删除数据时更新笔记内容的触发器SQL语句
    private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER =
        "CREATE TRIGGER update_note_content_on_delete " +
        " AFTER delete ON " + TABLE.DATA +
        " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
        " BEGIN" +
        "  UPDATE " + TABLE.NOTE +
        "   SET " + NoteColumns.SNIPPET + "=''" +
        "  WHERE " + NoteColumns.ID + "=old." + DataColumns.NOTE_ID + ";" +
        " END";
    // 删除笔记时删除属于该笔记的数据的触发器SQL语句
    private static final String NOTE_DELETE_DATA_ON_DELETE_TRIGGER =
        "CREATE TRIGGER delete_data_on_delete " +
        " AFTER DELETE ON " + TABLE.NOTE +
        " BEGIN" +
        "  DELETE FROM " + TABLE.DATA +    "   WHERE " + DataColumns.NOTE_ID + "=old." + NoteColumns.ID + ";" +
    " END";
 // 删除文件夹时删除属于该文件夹的笔记的触发器SQL语句
 private static final String FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER =
    "CREATE TRIGGER folder_delete_notes_on_delete " +
    " AFTER DELETE ON " + TABLE.NOTE +
    " BEGIN" +
    "  DELETE FROM " + TABLE.NOTE +
    "   WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
    " END";
 // 将笔记移动到回收站文件夹时移动属于该文件夹的笔记的触发器SQL语句
 private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER =
    "CREATE TRIGGER folder_move_notes_on_trash " +
    " AFTER UPDATE ON " + TABLE.NOTE +
    " WHEN new." + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
    " BEGIN" +
    "  UPDATE " + TABLE.NOTE +
    "   SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
    "  WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
    " END";
 // 构造函数
 public NotesDatabaseHelper(Context context) {
    super(context, DB_NAME, null, DB_VERSION);
 }
 // 创建笔记表的方法
 public void createNoteTable(SQLiteDatabase db) {
    db.execSQL(CREATE_NOTE_TABLE_SQL);
    reCreateNoteTableTriggers(db);
    createSystemFolder(db);
    Log.d(TAG, "note table has been created");
 }
 // 重新创建笔记表触发器的方法
 private void reCreateNoteTableTriggers(SQLiteDatabase db) {
    db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_update");
    db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_update");
    db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_delete");
    db.execSQL("DROP TRIGGER IF EXISTS delete_data_on_delete");
    db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_insert");
    db.execSQL("DROP TRIGGER IF EXISTS folder_delete_notes_on_delete");
    db.execSQL("DROP TRIGGER IF EXISTS folder_move_notes_on_trash");
    db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
    db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
    db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER);
    db.execSQL(NOTE_DELETE_DATA_ON_DELETE_TRIGGER);
    db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER);
    db.execSQL(FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER);
    db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);
 }
 // 创建系统文件夹的方法
 private void createSystemFolder(SQLiteDatabase db) {
    ContentValues values = new ContentValues();
    // 创建通话记录文件夹
    values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER);
    values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
    db.insert(TABLE.NOTE, null, values);
    // 创建根文件夹（默认文件夹）
    values.clear();
    values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER);
    values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
    db.insert(TABLE.NOTE, null, values);
    // 创建临时文件夹（用于移动笔记）
    values.clear();
    values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER);
    values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
    db.insert(TABLE.NOTE, null, values);
    // 创建回收站文件夹
    values.clear();
    values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
    values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
    db.insert(TABLE.NOTE, null, values);
 }
 // 创建数据表的方法
 public void createDataTable(SQLiteDatabase db) {
    db.execSQL(CREATE_DATA_TABLE_SQL);
    reCreateDataTableTriggers(db);
    db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);
    Log.d(TAG, "data table has been created");
 }
 // 重新创建数据表触发器的方法
 private void reCreateDataTableTriggers(SQLiteDatabase db) {
    db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_insert");
    db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_update");
    db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_delete");
    db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER);
    db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER);
    db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER);
 }
 // 获取单例实例的方法
 static synchronized NotesDatabaseHelper getInstance(Context context) {
    if (mInstance == null) {
        mInstance = new NotesDatabaseHelper(context);
    }
    return mInstance;
 }
 // 当创建数据库时调用的方法
@Override
 public void onCreate(SQLiteDatabase db) {
    createNoteTable(db);
    createDataTable(db);
 }
 // 当数据库升级时调用的方法
@Override
 public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    boolean reCreateTriggers = false;
    boolean skipV2 = false;
    if (oldVersion == 1) {
        upgradeToV2(db);
        skipV2 = true; // this upgrade including the upgrade from v2 to v3
        oldVersion++;
    }
    if (oldVersion == 2 && !skipV2) {
        upgradeToV3(db);
        reCreateTriggers = true;
        oldVersion++;
    }
    if (oldVersion == 3) {
        upgradeToV4(db);
        oldVersion++;
    }
    if (reCreateTriggers) {
        reCreateNoteTableTriggers(db);
        reCreateDataTableTriggers(db);
    }
    if (oldVersion != newVersion) {
        throw new IllegalStateException("Upgrade notes database to version " + newVersion
                + "fails");
    }
 }
 // 升级到版本2的方法
 private void upgradeToV2(SQLiteDatabase db) {
    db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE);
    db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA);
    createNoteTable(db);
    createDataTable(db);
 }
 // 升级到版本3的方法
 private void upgradeToV3(SQLiteDatabase db) {
    // 删除未使用的触发器
    db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_insert");
    db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_delete");
    db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_update");
    // 添加gtask id列
    db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID
            + " TEXT NOT NULL DEFAULT ''");
    // 添加回收站系统文件夹
    ContentValues values = new ContentValues();
    values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
    values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
    db.insert(TABLE.NOTE, null, values);
 }
 // 升级到版本4的方法
 private void upgradeToV4(SQLiteDatabase db) {
    db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
            + " INTEGER NOT NULL DEFAULT 0");
 }
--- a/NotesProvider.java
+++ b/NotesProvider.java
@ -1,305 +0,0 @@
 /*
 * 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.data;
 import android.app.SearchManager;
 import android.content.ContentProvider;
 import android.content.ContentUris;
 import android.content.ContentValues;
 import android.content.Intent;
 import android.content.UriMatcher;
 import android.database.Cursor;
 import android.database.sqlite.SQLiteDatabase;
 import android.net.Uri;
 import android.text.TextUtils;
 import android.util.Log;
 import net.micode.notes.R;
 import net.micode.notes.data.Notes.DataColumns;
 import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.data.NotesDatabaseHelper.TABLE;
 // 主要的 NotesProvider 类，继承自 ContentProvider
 public class NotesProvider extends ContentProvider {
    private static final UriMatcher mMatcher; // URI匹配器
    private NotesDatabaseHelper mHelper; // 数据库帮助类
    private static final String TAG = "NotesProvider"; // 日志标签
    // 定义URI匹配码
    private static final int URI_NOTE            = 1;
    private static final int URI_NOTE_ITEM       = 2;
    private static final int URI_DATA            = 3;
    private static final int URI_DATA_ITEM       = 4;
    private static final int URI_SEARCH          = 5;
    private static final int URI_SEARCH_SUGGEST  = 6;
    // 初始化URI匹配器
    static {
        mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
        mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
        mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM);
        mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA);
        mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM);
        mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH);
        mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST);
        mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", URI_SEARCH_SUGGEST);
    }
    // 定义搜索时使用的投影
    /**
     * x'0A' represents the '\n' character in sqlite. For title and content in the search result,
     * we will trim '\n' and white space in order to show more information.
     */
    private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + ","
        + NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + ","
        + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_1 + ","
        + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_2 + ","
        + R.drawable.search_result + " AS " + SearchManager.SUGGEST_COLUMN_ICON_1 + ","
        + "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + ","
        + "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA;
    // 定义搜索查询
    private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION
        + " FROM " + TABLE.NOTE
        + " WHERE " + NoteColumns.SNIPPET + " LIKE ?"
        + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER
        + " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE;
    @Override
    public boolean onCreate() {
        mHelper = NotesDatabaseHelper.getInstance(getContext()); // 获取数据库帮助类的实例
        return true;
    }
    @Override
    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
            String sortOrder) {
        Cursor c = null;
        SQLiteDatabase db = mHelper.getReadableDatabase(); // 获取可读数据库
        String id = null;
        switch (mMatcher.match(uri)) { // 匹配URI
            case URI_NOTE:
                c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
                        sortOrder);
                break;
            case URI_NOTE_ITEM:
                id = uri.getPathSegments().get(1); // 获取路径中的ID
                c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
                        + parseSelection(selection), selectionArgs, null, null, sortOrder);
                break;
            case URI_DATA:
                c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null,
                        sortOrder);
                break;
            case URI_DATA_ITEM:
                id = uri.getPathSegments().get(1); // 获取路径中的ID
                c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id
                        + parseSelection(selection), selectionArgs, null, null, sortOrder);
                break;
            case URI_SEARCH:
            case URI_SEARCH_SUGGEST:
                if (sortOrder != null || projection != null) {
                    throw new IllegalArgumentException(
                            "do not specify sortOrder, selection, selectionArgs, or projection" + "with this query");
                }
                String searchString = null;
                if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) {
                    if (uri.getPathSegments().size() > 1) {
                        searchString = uri.getPathSegments().get(1);
                    }
                } else {
                    searchString = uri.getQueryParameter("pattern");
                }
                if (TextUtils.isEmpty(searchString)) {
                    return null;
                }
                try {
                    searchString = String.format("%%%s%%", searchString);
                    c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY,
                            new String[] { searchString });
                } catch (IllegalStateException ex) {
                    Log.e(TAG, "got exception: " + ex.toString());
                }
                break;
            default:
                throw new IllegalArgumentException("Unknown URI " + uri);
        }
        if (c != null) {
            c.setNotificationUri(getContext().getContentResolver(), uri); // 设置通知URI
        }
        return c;
    }
    @Override
    public Uri insert(Uri uri, ContentValues values) {
        SQLiteDatabase db = mHelper.getWritableDatabase(); // 获取可写数据库
        long dataId = 0, noteId = 0, insertedId = 0;
        switch (mMatcher.match(uri)) { // 匹配URI
            case URI_NOTE:
                insertedId = noteId = db.insert(TABLE.NOTE, null, values); // 插入笔记
                break;
            case URI_DATA:
                if (values.containsKey(DataColumns.NOTE_ID)) {
                    noteId = values.getAsLong(DataColumns.NOTE_ID); // 获取笔记ID
                } else {
                    Log.d(TAG, "Wrong data format without note id:" + values.toString());
                }
                insertedId = dataId = db.insert(TABLE.DATA, null, values); // 插入数据
                break;
            default:
                throw new IllegalArgumentException("Unknown URI " + uri);
        }
        // Notify the note uri
        if (noteId > 0) {
            getContext().getContentResolver().notifyChange(
                    ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
        }
        // Notify the data uri
        if (dataId > 0) {
            getContext().getContentResolver().notifyChange(
                    ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);
        }
        return ContentUris.withAppendedId(uri, insertedId); // 返回插入的URI
    }
    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        int count = 0;
        String id = null;
        SQLiteDatabase db = mHelper.getWritableDatabase(); // 获取可写数据库
        boolean deleteData = false;
        switch (mMatcher.match(uri)) { // 匹配URI
            case URI_NOTE:
                selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 "; // 确保ID大于0
                count = db.delete(TABLE.NOTE, selection, selectionArgs); // 删除笔记
                break;
            case URI_NOTE_ITEM:
                id = uri.getPathSegments().get(1); // 获取路径中的ID
                /**
                 * ID that smaller than 0 is system folder which is not allowed to
                 * trash
                 */
                long noteId = Long.valueOf(id);
                if (noteId <= 0) {
                    break;
                }
                count = db.delete(TABLE.NOTE,
                        NoteColumns.ID + "=" +id + parseSelection(selection), selectionArgs); // 删除笔记项
 					break;
 			case URI_DATA:
 				count = db.delete(TABLE.DATA, selection, selectionArgs); // 删除数据
 				deleteData = true;
 					break;
 			case URI_DATA_ITEM:
 				id = uri.getPathSegments().get(1); // 获取路径中的ID
 				count = db.delete(TABLE.DATA,
 				DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs); // 删除数据项
 				deleteData = true;
 				break;
 			default:
 				throw new IllegalArgumentException("Unknown URI " + uri);
 		}
 	if (count > 0) {
 		if (deleteData) {
 			getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null); // 通知删除数据
 		}
 		getContext().getContentResolver().notifyChange(uri, null); // 通知删除
 	}		
 	return count;
 }
@Override
 public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
    int count = 0;
    String id = null;
    SQLiteDatabase db = mHelper.getWritableDatabase(); // 获取可写数据库
    boolean updateData = false;
    switch (mMatcher.match(uri)) { // 匹配URI
        case URI_NOTE:
            increaseNoteVersion(-1, selection, selectionArgs); // 增加笔记版本
            count = db.update(TABLE.NOTE, values, selection, selectionArgs); // 更新笔记
            break;
        case URI_NOTE_ITEM:
            id = uri.getPathSegments().get(1); // 获取路径中的ID
            increaseNoteVersion(Long.valueOf(id), selection, selectionArgs); // 增加笔记版本
            count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id
                    + parseSelection(selection), selectionArgs); // 更新笔记项
            break;
        case URI_DATA:
            count = db.update(TABLE.DATA, values, selection, selectionArgs); // 更新数据
            updateData = true;
            break;
        case URI_DATA_ITEM:
            id = uri.getPathSegments().get(1); // 获取路径中的ID
            count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id
                    + parseSelection(selection), selectionArgs); // 更新数据项
            updateData = true;
            break;
        default:
            throw new IllegalArgumentException("Unknown URI " + uri);
    }
    if (count > 0) {
        if (updateData) {
            getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null); // 通知更新数据
        }
        getContext().getContentResolver().notifyChange(uri, null); // 通知更新
    }
    return count;
 }
 private String parseSelection(String selection) {
    return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : ""); // 解析选择条件
 }
 private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
    StringBuilder sql = new StringBuilder(120);
    sql.append("UPDATE ");
    sql.append(TABLE.NOTE);
    sql.append(" SET ");
    sql.append(NoteColumns.VERSION);
    sql.append("=" + NoteColumns.VERSION + "+1 ");
    if (id > 0 || !TextUtils.isEmpty(selection)) {
        sql.append(" WHERE ");
    }
    if (id > 0) {
        sql.append(NoteColumns.ID + "=" + String.valueOf(id));
    }
    if (!TextUtils.isEmpty(selection)) {
        String selectString = id > 0 ? parseSelection(selection) : selection;
        for (String args : selectionArgs) {
            selectString = selectString.replaceFirst("\\?", args);
        }
        sql.append(selectString);
    }
    mHelper.getWritableDatabase().execSQL(sql.toString()); // 执行更新SQL
 }
@Override
 public String getType(Uri uri) {
    // TODO Auto-generated method stub
    return null;
 }
--- a/README.md
+++ b/README.md
@ -1,2 +0,0 @@
 # 5MI
--- a/SqlData.java
+++ b/SqlData.java
@ -1,191 +0,0 @@
 // 多行注释，说明版权信息和许可证
 /*
 * 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.content.ContentResolver;
 import android.content.ContentUris;
 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.DataConstants;
 import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.data.NotesDatabaseHelper.TABLE;
 import net.micode.notes.gtask.exception.ActionFailureException;
 import org.json.JSONException;
 import org.json.JSONObject;
 // SqlData类用于处理与数据库相关的操作
 public class SqlData {
    // 类的标签，用于日志记录
    private static final String TAG = SqlData.class.getSimpleName();
    // 定义一个无效的ID值
    private static final int INVALID_ID = -99999;
    // 数据库查询的列
    public static final String[] PROJECTION_DATA = new String[] {
            DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
            DataColumns.DATA3
    };
    // 定义查询列的索引
    public static final int DATA_ID_COLUMN = 0;
    public static final int DATA_MIME_TYPE_COLUMN = 1;
    public static final int DATA_CONTENT_COLUMN = 2;
    public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
    public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
    // 成员变量
    private ContentResolver mContentResolver; // 内容解析器
    private boolean mIsCreate; // 是否为创建操作
    private long mDataId; // 数据ID
    private String mDataMimeType; // 数据MIME类型
    private String mDataContent; // 数据内容
    private long mDataContentData1; // 数据内容的DATA1字段
    private String mDataContentData3; // 数据内容的DATA3字段
    private ContentValues mDiffDataValues; // 与数据库不同的数据内容
    // 构造函数，用于创建新的SqlData对象
    public SqlData(Context context) {
        mContentResolver = context.getContentResolver();
        mIsCreate = true;
        mDataId = INVALID_ID;
        mDataMimeType = DataConstants.NOTE;
        mDataContent = "";
        mDataContentData1 = 0;
        mDataContentData3 = "";
        mDiffDataValues = new ContentValues();
    }
    // 构造函数，用于从数据库中加载现有的SqlData对象
    public SqlData(Context context, Cursor c) {
        mContentResolver = context.getContentResolver();
        mIsCreate = false;
        loadFromCursor(c);
        mDiffDataValues = new ContentValues();
    }
    // 从游标加载数据
    private void loadFromCursor(Cursor c) {
        mDataId = c.getLong(DATA_ID_COLUMN);
        mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
        mDataContent = c.getString(DATA_CONTENT_COLUMN);
        mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN);
        mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
    }
    // 设置内容，从JSONObject中读取数据
    public void setContent(JSONObject js) throws JSONException {
        long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
        if (mIsCreate || mDataId != dataId) {
            mDiffDataValues.put(DataColumns.ID, dataId);
        }
        mDataId = dataId;
        String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)
                : DataConstants.NOTE;
        if (mIsCreate || !mDataMimeType.equals(dataMimeType)) {
            mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType);
        }
        mDataMimeType = dataMimeType;
        String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : "";
        if (mIsCreate || !mDataContent.equals(dataContent)) {
            mDiffDataValues.put(DataColumns.CONTENT, dataContent);
        }
        mDataContent = dataContent;
        long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0;
        if (mIsCreate || mDataContentData1 != dataContentData1) {
            mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
        }
        mDataContentData1 = dataContentData1;
        String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : "";
        if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {
            mDiffDataValues.put(DataColumns.DATA3, dataContentData3);
        }
        mDataContentData3 = dataContentData3;
    }
    // 获取内容，返回JSONObject
    public JSONObject getContent() throws JSONException {
        if (mIsCreate) {
            Log.e(TAG, "it seems that we haven't created this in database yet");
            return null;
        }
        JSONObject js = new JSONObject();
        js.put(DataColumns.ID, mDataId);
        js.put(DataColumns.MIME_TYPE, mDataMimeType);
        js.put(DataColumns.CONTENT, mDataContent);
        js.put(DataColumns.DATA1, mDataContentData1);
        js.put(DataColumns.DATA3, mDataContentData3);
        return js;
    }
    // 提交数据到数据库
    public void commit(long noteId, boolean validateVersion, long version) {
        if (mIsCreate) {
            if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
                mDiffDataValues.remove(DataColumns.ID);
            }
            mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
            Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
            try {
                mDataId = Long.valueOf(uri.getPathSegments().get(1));
            } catch (NumberFormatException e) {
                Log.e(TAG, "Get note id error :" + e.toString());
                throw new ActionFailureException("create note failed");
            }
        } else {
            if (mDiffDataValues.size() > 0) {
                int result = 0;
                if (!validateVersion) {
                    result = mContentResolver.update(ContentUris.withAppendedId(
                            Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
                } else {
                    result = mContentResolver.update(ContentUris.withAppendedId(
                            Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
                            " ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
                                    + " WHERE " + NoteColumns.VERSION + "=?)", new String[] {
                                    String.valueOf(noteId), String.valueOf(version)
                            });
                }
                if (result == 0) {
                    Log.w(TAG, "there is no update. maybe user updates note when syncing");
                }
            }
        }
        mDiffDataValues.clear();
        mIsCreate = false;
    }
    // 获取数据ID
    public long getId() {
        return mDataId;
    }
 }
--- a/SqlNote.java
+++ b/SqlNote.java
@ -1,483 +0,0 @@
 // 多行注释，说明版权信息和许可证
 /*
 * 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值
    private static final int INVALID_ID = -99999;
    // 数据库查询的列
    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<SqlData> mDataList; // 数据列表
    // 构造函数，用于创建新的SqlNote对象
    public SqlNote(Context context) {
        mContext = context;
        mContentResolver = context.getContentResolver();
        mIsCreate = true;
        mId = INVALID_ID;
        mAlertDate = 0;
        mBgColorId = ResourceParser.getDefaultBgId(context);
        mCreatedDate = System.currentTimeMillis();
        mHasAttachment = 0;
        mModifiedDate = System.currentTimeMillis();
        mParentId = 0;
        mSnippet = "";
        mType = Notes.TYPE_NOTE;
        mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID;
        mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
        mOriginParent = 0;
        mVersion = 0;
        mDiffNoteValues = new ContentValues();
        mDataList = new ArrayList<SqlData>();
    }
    // 构造函数，用于从数据库中加载现有的SqlNote对象
    public SqlNote(Context context, Cursor c) {
        mContext = context;
        mContentResolver = context.getContentResolver();
        mIsCreate = false;
        loadFromCursor(c);
        mDataList = new ArrayList<SqlData>();
        if (mType == Notes.TYPE_NOTE)
            loadDataContent();
        mDiffNoteValues = new ContentValues();
    }
    // 构造函数，用于从数据库中加载特定的SqlNote对象
    public SqlNote(Context context, long id) {
        mContext = context;
        mContentResolver = context.getContentResolver();
        mIsCreate = false;
        loadFromCursor(id);
        mDataList = new ArrayList<SqlData>();
        if (mType == Notes.TYPE_NOTE)
            loadDataContent();
        mDiffNoteValues = new ContentValues();
    }
    // 从游标加载数据
    private void loadFromCursor(long id) {
        Cursor c = null;
        try {
            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();
        }
    }
    // 从游标加载数据
    private void loadFromCursor(Cursor c) {
        mId = c.getLong(ID_COLUMN);
        mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
        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);
        mParentId = c.getLong(PARENT_ID_COLUMN);
        mSnippet = c.getString(SNIPPET_COLUMN);
        mType = c.getInt(TYPE_COLUMN);
        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 {
            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)
        }
    }
    // 设置内容，从JSONObject中读取数据
    public boolean setContent(JSONObject js) {
        try {
            JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
            if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
                Log.w(TAG, "cannot set system folder");
                return false;
            } 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);
                long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID;
                if (mIsCreate || mId != id) {
                    mDiffNoteValues.put(NoteColumns.ID, id);
                }
                mId = id;
                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;
                int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note
                        .getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext);
                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;
                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;
                long parentId = note.has(NoteColumns.PARENT_ID) ? note
                        .getLong(NoteColumns.PARENT_ID) : 0;
                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;
                int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID)
                        : AppWidgetManager.INVALID_APPWIDGET_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;
                long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note
                        .getLong(NoteColumns.ORIGIN_PARENT_ID) : 0;
                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) {
            Log.e(TAG, e.toString());
            e.printStackTrace();
            return false;
        }
        return true;
    }
    // 获取内容，返回JSONObject
    public JSONObject getContent() {
        try {
            JSONObject js = new JSONObject();
            if (mIsCreate) {
                Log.e(TAG, "it seems that we haven't created this in database yet");
                return null;
            }
            JSONObject note = new JSONObject();
            if (mType == Notes.TYPE_NOTE) {
                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);
                js.put(GTaskStringUtils.META_HEAD_NOTE, note);
                JSONArray dataArray = new JSONArray();
                for (SqlData sqlData : mDataList) {
                    JSONObject data = sqlData.getContent();
                    if (data != null) {
                        dataArray.put(data);
                    }
                }
                js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
            } 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);
                js.put(GTaskStringUtils.META_HEAD_NOTE, note);
            }
            return js;
        } catch (JSONException e) {
            Log.e(TAG, e.toString());
            e.printStackTrace();
        }
        return null;
    }
    // 设置父笔记ID
    public void setParentId(long id) {
        mParentId = id;
        mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
    }
    // 设置Google任务ID
    public void setGtaskId(String gid) {
        mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
    }
    // 设置同步ID
    public void setSyncId(long syncId) {
        mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
    }
    // 重置本地修改
    public void resetLocalModified() {
        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() {
        return mType == Notes.TYPE_NOTE;
    }
    // 提交笔记数据到数据库
    public void commit(boolean validateVersion) {
        if (mIsCreate) {
            if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
                mDiffNoteValues.remove(NoteColumns.ID);
            }
            Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
            try {
                mId = Long.valueOf(uri.getPathSegments().get(1));
            } catch (NumberFormatException e) {
                Log.e(TAG, "Get note id error :" + e.toString());
                throw new ActionFailureException("create note failed");
            }
            if (mId == 0) {
                throw new IllegalStateException("Create thread id failed");
            }
            if (mType == Notes.TYPE_NOTE) {
                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");
                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");
 }
 }
--- a/Task.java
+++ b/Task.java
@ -1,366 +0,0 @@
 // 版权声明
 /*
 * 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.database.Cursor;
 import android.text.TextUtils;
 import android.util.Log;
 import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.DataColumns;
 import net.micode.notes.data.Notes.DataConstants;
 import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.gtask.exception.ActionFailureException;
 import net.micode.notes.tool.GTaskStringUtils;
 import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 // Task类继承自Node类，表示一个任务
 public class Task extends Node {
    // 类的标签，用于日志记录
    private static final String TAG = Task.class.getSimpleName();
    // 成员变量
    private boolean mCompleted; // 表示任务是否完成
    private String mNotes; // 任务的备注信息
    private JSONObject mMetaInfo; // 任务的元数据信息
    private Task mPriorSibling; // 表示任务在任务列表中的前一个任务
    private TaskList mParent; // 表示任务所属的任务列表
    // 构造函数
    public Task() {
        super(); // 调用父类的构造函数
        mCompleted = false; // 默认任务未完成
        mNotes = null; // 初始没有备注信息
        mPriorSibling = null; // 初始没有前一个任务
        mParent = null; // 初始没有所属的任务列表
        mMetaInfo = null; // 初始没有元数据信息
    }
    // 生成创建任务的JSON对象
    public JSONObject getCreateAction(int actionId) {
        JSONObject js = new JSONObject(); // 创建一个空的JSON对象
        try {
            // action_type
            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
            // action_id
            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
            // index
            js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
            // entity_delta
            JSONObject entity = new JSONObject();
            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
            entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
            entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
                    GTaskStringUtils.GTASK_JSON_TYPE_TASK);
            if (getNotes() != null) {
                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
            }
            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
            // parent_id
            js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
            // dest_parent_type
            js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
                    GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
            // list_id
            js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
            // prior_sibling_id
            if (mPriorSibling != null) {
                js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
            }
        } catch (JSONException e) {
            Log.e(TAG, e.toString());
            e.printStackTrace();
            throw new ActionFailureException("fail to generate task-create jsonobject");
        }
        return js;
    }
    // 生成更新任务的JSON对象
    public JSONObject getUpdateAction(int actionId) {
        JSONObject js = new JSONObject();
        try {
            // action_type
            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
            // action_id
            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
            // id
            js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
            // entity_delta
            JSONObject entity = new JSONObject();
            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
            if (getNotes() != null) {
                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
            }
            entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
        } catch (JSONException e) {
            Log.e(TAG, e.toString());
            e.printStackTrace();
            throw new ActionFailureException("fail to generate task-update jsonobject");
        }
        return js;
    }
    // 根据远程JSON对象设置任务内容
    public void setContentByRemoteJSON(JSONObject js) {
        if (js != null) {
            try {
                // id
                if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
                    setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
                }
                // last_modified
                if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
                    setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
                }
                // name
                if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
                    setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
                }
                // notes
                if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) {
                    setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES));
                }
                // deleted
                if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) {
                    setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED));
                }
                // completed
                if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) {
                    setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED));
                }
            } catch (JSONException e) {
                Log.e(TAG, e.toString());
                e.printStackTrace();
                throw new ActionFailureException("fail to get task content from jsonobject");
            }
        }
    }
    // 根据本地JSON对象设置任务内容
    public void setContentByLocalJSON(JSONObject js) {
        if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
                || !js.has(GTaskStringUtils.META_HEAD_DATA)) {
            Log.w(TAG, "setContentByLocalJSON: nothing is available");
        }
        try {
            JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
            JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
            if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) {
                Log.e(TAG, "invalid type");
                return;
            }
            for (int i = 0; i < dataArray.length(); i++) {
                JSONObject data = dataArray.getJSONObject(i);
                if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
                    setName(data.getString(DataColumns.CONTENT));
                    break;
                }
            }
        } catch (JSONException e) {
            Log.e(TAG, e.toString());
            e.printStackTrace();
        }
    }
    // 从内容生成本地JSON对象
    public JSONObject getLocalJSONFromContent() {
        String name = getName();
        try {
            if (mMetaInfo == null) {
                // new task created from web
                if (name == null) {
                    Log.w(TAG, "the note seems to be an empty one");
                    return null;
                }
                JSONObject js = new JSONObject();
                JSONObject note = new JSONObject();
                JSONArray dataArray = new JSONArray();
                JSONObject data = new JSONObject();
                data.put(DataColumns.CONTENT, name);
                dataArray.put(data);
                js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
                note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
                js.put(GTaskStringUtils.META_HEAD_NOTE, note);
                return js;
            } else {
                // synced task
                JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
                JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
                for (int i = 0; i < dataArray.length(); i++) {
                    JSONObject data = dataArray.getJSONObject(i);
                    if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
                        data.put(DataColumns.CONTENT, getName());
                        break;
                    }
                }
                note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
                return mMetaInfo;
            }
        } catch (JSONException e) {
            Log.e(TAG, e.toString());
            e.printStackTrace();
            return null;
        }
    }
    // 设置任务的元数据信息
    public void setMetaInfo(MetaData metaData) {
        if (metaData != null && metaData.getNotes() != null) {
            try {
                mMetaInfo = new JSONObject(metaData.getNotes());
            } catch (JSONException e) {
                Log.w(TAG, e.toString());
                mMetaInfo = null;
 }
 }
 }
 // 确定同步操作类型
 public int getSyncAction(Cursor c) {
    try {
        JSONObject noteInfo = null;
        if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) {
            noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
        }
        if (noteInfo == null) {
            Log.w(TAG, "it seems that note meta has been deleted");
            return SYNC_ACTION_UPDATE_REMOTE;
        }
        if (!noteInfo.has(NoteColumns.ID)) {
            Log.w(TAG, "remote note id seems to be deleted");
            return SYNC_ACTION_UPDATE_LOCAL;
        }
        // validate the note id now
        if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) {
            Log.w(TAG, "note id doesn't match");
            return SYNC_ACTION_UPDATE_LOCAL;
        }
        if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
            // there is no local update
            if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
                // no update both side
                return SYNC_ACTION_NONE;
            } else {
                // apply remote to local
                return SYNC_ACTION_UPDATE_LOCAL;
            }
        } else {
            // validate gtask id
            if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
                Log.e(TAG, "gtask id doesn't match");
                return SYNC_ACTION_ERROR;
            }
            if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
                // local modification only
                return SYNC_ACTION_UPDATE_REMOTE;
            } else {
                return SYNC_ACTION_UPDATE_CONFLICT;
            }
        }
    } catch (Exception e) {
        Log.e(TAG, e.toString());
        e.printStackTrace();
    }
    return SYNC_ACTION_ERROR;
 }
 // 判断任务是否值得保存
 public boolean isWorthSaving() {
    return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)
            || (getNotes() != null && getNotes().trim().length() > 0);
 }
 // 设置任务是否完成
 public void setCompleted(boolean completed) {
    this.mCompleted = completed;
 }
 // 设置任务的备注信息
 public void setNotes(String notes) {
    this.mNotes = notes;
 }
 // 设置任务在任务列表中的前一个任务
 public void setPriorSibling(Task priorSibling) {
    this.mPriorSibling = priorSibling;
 }
 // 设置任务所属的任务列表
 public void setParent(TaskList parent) {
    this.mParent = parent;
 }
 // 获取任务是否完成
 public boolean getCompleted() {
    return this.mCompleted;
 }
 // 获取任务的备注信息
 public String getNotes() {
    return this.mNotes;
 }
 // 获取任务在任务列表中的前一个任务
 public Task getPriorSibling() {
    return this.mPriorSibling;
 }
 // 获取任务所属的任务列表
 public TaskList getParent() {
    return this.mParent;
 }
--- a/TaskList.java
+++ b/TaskList.java
@ -1,363 +0,0 @@
 // 版权声明和许可证信息
 /*
 * 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.database.Cursor;
 import android.util.Log;
 import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.gtask.exception.ActionFailureException;
 import net.micode.notes.tool.GTaskStringUtils;
 import org.json.JSONException;
 import org.json.JSONObject;
 import java.util.ArrayList;
 // TaskList类继承自Node类，用于表示一个任务列表
 public class TaskList extends Node {
    // 类的标签，用于日志记录
    private static final String TAG = TaskList.class.getSimpleName();
    // 成员变量
    private int mIndex; // 任务列表的索引
    private ArrayList<Task> mChildren; // 任务列表中的任务
    // 构造函数
    public TaskList() {
        super(); // 调用父类的构造函数
        mChildren = new ArrayList<Task>(); // 初始化任务列表
        mIndex = 1; // 默认索引为1
    }
    // 生成创建任务列表的JSON对象
    public JSONObject getCreateAction(int actionId) {
        JSONObject js = new JSONObject(); // 创建一个空的JSON对象
        try {
            // action_type
            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
            // action_id
            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
            // index
            js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex);
            // entity_delta
            JSONObject entity = new JSONObject();
            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
            entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
            entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
                    GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
        } catch (JSONException e) {
            Log.e(TAG, e.toString());
            e.printStackTrace();
            throw new ActionFailureException("fail to generate tasklist-create jsonobject");
        }
        return js;
    }
    // 生成更新任务列表的JSON对象
    public JSONObject getUpdateAction(int actionId) {
        JSONObject js = new JSONObject();
        try {
            // action_type
            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
            // action_id
            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
            // id
            js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
            // entity_delta
            JSONObject entity = new JSONObject();
            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
            entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
        } catch (JSONException e) {
            Log.e(TAG, e.toString());
            e.printStackTrace();
            throw new ActionFailureException("fail to generate tasklist-update jsonobject");
        }
        return js;
    }
    // 根据远程JSON对象设置任务列表内容
    public void setContentByRemoteJSON(JSONObject js) {
        if (js != null) {
            try {
                // id
                if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
                    setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
                }
                // last_modified
                if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
                    setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
                }
                // name
                if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
                    setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
                }
            } catch (JSONException e) {
                Log.e(TAG, e.toString());
                e.printStackTrace();
                throw new ActionFailureException("fail to get tasklist content from jsonobject");
            }
        }
    }
    // 根据本地JSON对象设置任务列表内容
    public void setContentByLocalJSON(JSONObject js) {
        if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) {
            Log.w(TAG, "setContentByLocalJSON: nothing is available");
        }
        try {
            JSONObject folder = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
            if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
                String name = folder.getString(NoteColumns.SNIPPET);
                setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + name);
            } else if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
                if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER)
                    setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT);
                else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER)
                    setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX
                            + GTaskStringUtils.FOLDER_CALL_NOTE);
                else
                    Log.e(TAG, "invalid system folder");
            } else {
                Log.e(TAG, "error type");
            }
        } catch (JSONException e) {
            Log.e(TAG, e.toString());
            e.printStackTrace();
        }
    }
    // 从内容生成本地JSON对象
    public JSONObject getLocalJSONFromContent() {
        try {
            JSONObject js = new JSONObject();
            JSONObject folder = new JSONObject();
            String folderName = getName();
            if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX))
                folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length(),
                        folderName.length());
            folder.put(NoteColumns.SNIPPET, folderName);
            if (folderName.equals(GTaskStringUtils.FOLDER_DEFAULT)
                    || folderName.equals(GTaskStringUtils.FOLDER_CALL_NOTE))
                folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
            else
                folder.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
            js.put(GTaskStringUtils.META_HEAD_NOTE, folder);
            return js;
        } catch (JSONException e) {
            Log.e(TAG, e.toString());
            e.printStackTrace();
            return null;
        }
    }
    // 确定同步操作类型
    public int getSyncAction(Cursor c) {
        try {
            if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
                // there is no local update
                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
                    // no update both side
                    return SYNC_ACTION_NONE;
                } else {
                    // apply remote to local
                    return SYNC_ACTION_UPDATE_LOCAL;
                }
            } else {
                // validate gtask id
                if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
                    Log.e(TAG, "gtask id doesn't match");
                    return SYNC_ACTION_ERROR;
                }
                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
                    // local modification only
                    return SYNC_ACTION_UPDATE_REMOTE;
                } else {
                    // for folder conflicts, just apply local modification
                    return SYNC_ACTION_UPDATE_REMOTE;
                }
            }
        } catch (Exception e) {
            Log.e(TAG, e.toString());
            e.printStackTrace();
        }
        return SYNC_ACTION_ERROR;
    }
    // 获取子任务的数量
    public int getChildTaskCount() {
        return mChildren.size();
    }
    // 添加子任务
    public boolean addChildTask(Task task) {
        boolean ret = false;
        if (task != null && !mChildren.contains(task)) {
            ret = mChildren.add(task);
            if (ret) {
                // need to set prior sibling and parent
                task.setPriorSibling(mChildren.isEmpty() ? null : mChildren
                        .get(mChildren.size() - 1));
                task.setParent(this);
            }
        }
        return ret;
    }
    // 在指定位置添加子任务
    public boolean addChildTask(Task task, int index) {
        if (index < 0 || index > mChildren.size()) {
            Log.e(TAG, "add child task: invalid index");
            return false;
        }
        int pos = mChildren.indexOf(task);
        if (task != null && pos == -1) {
            mChildren.add(index, task);
            // update the task list
            Task preTask = null;
            Task afterTask = null;
            if (index != 0)
                preTask = mChildren.get(index - 1);
            if (index != mChildren.size() - 1)
                afterTask = mChildren.get(index + 1);
            task.setPriorSibling(preTask);
            if (afterTask != null)
                afterTask.setPriorSibling(task);
 }
    return true;
 }
 // 移除子任务
 public boolean removeChildTask(Task task) {
    boolean ret = false;
    int index = mChildren.indexOf(task);
    if (index != -1) {
        ret = mChildren.remove(task);
        if (ret) {
            // reset prior sibling and parent
            task.setPriorSibling(null);
            task.setParent(null);
            // update the task list
            if (index != mChildren.size()) {
                mChildren.get(index).setPriorSibling(
                        index == 0 ? null : mChildren.get(index - 1));
            }
        }
    }
    return ret;
 }
 // 移动子任务到指定位置
 public boolean moveChildTask(Task task, int index) {
    if (index < 0 || index >= mChildren.size()) {
        Log.e(TAG, "move child task: invalid index");
        return false;
    }
    int pos = mChildren.indexOf(task);
    if (pos == -1) {
        Log.e(TAG, "move child task: the task should in the list");
        return false;
    }
    if (pos == index)
        return true;
    return (removeChildTask(task) && addChildTask(task, index));
 }
 // 根据GID查找子任务
 public Task findChildTaskByGid(String gid) {
    for (int i = 0; i < mChildren.size(); i++) {
        Task t = mChildren.get(i);
        if (t.getGid().equals(gid)) {
            return t;
        }
    }
    return null;
 }
 // 获取子任务的索引
 public int getChildTaskIndex(Task task) {
    return mChildren.indexOf(task);
 }
 // 根据索引获取子任务
 public Task getChildTaskByIndex(int index) {
    if (index < 0 || index >= mChildren.size()) {
        Log.e(TAG, "getTaskByIndex: invalid index");
        return null;
    }
    return mChildren.get(index);
 }
 // 根据GID获取子任务
 public Task getChilTaskByGid(String gid) {
    for (Task task : mChildren) {
        if (task.getGid().equals(gid))
            return task;
    }
    return null;
 }
 // 获取子任务列表
 public ArrayList<Task> getChildTaskList() {
    return this.mChildren;
 }
 // 设置索引
 public void setIndex(int index) {
    this.mIndex = index;
 }
 // 获取索引
 public int getIndex() {
    return this.mIndex;
 }
--- a/WorkingNote.java
+++ b/WorkingNote.java
@ -1,404 +0,0 @@
 // 包声明，定义了该类所在的包名
 package net.micode.notes.model;
 // 导入所需的Android类库
 import android.appwidget.AppWidgetManager;
 import android.content.ContentUris;
 import android.content.Context;
 import android.database.Cursor;
 import android.text.TextUtils;
 import android.util.Log;
 // 导入项目中定义的数据表和列名
 import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.CallNote;
 import net.micode.notes.data.Notes.DataColumns;
 import net.micode.notes.data.Notes.DataConstants;
 import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.data.Notes.TextNote;
 import net.micode.notes.tool.ResourceParser.NoteBgResources;
 // 定义WorkingNote类，用于表示一个工作便签
 public class WorkingNote {
    // Note对象，用于操作便签数据
    private Note mNote;
    // 便签ID
    private long mNoteId;
    // 便签内容
    private String mContent;
    // 便签模式
    private int mMode;
    // 便签提醒日期
    private long mAlertDate;
    // 便签修改日期
    private long mModifiedDate;
    // 便签背景颜色ID
    private int mBgColorId;
    // 小部件ID
    private int mWidgetId;
    // 小部件类型
    private int mWidgetType;
    // 便签所在文件夹ID
    private long mFolderId;
    // 上下文对象
    private Context mContext;
    // 日志标签
    private static final String TAG = "WorkingNote";
    // 是否被删除
    private boolean mIsDeleted;
    // 便签设置更改监听器
    private NoteSettingChangedListener mNoteSettingStatusListener;
    // 数据查询投影
    public static final String[] DATA_PROJECTION = new String[] {
            DataColumns.ID,
            DataColumns.CONTENT,
            DataColumns.MIME_TYPE,
            DataColumns.DATA1,
            DataColumns.DATA2,
            DataColumns.DATA3,
            DataColumns.DATA4,
    };
    // 便签查询投影
    public static final String[] NOTE_PROJECTION = new String[] {
            NoteColumns.PARENT_ID,
            NoteColumns.ALERTED_DATE,
            NoteColumns.BG_COLOR_ID,
            NoteColumns.WIDGET_ID,
            NoteColumns.WIDGET_TYPE,
            NoteColumns.MODIFIED_DATE
    };
    // 数据ID列索引
    private static final int DATA_ID_COLUMN = 0;
    // 数据内容列索引
    private static final int DATA_CONTENT_COLUMN = 1;
    // 数据MIME类型列索引
    private static final int DATA_MIME_TYPE_COLUMN = 2;
    // 数据模式列索引
    private static final int DATA_MODE_COLUMN = 3;
    // 便签父ID列索引
    private static final int NOTE_PARENT_ID_COLUMN = 0;
    // 便签提醒日期列索引
    private static final int NOTE_ALERTED_DATE_COLUMN = 1;
    // 便签背景颜色ID列索引
    private static final int NOTE_BG_COLOR_ID_COLUMN = 2;
    // 便签小部件ID列索引
    private static final int NOTE_WIDGET_ID_COLUMN = 3;
    // 便签小部件类型列索引
    private static final int NOTE_WIDGET_TYPE_COLUMN = 4;
    // 便签修改日期列索引
    private static final int NOTE_MODIFIED_DATE_COLUMN = 5;
    // 新建便签构造函数
    private WorkingNote(Context context, long folderId) {
        mContext = context;
        mAlertDate = 0;
        mModifiedDate = System.currentTimeMillis();
        mFolderId = folderId;
        mNote = new Note();
        mNoteId = 0;
        mIsDeleted = false;
        mMode = 0;
        mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
    }
    // 现有便签构造函数
    private WorkingNote(Context context, long noteId, long folderId) {
        mContext = context;
        mNoteId = noteId;
        mFolderId = folderId;
        mIsDeleted = false;
        mNote = new Note();
        loadNote();
    }
    // 加载便签数据
    private void loadNote() {
        Cursor cursor = mContext.getContentResolver().query(
                ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
                null, null);
        if (cursor != null) {
            if (cursor.moveToFirst()) {
                mFolderId = cursor.getLong(NOTE_PARENT_ID_COLUMN);
                mBgColorId = cursor.getInt(NOTE_BG_COLOR_ID_COLUMN);
                mWidgetId = cursor.getInt(NOTE_WIDGET_ID_COLUMN);
                mWidgetType = cursor.getInt(NOTE_WIDGET_TYPE_COLUMN);
                mAlertDate = cursor.getLong(NOTE_ALERTED_DATE_COLUMN);
                mModifiedDate = cursor.getLong(NOTE_MODIFIED_DATE_COLUMN);
            }
            cursor.close();
        } else {
            Log.e(TAG, "No note with id:" + mNoteId);
            throw new IllegalArgumentException("Unable to find note with id " + mNoteId);
        }
        loadNoteData();
    }
    // 加载便签数据内容
    private void loadNoteData() {
        Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION,
                DataColumns.NOTE_ID + "=?", new String[] {
                    String.valueOf(mNoteId)
                }, null);
        if (cursor != null) {
            if (cursor.moveToFirst()) {
                do {
                    String type = cursor.getString(DATA_MIME_TYPE_COLUMN);
                    if (DataConstants.NOTE.equals(type)) {
                        mContent = cursor.getString(DATA_CONTENT_COLUMN);
                        mMode = cursor.getInt(DATA_MODE_COLUMN);
                        mNote.setTextDataId(cursor.getLong(DATA_ID_COLUMN));
                    } else if (DataConstants.CALL_NOTE.equals(type)) {
                        mNote.setCallDataId(cursor.getLong(DATA_ID_COLUMN));
                    } else {
                        Log.d(TAG, "Wrong note type with type:" + type);
                    }
                } while (cursor.moveToNext());
            }
            cursor.close();
        } else {
            Log.e(TAG, "No data with id:" + mNoteId);
            throw new IllegalArgumentException("Unable to find note's data with id " + mNoteId);
        }
    }
    // 创建空便签
    public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
            int widgetType, int defaultBgColorId) {
        WorkingNote note = new WorkingNote(context, folderId);
        note.setBgColorId(defaultBgColorId);
        note.setWidgetId(widgetId);
        note.setWidgetType(widgetType);
        return note;
    }
    // 加载便签
    public static WorkingNote load(Context context, long id) {
        return new WorkingNote(context, id, 0);
    }
    // 保存便签
    public synchronized boolean saveNote() {
        if (isWorthSaving()) {
            if (!existInDatabase()) {
                if ((mNoteId = Note.getNewNoteId(mContext, mFolderId)) == 0) {
                    Log.e(TAG, "Create new note fail with id:" + mNoteId);
                    return false;
                }
            }
            mNote.syncNote(mContext, mNoteId);
            /**
             * Update widget content if there exist any widget of this note
             */
            if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
                    && mWidgetType != Notes.TYPE_WIDGET_INVALIDE
                    && mNoteSettingStatusListener != null) {
                mNoteSettingStatusListener.onWidgetChanged();
            }
            return true;
        } else {
            return false;
        }
    }
    // 判断便签是否存在于数据库中
    public boolean existInDatabase() {
        return mNoteId > 0;
    }
    // 判断便签是否值得保存
    private boolean isWorthSaving() {
        if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
                || (existInDatabase() && !mNote.isLocalModified())) {
            return false;
        } else {
            return true;
        }
    }
    // 设置便签设置更改监听器
    public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
        mNoteSettingStatusListener = l;
    }
    // 设置提醒日期
    public void setAlertDate(long date, boolean set) {
        if (date != mAlertDate) {
            mAlertDate = date;
            mNote.setNoteValue(NoteColumns.ALERTED_DATE, String.valueOf(mAlertDate));
        }
        if (mNoteSettingStatusListener != null) {
            mNoteSettingStatusListener.onClockAlertChanged(date, set);
        }
    }
    // 标记便签是否被删除
    public void markDeleted(boolean mark) {
        mIsDeleted = mark;
        if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
                && mWidgetType != Notes.TYPE_WIDGET_INVALIDE && mNoteSettingStatusListener != null) {
                mNoteSettingStatusListener.onWidgetChanged();
        }
    }
    // 设置背景颜色ID
    public void setBgColorId(int id) {
        if (id != mBgColorId) {
            mBgColorId =id;
 		if (mNoteSettingStatusListener != null) {
 			mNoteSettingStatusListener.onBackgroundColorChanged();
 		}
 		mNote.setNoteValue(NoteColumns.BG_COLOR_ID, String.valueOf(id));
 	}
 }
 // 设置检查列表模式
 public void setCheckListMode(int mode) {
    if (mMode != mode) {
        if (mNoteSettingStatusListener != null) {
            mNoteSettingStatusListener.onCheckListModeChanged(mMode, mode);
        }
        mMode = mode;
        mNote.setTextData(TextNote.MODE, String.valueOf(mMode));
    }
 }
 // 设置小部件类型
 public void setWidgetType(int type) {
    if (type != mWidgetType) {
        mWidgetType = type;
        mNote.setNoteValue(NoteColumns.WIDGET_TYPE, String.valueOf(mWidgetType));
    }
 }
 // 设置小部件ID
 public void setWidgetId(int id) {
    if (id != mWidgetId) {
        mWidgetId = id;
        mNote.setNoteValue(NoteColumns.WIDGET_ID, String.valueOf(mWidgetId));
    }
 }
 // 设置工作文本
 public void setWorkingText(String text) {
    if (!TextUtils.equals(mContent, text)) {
        mContent = text;
        mNote.setTextData(DataColumns.CONTENT, mContent);
    }
 }
 // 转换为通话便签
 public void convertToCallNote(String phoneNumber, long callDate) {
    mNote.setCallData(CallNote.CALL_DATE, String.valueOf(callDate));
    mNote.setCallData(CallNote.PHONE_NUMBER, phoneNumber);
    mNote.setNoteValue(NoteColumns.PARENT_ID, String.valueOf(Notes.ID_CALL_RECORD_FOLDER));
 }
 // 判断是否有提醒闹钟
 public boolean hasClockAlert() {
    return (mAlertDate > 0 ? true : false);
 }
 // 获取便签内容
 public String getContent() {
    return mContent;
 }
 // 获取提醒日期
 public long getAlertDate() {
    return mAlertDate;
 }
 // 获取修改日期
 public long getModifiedDate() {
    return mModifiedDate;
 }
 // 获取背景颜色资源ID
 public int getBgColorResId() {
    return NoteBgResources.getNoteBgResource(mBgColorId);
 }
 // 获取背景颜色ID
 public int getBgColorId() {
    return mBgColorId;
 }
 // 获取标题背景资源ID
 public int getTitleBgResId() {
    return NoteBgResources.getNoteTitleBgResource(mBgColorId);
 }
 // 获取检查列表模式
 public int getCheckListMode() {
    return mMode;
 }
 // 获取便签ID
 public long getNoteId() {
    return mNoteId;
 }
 // 获取便签所在文件夹ID
 public long getFolderId() {
    return mFolderId;
 }
 // 获取小部件ID
 public int getWidgetId() {
    return mWidgetId;
 }
 // 获取小部件类型
 public int getWidgetType() {
    return mWidgetType;
 }
 // 定义便签设置更改监听器接口
 public interface NoteSettingChangedListener {
    /**
     * Called when the background color of current note has just changed
     */
    void onBackgroundColorChanged();
    /**
     * Called when user set clock
     */
    void onClockAlertChanged(long date, boolean set);
    /**
     * Call when user create note from widget
     */
    void onWidgetChanged();
    /**
     * Call when switch between check list mode and normal mode
     * @param oldMode is previous mode before change
     * @param newMode is new mode
     */
    void onCheckListModeChanged(int oldMode, int newMode);
 }
--- a/hello.txt
+++ b/hello.txt
--- a/mi.java
+++ b/mi.java
@ -0,0 +1 @@
 xiaomi
--- a/(2).txt
+++ b/(2).txt
@ -0,0 +1,236 @@
 以下是对这段代码每一行的注释：
 ```java
 /*
 * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
 * 版权声明，指出代码由The MiCode Open Source Community拥有版权，并提供了他们的网址。
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * 声明代码遵循Apache License 2.0。
 * 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.ui;
 // 声明代码属于哪个包。
 import android.app.Activity;
 // 导入Activity类，是Android应用程序的基础类。
 import android.app.AlertDialog;
 // 导入AlertDialog类，用于显示对话框。
 import android.content.Context;
 // 导入Context类，提供关于应用程序环境的信息。
 import android.content.DialogInterface;
 // 导入DialogInterface类，是对话框中按钮监听器的基接口。
 import android.content.DialogInterface.OnClickListener;
 // 导入OnClickListener接口，用于处理对话框按钮点击事件。
 import android.content.DialogInterface.OnDismissListener;
 // 导入OnDismissListener接口，用于处理对话框被关闭的事件。
 import android.content.Intent;
 // 导入Intent类，用于在组件之间传递消息。
 import android.media.AudioManager;
 // 导入AudioManager类，用于管理与音频相关的操作。
 import android.media.MediaPlayer;
 // 导入MediaPlayer类，用于播放音频文件。
 import android.media.RingtoneManager;
 // 导入RingtoneManager类，用于管理铃声。
 import android.net.Uri;
 // 导入Uri类，表示一个统一的资源标识符。
 import android.os.Bundle;
 // 导入Bundle类，用于存储键值对的数据。
 import android.os.PowerManager;
 // 导入PowerManager类，用于管理系统电源。
 import android.provider.Settings;
 // 导入Settings类，用于访问系统设置。
 import android.view.Window;
 // 导入Window类，表示应用窗口。
 import android.view.WindowManager;
 // 导入WindowManager类，用于管理窗口。
 import net.micode.notes.R;
 // 导入R类，包含了应用程序的资源。
 import net.micode.notes.data.Notes;
 // 导入Notes类，用于处理笔记数据。
 import net.micode.notes.tool.DataUtils;
 // 导入DataUtils类，提供了数据操作的工具方法。
 import java.io.IOException;
 // 导入IOException类，表示I/O异常。
 ```
 ```java
 public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener {
 // 声明一个名为AlarmAlertActivity的公共类，继承自Activity类，并实现OnClickListener和OnDismissListener接口。
    private long mNoteId;
    // 定义一个私有成员变量mNoteId，用于存储笔记的ID。
    private String mSnippet;
    // 定义一个私有成员变量mSnippet，用于存储笔记的预览文本。
    private static final int SNIPPET_PREW_MAX_LEN = 60;
    // 定义一个常量，限定预览文本的最大长度。
    MediaPlayer mPlayer;
    // 定义一个MediaPlayer对象，用于播放音频。
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        // 请求一个没有标题的窗口特性。
        final Window win = getWindow();
        win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
        // 设置窗口参数，即使在锁定屏幕时也能显示窗口。
        if (!isScreenOn()) {
            win.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
                    | WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
                    | WindowManager.LayoutParams.FLAG_ALLOW_LOCK_WHILE_SCREEN_ON
                    | WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR);
        }
        // 如果屏幕不亮，则设置窗口参数以保持屏幕常亮。
        Intent intent = getIntent();
        // 获取启动该Activity的Intent。
        try {
            mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1));
            // 从Intent中获取笔记ID。
            mSnippet = DataUtils.getSnippetById(this.getContentResolver(), mNoteId);
            // 根据笔记ID获取笔记的预览文本。
            mSnippet = mSnippet.length() > SNIPPET_PREW_MAX_LEN ? mSnippet.substring(0,
                    SNIPPET_PREW_MAX_LEN) + getResources().getString(R.string.notelist_string_info)
                    : mSnippet;
            // 如果预览文本超过最大长度，则截断并添加省略号。
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
            return;
        }
        mPlayer = new MediaPlayer();
        // 初始化MediaPlayer对象。
        if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) {
            showActionDialog();
            // 显示操作对话框。
            playAlarmSound();
            // 播放闹钟声音。
        } else {
            finish();
            // 如果笔记不在数据库中，则结束该Activity。
        }
    }
    private boolean isScreenOn() {
        PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
        // 获取电源服务。
        return pm.isScreenOn();
        // 返回屏幕是否亮着。
    }
    private void playAlarmSound() {
        Uri url = RingtoneManager.getActualDefaultRingtoneUri(this, RingtoneManager.TYPE_ALARM);
        // 获取默认闹钟铃声的Uri。
        int silentModeStreams = Settings.System.getInt(getContentResolver(),
                Settings.System.MODE_RINGER_STREAMS_AFFECTED, 0);
        // 获取静音模式下受影响的音频流。
        if ((silentModeStreams & (1 << AudioManager.STREAM_ALARM)) != 0) {
            mPlayer.setAudioStreamType(silentModeStreams);
        } else {
            mPlayer.setAudioStreamType(AudioManager.STREAM_ALARM);
        }
        // 设置MediaPlayer的音频流类型。
        try {
            mPlayer.setDataSource(this, url);
            // 设置MediaPlayer的数据源。
            mPlayer.prepare();
            // 准备MediaPlayer。
            mPlayer.setLooping(true);
            // 设置MediaPlayer循环播放。
            mPlayer.start();
            // 开始播放。
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalStateException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    private void showActionDialog() {
        AlertDialog.Builder dialog = new AlertDialog.Builder(this);
        // 创建AlertDialog的构造器。
        dialog.setTitle(R.string.app_name);
        // 设置对话框标题。
        dialog.setMessage(mSnippet);
        // 设置对话框消息。
        dialog.setPositiveButton(R.string.notealert_ok, this);
        // 设置对话框的确定按钮。
        if (isScreenOn()) {
            dialog.setNegativeButton(R.string.notealert_enter, this);
        }
        // 如果屏幕亮着，设置对话框的进入按钮。
        dialog.show().setOnDismissListener(this);
        // 显示对话框并设置对话框消失监听器。
    }
    public void onClick(DialogInterface dialog, int which) {
        // 实现OnClickListener接口的onClick方法。
        switch (which) {
            case DialogInterface.BUTTON_NEGATIVE:
                Intent intent = new Intent(this, NoteEditActivity.class);
                // 创建一个新的Intent，意图是打开NoteEditActivity。
                intent.setAction(Intent.ACTION_VIEW);
                // 设置Intent的动作为查看。
                intent.putExtra(Intent.EXTRA_UID, mNoteId);
                // 将笔记ID作为额外信息传递给NoteEditActivity。
                startActivity(intent);
                // 启动NoteEditActivity。
                break;
            default:
                break;
        }
    }
    public void onDismiss(DialogInterface dialog) {
        // 实现OnDismissListener接口的onDismiss方法。
        stopAlarmSound();
        // 停止闹钟声音。
        finish();
        // 结束该Activity。
    }
    private void stopAlarmSound() {
        // 定义一个私有方法来停止闹钟声音。
        if (mPlayer != null) {
            mPlayer.stop();
            // 停止MediaPlayer。
            mPlayer.release();
            // 释放MediaPlayer资源。
            mPlayer = null;
            // 将MediaPlayer对象设置为null。
        }
    }
 }
 ```
Author	SHA1	Message	Date
p2hs734fm	d0ebe1795d	Delete 'TaskList.java'	4 weeks ago
zhangwenqing	2d403a0d6e	同步任务列表，将Task组织成同步任务列表进行管理	4 weeks ago
LZ	48ac1b02b0	注释代码AlarmAlertActivity(2)的全文代码	3 months ago
p2hs734fm	3711a8ac34	Delete 'Contact.java'	4 months ago
p2hs734fm	9614a4023f	Delete 'Notes.java'	4 months ago
zhangwenqing	3bd5ad87ad	baodao	5 months ago
zhangwenqing	83fbc318ef	Merge branch 'main' of https://bdgit.educoder.net/pyqg8khpo/5MI	5 months ago
zhangwenqing	75f13ae167	baodao	5 months ago
zwq	741fe15a22	baodao	5 months ago
p7enkxv86	cdaae6d879	Delete '1.java'	5 months ago
p7enkxv86	ab29b52801	Delete 'README.md'	5 months ago
p7enkxv86	074e70ff90	Delete 'Note.java'	5 months ago
p7enkxv86	69f4609a22	Delete 'GTaskStringUtils.java'	5 months ago
p7enkxv86	664ae9568f	Delete '11.java'	5 months ago
LZ	16589381b9	测试	5 months ago
LZ	27f9dad72e	测试	5 months ago
LZ	7c59e17b36	测试	5 months ago
LZ	8b8b0a2f4f	测试	5 months ago
LZ	8f9b3726f4	测试	5 months ago