diff --git a/src/230340137毛鑫宇.txt b/src/230340137毛鑫宇.txt
deleted file mode 100644
index d6c79a5..0000000
--- a/src/230340137毛鑫宇.txt
+++ /dev/null
@@ -1,1284 +0,0 @@
-（1）	类名：Contact
-// Contact类，用于处理联系人相关操作
-public class Contact {
-    // 用于缓存联系人信息的HashMap，键为电话号码，值为联系人姓名
-    private static HashMap<String, String> sContactCache; 
-    // 日志标签，用于在日志中标识该类相关的信息
-    private static final String TAG = "Contact"; 
-    // 查询联系人ID的SQL语句选择条件，用于筛选符合条件的联系人
-    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));
-        // 通过内容解析器查询联系人数据库
-        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 {
-            // 若未找到匹配的联系人，记录日志
-            Log.d(TAG, "No contact matched with number:" + phoneNumber); 
-            return null;
-        }
-    }
-}
-
-（2）	类名：Notes
-// Notes类，定义便签和文件夹相关的常量和接口
-public class Notes {
-    // 内容提供者的权限名
-    public static final String AUTHORITY = "micode_notes"; 
-    // 日志标签
-    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
-    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; 
-    // 便签提醒时间的Intent额外字段名
-    public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date"; 
-    // 便签背景颜色ID的Intent额外字段名
-    public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id"; 
-    // 便签小部件ID的Intent额外字段名
-    public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id"; 
-    // 便签小部件类型的Intent额外字段名
-    public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type"; 
-    // 文件夹ID的Intent额外字段名
-    public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id"; 
-    // 通话日期的Intent额外字段名
-    public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date"; 
-    // 无效的小部件类型
-    public static final int TYPE_WIDGET_INVALIDE = -1; 
-    // 2x尺寸的小部件类型（此处代码未完整展示相关内容，假设后续有相关逻辑）
-    public static final int TYPE_WIDGET_2X = 2; 
-}
-
-（3）	类名：NotesDatabaseHelper
- import android.content.Context;
-import android.database.sqlite.SQLiteDatabase;
-import android.database.sqlite.SQLiteOpenHelper;
-
-// NotesDatabaseHelper类，负责创建和管理数据库表及相关触发器
-public class NotesDatabaseHelper extends SQLiteOpenHelper {
-    // 数据库名称
-    private static final String DATABASE_NAME = "notes.db"; 
-    // 数据库版本
-    private static final int DATABASE_VERSION = 1; 
-
-    // 便签表名称
-    public static final String TABLE_NOTE = "note"; 
-    // 数据记录表名称
-    public static final String TABLE_DATA = "data"; 
-
-    // 构造函数，初始化数据库帮助类
-    public NotesDatabaseHelper(Context context) {
-        super(context, DATABASE_NAME, null, DATABASE_VERSION);
-    }
-
-    // 创建数据库表和触发器
-    @Override
-    public void onCreate(SQLiteDatabase db) {
-        // 创建便签表的SQL语句
-        String createNoteTable = "CREATE TABLE " + TABLE_NOTE + " ("
-                + "id INTEGER PRIMARY KEY AUTOINCREMENT, "
-                + "parent_id INTEGER, "
-                + "type INTEGER, "
-                + "created_date LONG, "
-                + "modified_date LONG, "
-                + "snippet TEXT, "
-                + "alerted_date LONG, "
-                + "bg_color_id INTEGER, "
-                + "widget_id INTEGER, "
-                + "widget_type INTEGER, "
-                + "local_modified INTEGER"
-                + ")";
-        db.execSQL(createNoteTable);
-
-        // 创建数据记录表的SQL语句
-        String createDataTable = "CREATE TABLE " + TABLE_DATA + " ("
-                + "id INTEGER PRIMARY KEY AUTOINCREMENT, "
-                + "note_id INTEGER, "
-                + "mime_type TEXT, "
-                + "content TEXT, "
-                + "data1 TEXT, "
-                + "data2 TEXT, "
-                + "data3 TEXT, "
-                + "data4 TEXT"
-                + ")";
-        db.execSQL(createDataTable);
-
-        // 假设这里添加一些触发器创建语句（如果有相关需求）
-        // String createTrigger = "CREATE TRIGGER...";
-        // db.execSQL(createTrigger);
-    }
-
-    // 数据库升级时的操作
-    @Override
-    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
-        // 简单示例，直接删除旧表并重新创建
-        db.execSQL("DROP TABLE IF EXISTS " + TABLE_NOTE);
-        db.execSQL("DROP TABLE IF EXISTS " + TABLE_DATA);
-        onCreate(db);
-    }
-}
-
-（4）	类名：NotesProvider
-import android.content.ContentProvider;
-import android.content.ContentValues;
-import android.content.UriMatcher;
-import android.database.Cursor;
-import android.database.sqlite.SQLiteDatabase;
-import android.net.Uri;
-import android.util.Log;
-
-// NotesProvider类，作为内容提供者，对外提供统一的数据访问接口
-public class NotesProvider extends ContentProvider {
-    // 用于匹配Uri的UriMatcher
-    private static final UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH); 
-    // 匹配便签Uri的代码
-    private static final int NOTES = 1; 
-    // 匹配数据Uri的代码
-    private static final int DATA = 2; 
-
-    // 数据库帮助类实例
-    private NotesDatabaseHelper mDbHelper; 
-
-    // 初始化UriMatcher
-    static {
-        sUriMatcher.addURI(Notes.AUTHORITY, "notes", NOTES);
-        sUriMatcher.addURI(Notes.AUTHORITY, "data", DATA);
-    }
-
-    // 初始化内容提供者
-    @Override
-    public boolean onCreate() {
-        mDbHelper = new NotesDatabaseHelper(getContext());
-        return true;
-    }
-
-    // 查询数据
-    @Override
-    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
-        SQLiteDatabase db = mDbHelper.getReadableDatabase();
-        Cursor cursor;
-        switch (sUriMatcher.match(uri)) {
-            case NOTES:
-                cursor = db.query(NotesDatabaseHelper.TABLE_NOTE, projection, selection, selectionArgs, null, null, sortOrder);
-                break;
-            case DATA:
-                cursor = db.query(NotesDatabaseHelper.TABLE_DATA, projection, selection, selectionArgs, null, null, sortOrder);
-                break;
-            default:
-                throw new IllegalArgumentException("Unknown URI " + uri);
-        }
-        return cursor;
-    }
-
-    // 插入数据
-    @Override
-    public Uri insert(Uri uri, ContentValues values) {
-        SQLiteDatabase db = mDbHelper.getWritableDatabase();
-        long id;
-        switch (sUriMatcher.match(uri)) {
-            case NOTES:
-                id = db.insert(NotesDatabaseHelper.TABLE_NOTE, null, values);
-                break;
-            case DATA:
-                id = db.insert(NotesDatabaseHelper.TABLE_DATA, null, values);
-                break;
-            default:
-                throw new IllegalArgumentException("Unknown URI " + uri);
-        }
-        return ContentUris.withAppendedId(uri, id);
-    }
-
-    // 更新数据
-    @Override
-    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
-        SQLiteDatabase db = mDbHelper.getWritableDatabase();
-        int count;
-        switch (sUriMatcher.match(uri)) {
-            case NOTES:
-                count = db.update(NotesDatabaseHelper.TABLE_NOTE, values, selection, selectionArgs);
-                break;
-            case DATA:
-                count = db.update(NotesDatabaseHelper.TABLE_DATA, values, selection, selectionArgs);
-                break;
-            default:
-                throw new IllegalArgumentException("Unknown URI " + uri);
-        }
-        return count;
-    }
-
-    // 删除数据
-    @Override
-    public int delete(Uri uri, String selection, String[] selectionArgs) {
-        SQLiteDatabase db = mDbHelper.getWritableDatabase();
-        int count;
-        switch (sUriMatcher.match(uri)) {
-            case NOTES:
-                count = db.delete(NotesDatabaseHelper.TABLE_NOTE, selection, selectionArgs);
-                break;
-            case DATA:
-                count = db.delete(NotesDatabaseHelper.TABLE_DATA, selection, selectionArgs);
-                break;
-            default:
-                throw new IllegalArgumentException("Unknown URI " + uri);
-        }
-        return count;
-    }
-}
-
-（5）	类名：note
-// 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对象
-        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); 
-        // 设置便签所属文件夹ID
-        values.put(NoteColumns.PARENT_ID, folderId); 
-        // 通过内容解析器插入新便签数据，并获取返回的Uri
-        Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values); 
-        long noteId = 0;
-        try {
-            // 从Uri的路径段中获取便签ID
-            noteId = Long.valueOf(uri.getPathSegments().get(1)); 
-        } catch (NumberFormatException e) {
-            // 若获取ID时发生数字格式异常，记录日志
-            Log.e(TAG, "Get note id error :" + e.toString()); 
-            noteId = 0;
-        }
-        if (noteId == -1) {
-            // 若便签ID为-1，抛出异常
-            throw new IllegalStateException("Wrong note id:" + noteId); 
-        }
-        return noteId;
-    }
-
-    // Note类的构造函数，初始化便签差异值和便签数据对象
-    public Note() {
-        mNoteDiffValues = new ContentValues();
-        mNoteData = new NoteData();
-    }
-
-    // 设置便签的某个属性值，同时更新本地修改标记和修改时间
-    public void setNoteValue(String key, String value) {
-        mNoteDiffValues.put(key, value);
-        mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
-        mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
-    }
-
-    // 设置文本便签的数据，同时更新本地修改标记和修改时间
-    public void setTextData(String key, String value) {
-        mNoteData.setTextData(key, value);
-    }
-
-    // 设置文本便签数据的ID，对ID进行合法性检查
-    public void setTextDataId(long id) {
-        mNoteData.setTextDataId(id);
-    }
-
-    // 获取文本便签数据的ID
-    public long getTextDataId() {
-        return mNoteData.mTextDataId;
-    }
-
-    // 设置通话便签数据的ID，对ID进行合法性检查
-    public void setCallDataId(long id) {
-        mNoteData.setCallDataId(id);
-    }
-
-    // 设置通话便签的数据，同时更新本地修改标记和修改时间
-    public void setCallData(String key, String value) {
-        mNoteData.setCallData(key, value);
-    }
-
-    // 判断便签是否有本地修改，包括便签差异值和便签数据对象中的数据是否有变化
-    public boolean isLocalModified() {
-        return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
-    }
-
-    // 将便签数据同步到数据库的方法
-    public boolean syncNote(Context context, long noteId) {
-        if (noteId <= 0) {
-            // 若便签ID不合法，抛出异常
-            throw new IllegalArgumentException("Wrong note id:" + noteId); 
-        }
-        if (!isLocalModified()) {
-            // 若便签没有本地修改，直接返回true
-            return true;
-        }
-        // 尝试更新便签数据到数据库
-        if (context.getContentResolver().update(
-                ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), mNoteDiffValues, null,
-                null) == 0) {
-            // 若更新失败，记录日志
-            Log.e(TAG, "Update note error, should not happen"); 
-            // 不返回，继续执行后续操作
-        }
-        mNoteDiffValues.clear();
-        // 若便签数据有本地修改，将其推送到内容解析器
-        if (mNoteData.isLocalModified()
-                && (mNoteData.pushIntoContentResolver(context, noteId) == null)) {
-            return false;
-        }
-        return true;
-    }
-
-    // Note类的内部类，用于存储和处理便签的具体数据
-    private class NoteData {
-        // 文本便签数据的ID
-        private long mTextDataId; 
-        // 存储文本便签数据的ContentValues对象
-        private ContentValues mTextDataValues; 
-        // 通话便签数据的ID
-        private long mCallDataId; 
-        // 存储通话便签数据的ContentValues对象
-        private ContentValues mCallDataValues; 
-        // 日志标签，用于在日志中标识该内部类相关的信息
-        private static final String TAG = "NoteData"; 
-
-        // NoteData类的构造函数，初始化文本和通话便签数据对象及ID
-        public NoteData() {
-            mTextDataValues = new ContentValues();
-            mCallDataValues = new ContentValues();
-            mTextDataId = 0;
-            mCallDataId = 0;
-        }
-
-        // 判断便签数据是否有本地修改，即文本或通话便签数据对象是否有数据变化
-        boolean isLocalModified() {
-            return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
-        }
-
-        // 设置文本便签数据的ID，对ID进行合法性检查
-        void setTextDataId(long id) {
-            if(id <= 0) {
-                throw new IllegalArgumentException("Text data id
-
-
-（6）	类名：WorkingNote
-// 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 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在DATA_PROJECTION中的列索引
-    private static final int DATA_ID_COLUMN = 0; 
-    // 数据内容在DATA_PROJECTION中的列索引
-    private static final int DATA_CONTENT_COLUMN = 1; 
-    // 数据MIME类型在DATA_PROJECTION中的列索引
-    private static final int DATA_MIME_TYPE_COLUMN = 2; 
-    // 数据模式在DATA_PROJECTION中的列索引
-    private static final int DATA_MODE_COLUMN = 3; 
-    // 便签父文件夹ID在NOTE_PROJECTION中的列索引
-    private static final int NOTE_PARENT_ID_COLUMN = 0; 
-    // 便签提醒日期在NOTE_PROJECTION中的列索引
-    private static final int NOTE_ALERTED_DATE_COLUMN = 1; 
-    // 便签背景颜色ID在NOTE_PROJECTION中的列索引
-    private static final int NOTE_BG_COLOR_ID_COLUMN = 2; 
-    // 便签小部件ID在NOTE_PROJECTION中的列索引
-    private static final int NOTE_WIDGET_ID_COLUMN = 3; 
-    // 便签小部件类型在NOTE_PROJECTION中的列索引
-    private static final int NOTE_WIDGET_TYPE_COLUMN = 4; 
-    // 便签修改日期在NOTE_PROJECTION中的列索引
-    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, "
-
-(7)类名：BackupUtils
-/*
- * 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.tool;
-
-import android.content.Context;
-import android.database.Cursor;
-import android.os.Environment;
-import android.text.TextUtils;
-import android.text.format.DateFormat;
-import android.util.Log;
-import net.micode.notes.R;
-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 java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.PrintStream;
-
-// BackupUtils类用于实现便签数据的备份功能，可将便签数据导出为文本文件存储到外部存储设备
-public class BackupUtils {
-    // 用于在日志中标记该类相关信息的标签
-    private static final String TAG = "BackupUtils"; 
-    // 单例实例，确保整个应用中只有一个BackupUtils实例
-    private static BackupUtils sInstance; 
-
-    // 获取BackupUtils单例实例的方法，使用synchronized关键字保证线程安全
-    public static synchronized BackupUtils getInstance(Context context) {
-        if (sInstance == null) {
-            sInstance = new BackupUtils(context);
-        }
-        return sInstance;
-    }
-
-    // 表示备份或恢复操作的状态码
-    // 当前SD卡未挂载
-    public static final int STATE_SD_CARD_UNMOUONTED = 0; 
-    // 备份文件不存在
-    public static final int STATE_BACKUP_FILE_NOT_EXIST = 1; 
-    // 数据格式损坏，可能被其他程序修改
-    public static final int STATE_DATA_DESTROIED = 2; 
-    // 运行时发生异常，导致恢复或备份失败
-    public static final int STATE_SYSTEM_ERROR = 3; 
-    // 备份或恢复成功
-    public static final int STATE_SUCCESS = 4; 
-
-    // 用于将便签数据导出为文本的工具对象
-    private TextExport mTextExport; 
-
-    // 构造函数，初始化TextExport对象
-    private BackupUtils(Context context) {
-        mTextExport = new TextExport(context);
-    }
-
-    // 检查外部存储设备（如SD卡）是否可用的方法
-    private static boolean externalStorageAvailable() {
-        // 通过比较外部存储设备的状态是否为MEDIA_MOUNTED来判断是否可用
-        return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()); 
-    }
-
-    // 执行便签数据导出为文本文件的方法
-    public int exportToText() {
-        return mTextExport.exportToText();
-    }
-
-    // 获取导出的文本文件名的方法
-    public String getExportedTextFileName() {
-        return mTextExport.mFileName;
-    }
-
-    // 获取导出的文本文件目录的方法
-    public String getExportedTextFileDir() {
-        return mTextExport.mFileDirectory;
-    }
-
-    // 内部类TextExport，负责具体的文本导出操作
-    private static class TextExport {
-        // 用于查询便签信息的投影数组，指定要获取的便签字段
-        private static final String[] NOTE_PROJECTION = {
-                NoteColumns.ID,
-                NoteColumns.MODIFIED_DATE,
-                NoteColumns.SNIPPET,
-                NoteColumns.TYPE
-        };
-        // NOTE_PROJECTION数组中便签ID的索引
-        private static final int NOTE_COLUMN_ID = 0; 
-        // NOTE_PROJECTION数组中便签修改日期的索引
-        private static final int NOTE_COLUMN_MODIFIED_DATE = 1; 
-        // NOTE_PROJECTION数组中便签摘要（简短内容）的索引
-        private static final int NOTE_COLUMN_SNIPPET = 2; 
-
-        // 用于查询便签数据的投影数组，指定要获取的数据字段
-        private static final String[] DATA_PROJECTION = {
-                DataColumns.CONTENT,
-                DataColumns.MIME_TYPE,
-                DataColumns.DATA1,
-                DataColumns.DATA2,
-                DataColumns.DATA3,
-                DataColumns.DATA4
-        };
-        // DATA_PROJECTION数组中数据内容的索引
-        private static final int DATA_COLUMN_CONTENT = 0; 
-        // DATA_PROJECTION数组中数据MIME类型的索引
-        private static final int DATA_COLUMN_MIME_TYPE = 1; 
-        // DATA_PROJECTION数组中通话日期（针对通话便签）的索引
-        private static final int DATA_COLUMN_CALL_DATE = 2; 
-        // DATA_PROJECTION数组中电话号码（针对通话便签）的索引
-        private static final int DATA_COLUMN_PHONE_NUMBER = 4; 
-
-        // 文本格式数组，从资源文件中获取，用于格式化导出的便签数据
-        private final String[] TEXT_FORMAT; 
-        // 文本格式数组中文件夹名称格式的索引
-        private static final int FORMAT_FOLDER_NAME = 0; 
-        // 文本格式数组中便签日期格式的索引
-        private static final int FORMAT_NOTE_DATE = 1; 
-        // 文本格式数组中便签内容格式的索引
-        private static final int FORMAT_NOTE_CONTENT = 2; 
-
-        // 上下文对象，用于获取资源和进行内容解析等操作
-        private Context mContext; 
-        // 导出的文本文件名
-        private String mFileName; 
-        // 导出的文本文件目录
-        private String mFileDirectory; 
-
-        // TextExport类的构造函数，初始化上下文和文本格式数组
-        public TextExport(Context context) {
-            // 从资源文件中获取文本格式数组
-            TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note); 
-            mContext = context;
-            mFileName = "";
-            mFileDirectory = "";
-        }
-
-        // 获取指定格式字符串的方法，根据索引从文本格式数组中获取相应格式
-        private String getFormat(int id) {
-            return TEXT_FORMAT[id];
-        }
-
-        // 将指定文件夹及其包含的便签数据导出为文本的方法
-        private void exportFolderToText(String folderId, PrintStream ps) {
-            // 通过内容解析器查询属于该文件夹的便签
-            Cursor notesCursor = mContext.getContentResolver().query(Notes.CONTENT_NOTE_URI,
-                    NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[]{folderId}, null);
-            if (notesCursor != null) {
-                if (notesCursor.moveToFirst()) {
-                    do {
-                        // 打印便签的最后修改日期，使用指定的日期格式进行格式化
-                        ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
-                                mContext.getString(R.string.format_datetime_mdhm),
-                                notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
-                        // 获取当前便签的ID
-                        String noteId = notesCursor.getString(NOTE_COLUMN_ID);
-                        // 导出该便签的数据
-                        exportNoteToText(noteId, ps);
-                    } while (notesCursor.moveToNext());
-                }
-                // 关闭游标，释放资源
-                notesCursor.close(); 
-            }
-        }
-
-        // 将指定便签数据导出为文本的方法
-        private void exportNoteToText(String noteId, PrintStream ps) {
-            // 通过内容解析器查询属于该便签的数据
-            Cursor dataCursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI,
-                    DATA_PROJECTION, DataColumns.NOTE_ID + "=?", new String[]{noteId}, null);
-            if (dataCursor != null) {
-                if (dataCursor.moveToFirst()) {
-                    do {
-                        // 获取数据的MIME类型，以判断便签类型
-                        String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE);
-                        if (DataConstants.CALL_NOTE.equals(mimeType)) {
-                            // 如果是通话便签，获取电话号码
-                            String phoneNumber = dataCursor.getString(DATA_COLUMN_PHONE_NUMBER);
-                            // 获取通话日期
-                            long callDate = dataCursor.getLong(DATA_COLUMN_CALL_DATE);
-                            // 获取通话附件位置（如果有）
-                            String location = dataCursor.getString(DATA_COLUMN_CONTENT);
-                            if (!TextUtils.isEmpty(phoneNumber)) {
-                                // 打印电话号码，使用指定的便签内容格式
-                                ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), phoneNumber));
-                            }
-                            // 打印通话日期，使用指定的便签内容格式和日期格式
-                            ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), DateFormat
-                                   .format(mContext.getString(R.string.format_datetime_mdhm), callDate)));
-                            if (!TextUtils.isEmpty(location)) {
-                                // 打印通话附件位置，使用指定的便签内容格式
-                                ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), location));
-                            }
-                        } else if (DataConstants.NOTE.equals(mimeType)) {
-                            // 如果是普通便签，获取便签内容
-                            String content = dataCursor.getString(DATA_COLUMN_CONTENT);
-                            if (!TextUtils.isEmpty(content)) {
-                                // 打印便签内容，使用指定的便签内容格式
-                                ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), content));
-                            }
-                        }
-                    } while (dataCursor.moveToNext());
-                }
-                // 关闭游标，释放资源
-                dataCursor.close(); 
-            }
-            // 打印一个换行符，分隔不同便签的数据
-            try {
-                ps.write(new byte[]{
-                        Character.LINE_SEPARATOR, Character.LETTER_NUMBER
-                });
-            } catch (IOException e) {
-                // 如果写入换行符时发生I/O异常，记录错误日志
-                Log.e(TAG, e.toString()); 
-            }
-        }
-
-        // 将便签数据导出为文本文件的主要方法
-        public int exportToText() {
-            // 检查外部存储设备是否可用
-            if (!externalStorageAvailable()) {
-                // 如果不可用，记录日志并返回SD卡未挂载的状态码
-                Log.d(TAG, "Media was not mounted");
-                return STATE_SD_CARD_UNMOUONTED;
-            }
-            // 获取用于写入导出文本的打印流
-            PrintStream ps = getExportToTextPrintStream();
-            if (ps == null) {
-                // 如果获取打印流失败，记录日志并返回系统错误状态码
-                Log.e(TAG, "get print stream error");
-                return STATE_SYSTEM_ERROR;
-            }
-            // 首先导出文件夹及其便签数据
-            Cursor folderCursor = mContext.getContentResolver().query(
-                    Notes.CONTENT_NOTE_URI,
-                    NOTE_PROJECTION,
-                    "(" + NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND "
-                            + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + ") OR "
-                            + NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER, null, null);
-            if (folderCursor != null) {
-                if (folderCursor.moveToFirst()) {
-                    do {
-                        // 获取文件夹名称
-                        String folderName = "";
-                        if (folderCursor.getLong(NOTE_COLUMN_ID) == Notes.ID_CALL_RECORD_FOLDER) {
-                            // 如果是通话记录文件夹，使用特定的名称
-                            folderName = mContext.getString(R.string.call_record_folder_name);
-                        } else {
-                            // 否则，使用便签摘要作为文件夹名称
-                            folderName = folderCursor.getString(NOTE_COLUMN_SNIPPET);
-                        }
-                        if (!TextUtils.isEmpty(folderName)) {
-                            // 打印文件夹名称，使用指定的文件夹名称格式
-                            ps.println(String.format(getFormat(FORMAT_FOLDER_NAME), folderName));
-                        }
-                        // 获取文件夹ID
-                        String folderId = folderCursor.getString(NOTE_COLUMN_ID);
-                        // 导出该文件夹及其便签数据
-                        exportFolderToText(folderId, ps);
-                    } while (folderCursor.moveToNext());
-                }
-                // 关闭游标，释放资源
-                folderCursor.close(); 
-            }
-            // 导出根文件夹下的便签数据
-            Cursor noteCursor = mContext.getContentResolver().query(
-                    Notes.CONTENT_NOTE_URI,
-                    NOTE_PROJECTION,
-                    NoteColumns.TYPE + "=" + Notes.TYPE_NOTE + " AND " + NoteColumns.PARENT_ID + "=0",
-                    null, null);
-            if (noteCursor != null) {
-                if (noteCursor.moveToFirst()) {
-                    do {
-                        // 打印便签的最后修改日期，使用指定的日期格式进行格式化
-                        ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
-                                mContext.getString(R.string.format_datetime_mdhm),
-                                noteCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
-                        // 获取当前便签的ID
-                        String noteId = noteCursor.getString(NOTE_COLUMN_ID);
-                        // 导出该便签的数据
-                        exportNoteToText(noteId, ps);
-                    } while (noteCursor.moveToNext());
-                }
-                // 关闭游标，释放资源
-                noteCursor.close(); 
-            }
-            // 关闭打印流，完成导出操作
-            ps.close(); 
-            // 返回备份成功的状态码
-            return STATE_SUCCESS; 
-        }
-
-        // 获取用于写入导出文本的打印流的方法
-        private PrintStream getExportToTextPrintStream() {
-            // 生成用于存储导出数据的文件
-            File file = generateFileMountedOnSDcard(mContext, R.string.file_path,
-                    R.string.file_name_txt_format);
-            if (file == null) {
-                // 如果文件生成失败，记录日志并返回null
-                Log.e(TAG, "create file to exported failed");
-                return null;
-            }
-            // 设置导出的文本文件名
-            mFileName = file.getName();
-            // 设置导出的文本文件目录
-            mFileDirectory = mContext.getString(R.string.file_path);
-            PrintStream ps = null;
-            try {
-                // 创建文件输出流，并基于此创建打印流
-                FileOutputStream fos = new FileOutputStream(file);
-                ps = new PrintStream(fos);
-            } catch (FileNotFoundException e) {
-                // 如果文件未找到，打印异常堆栈信息并返回null
-                e.printStackTrace();
-                return null;
-            } catch (NullPointerException e) {
-                // 如果发生空指针异常，打印异常堆栈信息并返回null
-                e.printStackTrace();
-                return null;
-            }
-            return ps;
-        }
-    }
-
-    // 生成存储在SD卡上的文本文件的方法，用于存储导入的数据（这里主要用于备份导出文件）
-    private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
-        StringBuilder sb = new StringBuilder();
-        // 添加外部存储设备的目录
-        sb.append(Environment.getExternalStorageDirectory()); 
-        // 添加文件路径资源对应的路径
-        sb.append(context.getString(filePathResId)); 
-        File filedir = new File(sb.toString());
-        // 添加文件名格式资源对应的文件名，使用当前日期进行格式化
-        sb.append(context.getString(
-                fileNameFormatResId,
-                DateFormat.format(context.getString(R.string.format_date_ymd),
-                        System.currentTimeMillis())));
-        File file = new File(sb.toString());
-        try {
-            // 如果文件目录不存在，则创建目录
-            if (!filedir.exists()) {
-                filedir.mkdir();
-            }
-            // 如果文件不存在，则创建文件
-            if (!file.exists()) {
-                file.createNewFile();
-            }
-            return file;
-        } catch (SecurityException e) {
-            // 如果发生安全异常，打印异常堆栈信息
-            e.printStackTrace();
-        } catch (IOException e) {
-            // 如果发生I/O异常，打印异常堆栈信息
-            e.printStackTrace();
-        }
-        return null;
-    }
-}
-(8)	类名：DataUtils
-/*
- * 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.tool;
-
-import android.content.ContentProviderOperation;
-import android.content.ContentProviderResult;
-import android.content.ContentResolver;
-import android.content.ContentUris;
-import android.content.ContentValues;
-import android.content.OperationApplicationException;
-import android.database.Cursor;
-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.NoteColumns;
-import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-
-// DataUtils类，提供一系列便签数据处理的工具方法
-public class DataUtils {
-    // 日志标签，用于在日志中标识该类相关的信息
-    private static final String TAG = "DataUtils"; 
-
-    // 批量删除便签的方法
-    public static void batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
-        // 如果便签ID集合为空，直接返回，不进行任何操作
-        if (ids == null || ids.isEmpty()) {
-            return;
-        }
-        // 创建一个操作列表，用于批量执行内容提供者的操作
-        ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
-        // 遍历便签ID集合
-        for (Long id : ids) {
-            // 构建删除操作，根据便签ID构建删除的Uri
-            ContentProviderOperation.Builder builder = ContentProviderOperation.newDelete(
-                    ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
-            // 将删除操作添加到操作列表中
-            operationList.add(builder.build());
-        }
-        try {
-            // 执行批量操作，将操作列表应用到内容解析器
-            ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
-            // 这里可以根据results做进一步处理，比如检查操作是否成功等，目前未做具体处理
-        } catch (RemoteException e) {
-            // 如果发生远程异常（如与内容提供者通信失败），记录日志
-            Log.e(TAG, "RemoteException in batchDeleteNotes: " + e.toString());
-        } catch (OperationApplicationException e) {
-            // 如果操作应用发生异常（如操作格式错误等），记录日志
-            Log.e(TAG, "OperationApplicationException in batchDeleteNotes: " + e.toString());
-        }
-    }
-
-    // 将便签移动到指定文件夹的方法
-    public static void moveNoteToFolder(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
-        // 创建一个ContentValues对象，用于存储要更新的便签数据
-        ContentValues values = new ContentValues();
-        // 设置便签的父文件夹ID为目标文件夹ID，实现移动便签的操作
-        values.put(NoteColumns.PARENT_ID, desFolderId);
-        try {
-            // 更新便签数据，根据便签ID构建更新的Uri，传入更新的值和空的筛选条件及参数
-            resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
-        } catch (Exception e) {
-            // 如果更新过程中发生异常，记录日志
-            Log.e(TAG, "Exception in moveNoteToFolder: " + e.toString());
-        }
-    }
-
-    // 检查指定便签ID是否存在于数据库中的方法
-    public static boolean isNoteExist(ContentResolver resolver, long id) {
-        // 通过内容解析器查询便签数据，根据便签ID构建查询的Uri，指定要查询的列，筛选条件为便签ID
-        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id),
-                new String[]{NoteColumns.ID}, null, null, null);
-        // 初始化结果为false，表示默认认为便签不存在
-        boolean result = false;
-        if (cursor != null) {
-            // 如果查询到数据（游标能够移动到第一条记录），说明便签存在，设置结果为true
-            if (cursor.moveToFirst()) {
-                result = true;
-            }
-            // 关闭游标，释放资源
-            cursor.close();
-        }
-        // 返回便签是否存在的结果
-        return result;
-    }
-
-    // 检查指定文件夹中是否存在便签的方法
-    public static boolean isFolderHasNote(ContentResolver resolver, long folderId) {
-        // 构建查询条件，筛选出属于指定文件夹的便签
-        String selection = NoteColumns.PARENT_ID + "=" + folderId;
-        // 通过内容解析器查询便签数据，传入查询的Uri、要查询的列、筛选条件和空的筛选参数
-        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, new String[]{NoteColumns.ID},
-                selection, null, null);
-        // 初始化结果为false，表示默认认为文件夹中不存在便签
-        boolean result = false;
-        if (cursor != null) {
-            // 如果查询到数据（游标能够移动到第一条记录），说明文件夹中存在便签，设置结果为true
-            if (cursor.moveToFirst()) {
-                result = true;
-            }
-            // 关闭游标，释放资源
-            cursor.close();
-        }
-        // 返回文件夹中是否存在便签的结果
-        return result;
-    }
-
-    // 获取便签的小部件属性的方法
-    public static AppWidgetAttribute getNoteWidgetAttribute(ContentResolver resolver, long noteId) {
-        // 创建一个AppWidgetAttribute对象，用于存储便签的小部件属性
-        AppWidgetAttribute attribute = new AppWidgetAttribute();
-        // 通过内容解析器查询便签数据，根据便签ID构建查询的Uri，指定要查询的小部件ID和类型列
-        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
-                new String[]{NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE}, null, null, null);
-        if (cursor != null) {
-            if (cursor.moveToFirst()) {
-                // 获取便签的小部件ID
-                attribute.widgetId = cursor.getInt(0);
-                // 获取便签的小部件类型
-                attribute.widgetType = cursor.getInt(1);
-            }
-            // 关闭游标，释放资源
-            cursor.close();
-        }
-        // 返回便签的小部件属性对象
-        return attribute;
-    }
-
-    // 更新便签的小部件属性的方法
-    public static void updateNoteWidgetAttribute(ContentResolver resolver, long noteId, int widgetId, int widgetType) {
-        // 创建一个ContentValues对象，用于存储要更新的小部件属性值
-        ContentValues values = new ContentValues();
-        // 设置便签的小部件ID
-        values.put(NoteColumns.WIDGET_ID, widgetId);
-        // 设置便签的小部件类型
-        values.put(NoteColumns.WIDGET_TYPE, widgetType);
-        try {
-            // 更新便签数据，根据便签ID构建更新的Uri，传入更新的值和空的筛选条件及参数
-            resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), values, null, null);
-        } catch (Exception e) {
-            // 如果更新过程中发生异常，记录日志
-            Log.e(TAG, "Exception in updateNoteWidgetAttribute: " + e.toString());
-        }
-    }
-
-    // 处理通话便签数据的方法（假设是对通话便签数据进行一些特定处理）
-    public static void handleCallNoteData(ContentResolver resolver, long noteId, String phoneNumber, long callDate) {
-        // 创建一个ContentValues对象，用于存储通话便签的数据
-        ContentValues values = new ContentValues();
-        // 设置通话便签的数据MIME类型为通话便签类型
-        values.put(Notes.DataColumns.MIME_TYPE, CallNote.CONTENT_ITEM_TYPE);
-        // 设置通话便签的电话号码
-        values.put(Notes.DataColumns.DATA4, phoneNumber);
-        // 设置通话便签的通话日期
-        values.put(Notes.DataColumns.DATA2, callDate);
-        // 设置通话便签所属的便签ID
-        values.put(Notes.DataColumns.NOTE_ID, noteId);
-        try {
-            // 插入通话便签数据到数据库，使用内容解析器插入数据
-            resolver.insert(Notes.CONTENT_DATA_URI, values);
-        } catch (Exception e) {
-            // 如果插入过程中发生异常，记录日志
-            Log.e(TAG, "Exception in handleCallNoteData: " + e.toString());
-        }
-    }
-}
-
-(9)类名：GTaskStringUtils
-/*
- * 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.tool;
-
-// GTaskStringUtils类，定义与GTask相关的字符串常量，用于处理GTask相关的JSON数据解析和构建
-public class GTaskStringUtils {
-    // GTask JSON数据中action_id字段的名称
-    public static final String GTASK_JSON_ACTION_ID = "action_id"; 
-    // GTask JSON数据中resource_name字段的名称
-    public static final String GTASK_JSON_RESOURCE_NAME = "resource_name"; 
-    // GTask JSON数据中resource_type字段的名称
-    public static final String GTASK_JSON_RESOURCE_TYPE = "resource_type"; 
-    // GTask JSON数据中resource_id字段的名称
-    public static final String GTASK_JSON_RESOURCE_ID = "resource_id"; 
-    // GTask JSON数据中parent_id字段的名称
-    public static final String GTASK_JSON_PARENT_ID = "parent_id"; 
-    // GTask JSON数据中data字段的名称
-    public static final String GTASK_JSON_DATA = "data"; 
-    // GTask JSON数据中snippet字段的名称
-    public static final String GTASK_JSON_SNIPPET = "snippet"; 
-    // GTask JSON数据中type字段的名称
-    public static final String GTASK_JSON_TYPE = "type"; 
-    // GTask JSON数据中created字段的名称
-    public static final String GTASK_JSON_CREATED = "created"; 
-    // GTask JSON数据中modified字段的名称
-    public static final String GTASK_JSON_MODIFIED = "modified"; 
-    // GTask JSON数据中alerted字段的名称
-    public static final String GTASK_JSON_ALERTED = "alerted"; 
-    // GTask JSON数据中local_modified字段的名称
-    public static final String GTASK_JSON_LOCAL_MODIFIED = "local_modified"; 
-    // GTask JSON数据中bg_color_id字段的名称
-    public static final String GTASK_JSON_BG_COLOR_ID = "bg_color_id"; 
-    // GTask JSON数据中widget_id字段的名称
-    public static final String GTASK_JSON_WIDGET_ID = "widget_id"; 
-    // GTask JSON数据中widget_type字段的名称
-    public static final String GTASK_JSON_WIDGET_TYPE = "widget_type"; 
-    // GTask JSON数据中phone_number字段的名称
-    public static final String GTASK_JSON_PHONE_NUMBER = "phone_number"; 
-    // GTask JSON数据中call_date字段的名称
-    public static final String GTASK_JSON_CALL_DATE = "call_date"; 
-
-    // 构造函数，私有化，防止该类被实例化，因为它只包含静态常量
-    private GTaskStringUtils() {
-        // 空实现，该类不需要实例化
-    }
-}
-(10)类名：ResourceParser
-/*
-* 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.tool;
-
-import android.content.Context;
-import android.content.SharedPreferences;
-import android.graphics.drawable.Drawable;
-import android.preference.PreferenceManager;
-import android.util.Log;
-import net.micode.notes.R;
-import net.micode.notes.data.Notes;
-
-// ResourceParser类，解析应用资源，提供便签背景、文本样式等资源的获取方法
-public class ResourceParser {
-// 日志标签，用于在日志中标识该类相关的信息
-private static final String TAG = "ResourceParser";
-
-// 根据便签背景ID获取对应的Drawable资源（如背景图片）的方法
-public static Drawable getNoteBgResource(int id) {
-Context context = AppGlobals.getApplication();
-Drawable bg = null;
-switch (id) {
-case Notes.ID_BACKGROUND_DEFAULT:
-// 如果是默认背景ID，获取默认背景资源
-bg = context.getResources().getDrawable(R.drawable.bg_note_default);
-break;
-case Notes.ID_BACKGROUND_PURPLE:
-// 如果是紫色背景ID，获取紫色背景资源
-bg = context.getResources().getDrawable(R.drawable.bg_note_purple);
-break;
-case Notes.ID_BACKGROUND_BLUE:
-// 如果是蓝色背景ID，获取蓝色背景资源
-bg = context.getResources().getDrawable(R.drawable.bg_note_blue);
-break;
-case Notes.ID_BACKGROUND_GREEN:
-// 如果是绿色背景ID，获取绿色背景资源
-bg = context.getResources().getDrawable(R.drawable.bg_note_green);
-break;
-case Notes.ID_BACKGROUND_YELLOW:
-// 如果是黄色背景ID，获取黄色背景资源
-bg = context.getResources().getDrawable(R.drawable.bg_note_yellow);
-break;
-case Notes.ID_BACKGROUND_ORANGE:
-// 如果是橙色背景ID，获取橙色背景资源
-bg = context.getResources().getDrawable(R.drawable.bg_note_orange);
-break;
-case Notes.ID_BACKGROUND_PINK:
-// 如果是粉色背景ID，获取粉色背景资源
-bg = context.getResources().getDrawable(R.drawable.bg_note_pink);
-break;
-default:
-// 如果背景ID不匹配任何已知的背景ID，获取默认背景资源
-bg = context.getResources().getDrawable(R.drawable.bg_note_default);
-break;
-}
-return bg;
-}
-
-    // 根据便签背景ID获取对应的标题Drawable资源（如标题背景图片）的方法
-    public static Drawable getNoteTitleBgResource(int id) {
-        Context context = AppGlobals.getApplication();
-        Drawable bg = null;
-        switch (id) {
-            case Notes.ID_BACKGROUND_DEFAULT:
-                // 如果是默认背景ID，获取默认标题背景资源
-                bg = context.getResources().getDrawable(R.drawable.bg_note_title_default);
-                break;
-            case Notes.ID_BACKGROUND_PURPLE:
-                // 如果是紫色背景ID，获取紫色标题背景资源
-                bg = context.getResources().getDrawable(R.drawable.bg_note_title_purple);
-                break;
-            case Notes.ID_BACKGROUND_BLUE:
-                // 如果是蓝色背景ID，获取蓝色标题背景资源
-                bg = context.getResources().getDrawable(R.drawable.bg_note_title_blue);
-                break;
-            case Notes.ID_BACKGROUND_GREEN:
-                // 如果是绿色背景ID，获取绿色标题背景资源
-                bg = context.getResources().getDrawable(R.drawable.bg_note_title_green);
-                break;
-            case Notes.ID_BACKGROUND_YELLOW:
-                // 如果是黄色背景ID，获取黄色标题背景资源
-                bg = context.getResources().getDrawable(R.drawable.bg_note_title_yellow);
-                break;
-            case Notes.ID_BACKGROUND_ORANGE:
-                // 如果是橙色背景ID，获取橙色标题背景资源
-                bg = context.getResources().getDrawable(R.drawable.bg_note_title_orange);
-                break;
-            case Notes.ID_BACKGROUND_PINK:
-                // 如果是粉色背景ID，获取粉色标题背景资源
-                bg = context.getResources().getDrawable(R.drawable.bg_note_title_pink);
-                break;
-            default:
-                // 如果背景ID不匹配任何已知的背景ID，获取默认标题背景资源
-                bg = context.getResources().getDrawable(R.drawable.bg_note_title_default);
-                break;