1

249 changed files with 16339 additions and 8494 deletions
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@ -1,259 +0,0 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!--
    AndroidManifest.xml - Android应用清单文件
    此文件定义了应用的基本信息、组件、权限等核心配置
    version="1.0" - XML版本
    encoding="utf-8" - 文件编码格式
 -->
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">
    <!--
        manifest - 根元素，定义应用的包名、版本等元数据
        xmlns:android - Android命名空间，用于访问Android系统属性
        xmlns:tools - 工具命名空间，用于开发工具的特殊处理
    -->
    <!-- ======================= 权限声明区域 ======================= -->
    <!-- 这一部分列出了应用需要的所有系统权限，安装时会向用户请求 -->
    <!-- 写入外部存储权限 - 允许应用保存文件到设备存储 -->
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <!-- 安装快捷方式权限 - 允许应用在桌面创建快捷方式 -->
    <uses-permission android:name="com.android.launcher.permission.INSTALL_SHORTCUT" />
    <!-- 网络访问权限 - 允许应用访问互联网（用于同步等功能） -->
    <uses-permission android:name="android.permission.INTERNET" />
    <!-- 读取联系人权限 - 允许应用访问设备联系人 -->
    <uses-permission android:name="android.permission.READ_CONTACTS" />
    <!-- 管理账户权限 - 允许应用管理账户（添加/删除账户等） -->
    <!-- tools:ignore="Deprecated" - 忽略此权限已被弃用的警告 -->
    <uses-permission
        android:name="android.permission.MANAGE_ACCOUNTS"
        tools:ignore="Deprecated" />
    <!-- 验证账户权限 - 允许应用验证账户凭据 -->
    <uses-permission android:name="android.permission.AUTHENTICATE_ACCOUNTS" />
    <!-- 获取账户权限 - 允许应用读取设备上的账户列表 -->
    <uses-permission android:name="android.permission.GET_ACCOUNTS" />
    <!-- 使用凭据权限 - 允许应用使用账户凭据 -->
    <uses-permission android:name="android.permission.USE_CREDENTIALS" />
    <!-- 开机启动完成广播权限 - 允许应用接收系统启动完成的广播 -->
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
    <!-- ======================= 应用配置区域 ======================= -->
    <!-- application - 应用全局配置 -->
    <!--
        android:icon - 应用图标，显示在桌面和应用列表中，支持不同分辨率需提供多套资源
        android:label - 应用名称，引用字符串资源
        android:allowBackup - 是否允许系统备份应用数据
        android:supportsRtl - 是否支持从右到左的布局（如阿拉伯语）
        android:theme - 应用主题样式
        tools:replace - 指定要替换的属性（用于解决与其他应用的冲突）
    -->
    <application
        android:icon="@drawable/icon_app"
        android:label="@string/app_name"
        android:allowBackup="true"
        android:supportsRtl="true"
        android:theme="@style/NoteTheme"
        tools:replace="android:icon,android:theme">
        <!-- ======================= Activity组件 ======================= -->
        <!-- 主Activity - 便签列表界面 -->
        <!--
            android:name - Activity类名（.表示相对路径）
            android:configChanges - 指定配置变化时由应用自己处理
            android:label - Activity标题
            android:launchMode - 启动模式（singleTop：栈顶复用）
            android:uiOptions - 界面选项（splitActionBarWhenNarrow：窄屏时拆分操作栏）
            android:windowSoftInputMode - 软键盘显示模式（adjustPan：调整面板）
            android:exported - 是否允许外部应用调用（true表示允许）
        -->
        <activity
            android:name=".ui.NotesListActivity"
            android:configChanges="keyboardHidden|orientation|screenSize"
            android:label="@string/app_name"
            android:launchMode="singleTop"
            android:theme="@style/NoteTheme"
            android:uiOptions="splitActionBarWhenNarrow"
            android:windowSoftInputMode="adjustPan"
            android:exported="true">
            <!-- intent-filter - 意图过滤器，定义Activity能响应的操作 -->
            <intent-filter>
                <!-- 主入口点，应用启动时第一个显示的Activity -->
                <action android:name="android.intent.action.MAIN" />
                <!-- 启动器类别，会在应用列表中显示 -->
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <!-- 编辑Activity - 便签编辑界面 -->
        <activity
            android:name=".ui.NoteEditActivity"
            android:configChanges="keyboardHidden|orientation|screenSize"
            android:launchMode="singleTop"
            android:theme="@style/NoteTheme"
            android:exported="true">
            <!-- 第一个intent-filter：查看便签 -->
            <intent-filter>
                <!-- 查看操作 -->
                <action android:name="android.intent.action.VIEW" />
                <!-- 默认类别 -->
                <category android:name="android.intent.category.DEFAULT" />
                <!-- 支持的数据类型：文本便签和通话便签 -->
                <data android:mimeType="vnd.android.cursor.item/text_note" />
                <data android:mimeType="vnd.android.cursor.item/call_note" />
            </intent-filter>
            <!-- 第二个intent-filter：插入或编辑便签 -->
            <intent-filter>
                <action android:name="android.intent.action.INSERT_OR_EDIT" />
                <category android:name="android.intent.category.DEFAULT" />
                <data android:mimeType="vnd.android.cursor.item/text_note" />
                <data android:mimeType="vnd.android.cursor.item/call_note" />
            </intent-filter>
            <!-- 第三个intent-filter：搜索功能 -->
            <intent-filter>
                <action android:name="android.intent.action.SEARCH" />
                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
            <!-- 搜索配置元数据 -->
            <meta-data
                android:name="android.app.searchable"
                android:resource="@xml/searchable" />
        </activity>
        <!-- ======================= Content Provider组件 ======================= -->
        <!-- 数据提供者 - 管理便签数据 -->
        <!--
            android:name - Provider类名
            android:authorities - 内容URI的授权标识
            android:multiprocess - 是否支持多进程
            android:exported - 是否允许外部应用访问（false表示不允许）
            tools:replace - 替换authorities属性
        -->
        <provider
            android:name="net.micode.notes.data.NotesProvider"
            android:authorities="micode_notes"
            android:multiprocess="true"
            android:exported="false"
            tools:replace="android:authorities" />
        <!-- ======================= Broadcast Receiver组件 ======================= -->
        <!-- 2x2桌面小部件接收器 -->
        <!--
            android:name - Receiver类名
            android:label - 小部件名称
            android:exported - 是否允许外部应用调用
        -->
        <receiver
            android:name=".widget.NoteWidgetProvider_2x"
            android:label="@string/app_widget2x2"
            android:exported="true"
            tools:replace="android:label">
            <!-- 小部件相关广播过滤器 -->
            <intent-filter>
                <!-- 小部件更新 -->
                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
                <!-- 小部件删除 -->
                <action android:name="android.appwidget.action.APPWIDGET_DELETED" />
                <!-- 隐私模式变更 -->
                <action android:name="android.intent.action.PRIVACY_MODE_CHANGED" />
            </intent-filter>
            <!-- 小部件配置元数据 -->
            <meta-data
                android:name="android.appwidget.provider"
                android:resource="@xml/widget_2x_info" />
        </receiver>
        <!-- 4x4桌面小部件接收器 -->
        <receiver
            android:name=".widget.NoteWidgetProvider_4x"
            android:label="@string/app_widget4x4"
            android:exported="true"
            tools:replace="android:label">
            <intent-filter>
                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
                <action android:name="android.appwidget.action.APPWIDGET_DELETED" />
                <action android:name="android.intent.action.PRIVACY_MODE_CHANGED" />
            </intent-filter>
            <meta-data
                android:name="android.appwidget.provider"
                android:resource="@xml/widget_4x_info" />
        </receiver>
        <!-- 闹钟初始化接收器 - 接收开机启动完成广播 -->
        <receiver
            android:name=".ui.AlarmInitReceiver"
            android:exported="true">
            <intent-filter>
                <!-- 系统启动完成广播 -->
                <action android:name="android.intent.action.BOOT_COMPLETED" />
            </intent-filter>
        </receiver>
        <!-- 闹钟接收器 - 处理闹钟提醒 -->
        <!--
            android:process=":remote" - 在独立进程中运行
            避免主进程被杀死时无法接收闹钟
        -->
        <receiver
            android:name="net.micode.notes.ui.AlarmReceiver"
            android:process=":remote" />
        <!-- ======================= 其他Activity组件 ======================= -->
        <!-- 闹钟提醒Activity - 显示闹钟提醒界面 -->
        <!--
            android:launchMode="singleInstance" - 独立任务栈启动
            android:theme - 使用系统主题（无标题栏壁纸主题）
        -->
        <activity
            android:name=".ui.AlarmAlertActivity"
            android:label="@string/app_name"
            android:launchMode="singleInstance"
            android:theme="@android:style/Theme.Holo.Wallpaper.NoTitleBar"
            tools:replace="android:theme" />
        <!-- 设置Activity - 应用偏好设置界面 -->
        <activity
            android:name="net.micode.notes.ui.NotesPreferenceActivity"
            android:label="@string/preferences_title"
            android:launchMode="singleTop"
            android:theme="@style/NoteTheme"
            tools:replace="android:theme" />
        <!-- ======================= Service组件 ======================= -->
        <!-- 同步服务 - 处理Google任务同步 -->
        <!--
            android:exported="false" - 不允许外部应用绑定此服务
            这是应用内部使用的同步服务
        -->
        <service
            android:name="net.micode.notes.gtask.remote.GTaskSyncService"
            android:exported="false" />
        <!-- ======================= 应用级元数据 ======================= -->
        <!-- 默认搜索Activity配置 -->
        <!--
            指定应用默认的搜索Activity
            当用户执行搜索操作时，会启动此Activity
        -->
        <meta-data
            android:name="android.app.default_searchable"
            android:value=".ui.NoteEditActivity" />
    </application>
 </manifest>
--- a/README.md
+++ b/README.md
@ -0,0 +1,2 @@
 # git
--- a/java/net/micode/notes/tool/BackupUtils.java
+++ b/java/net/micode/notes/tool/BackupUtils.java
@ -1,528 +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.
 */
 // BackupUtils.java - 小米便签备份工具类
 // 主要功能：将便签数据导出为文本文件格式，方便用户备份和查看
 package net.micode.notes.tool;
 // ======================= 导入区域 =======================
 // Android系统相关类
 import android.content.Context;          // 上下文，用于获取资源、ContentResolver等
 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;              // 资源文件R类
 // 应用数据模型相关
 import net.micode.notes.data.Notes;              // Notes主类
 import net.micode.notes.data.Notes.DataColumns;  // 数据表列定义
 import net.micode.notes.data.Notes.DataConstants;// 数据常量定义
 import net.micode.notes.data.Notes.NoteColumns;  // 便签表列定义
 // Java IO相关
 import java.io.File;                    // 文件操作
 import java.io.FileNotFoundException;   // 文件未找到异常
 import java.io.FileOutputStream;        // 文件输出流
 import java.io.IOException;             // IO异常
 import java.io.PrintStream;             // 打印输出流
 // ======================= 备份工具主类 =======================
 /**
 * BackupUtils - 便签备份工具
 * 采用单例设计模式，确保整个应用只有一个备份工具实例
 * 主要功能：将数据库中的便签数据导出为可读的文本文件
 */
 public class BackupUtils {
    // TAG - 日志标签，用于Logcat日志筛选
    private static final String TAG = "BackupUtils";
    // ======================= 单例模式实现 =======================
    // sInstance - 静态单例实例，volatile确保多线程可见性
    private static BackupUtils sInstance;
    /**
     * 获取BackupUtils单例实例
     * synchronized - 线程安全，防止多线程环境下创建多个实例
     * @param context 应用上下文，用于初始化
     * @return BackupUtils唯一实例
     */
    public static synchronized BackupUtils getInstance(Context context) {
        // 懒加载：首次调用时创建实例
        if (sInstance == null) {
            sInstance = new BackupUtils(context);
        }
        return sInstance;
    }
    // ======================= 备份状态常量定义 =======================
    /**
     * 备份/恢复操作结果状态码
     * 使用常量而非魔法数字，提高代码可读性
     */
    public static final int STATE_SD_CARD_UNMOUONTED    = 0; // SD卡未挂载，无法访问外部存储
    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; // 操作成功完成
    // mTextExport - 文本导出器实例，实际执行导出操作
    private TextExport mTextExport;
    /**
     * 私有构造函数 - 单例模式关键，防止外部直接实例化
     * @param context 应用上下文，用于初始化TextExport
     */
    private BackupUtils(Context context) {
        // 创建文本导出器，传入上下文用于资源访问
        mTextExport = new TextExport(context);
    }
    /**
     * 检查外部存储状态
     * @return true: SD卡已挂载可读写; false: SD卡不可用
     */
    private static boolean externalStorageAvailable() {
        // Environment.MEDIA_MOUNTED - 存储介质已挂载且可读写
        return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
    }
    /**
     * 执行文本导出操作 - 对外暴露的主要接口
     * @return 操作结果状态码（见上面的状态常量）
     */
    public int exportToText() {
        return mTextExport.exportToText();
    }
    /**
     * 获取导出的文件名
     * @return 导出的文本文件名
     */
    public String getExportedTextFileName() {
        return mTextExport.mFileName;
    }
    /**
     * 获取导出的文件目录
     * @return 文件保存的目录路径
     */
    public String getExportedTextFileDir() {
        return mTextExport.mFileDirectory;
    }
    // ======================= 文本导出内部类 =======================
    /**
     * TextExport - 文本导出器内部类
     * 私有静态内部类，封装具体的导出逻辑
     * 负责：查询数据 -> 格式化 -> 写入文件
     */
    private static class TextExport {
        // ======================= 数据库查询配置 =======================
        // NOTE_PROJECTION - 便签表查询字段投影
        // 指定从数据库查询哪些字段，避免查询不必要的数据
        private static final String[] NOTE_PROJECTION = {
                NoteColumns.ID,              // 0 - 便签ID，主键
                NoteColumns.MODIFIED_DATE,   // 1 - 最后修改时间
                NoteColumns.SNIPPET,         // 2 - 便签摘要/标题
                NoteColumns.TYPE             // 3 - 便签类型（文件夹/便签）
        };
        // 便签表字段索引常量 - 提高代码可读性和维护性
        private static final int NOTE_COLUMN_ID = 0;              // ID列索引
        private static final int NOTE_COLUMN_MODIFIED_DATE = 1;   // 修改时间列索引
        private static final int NOTE_COLUMN_SNIPPET = 2;         // 摘要列索引
        // DATA_PROJECTION - 便签数据表查询字段投影
        // 便签具体内容存储在数据表中
        private static final String[] DATA_PROJECTION = {
                DataColumns.CONTENT,     // 0 - 便签内容
                DataColumns.MIME_TYPE,   // 1 - 数据类型（普通便签/通话记录）
                DataColumns.DATA1,       // 2 - 扩展数据1（通话记录时为通话时间）
                DataColumns.DATA2,       // 3 - 扩展数据2
                DataColumns.DATA3,       // 4 - 扩展数据3
                DataColumns.DATA4,       // 5 - 扩展数据4（通话记录时为电话号码）
        };
        // 数据表字段索引常量
        private static final int DATA_COLUMN_CONTENT = 0;        // 内容列索引
        private static final int DATA_COLUMN_MIME_TYPE = 1;      // 数据类型列索引
        private static final int DATA_COLUMN_CALL_DATE = 2;      // 通话日期列索引
        private static final int DATA_COLUMN_PHONE_NUMBER = 4;   // 电话号码列索引
        // ======================= 文本格式化配置 =======================
        // TEXT_FORMAT - 文本格式化模板数组
        // 从strings.xml的format_for_exported_note数组加载
        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构造函数
         * @param context 应用上下文，用于获取格式化模板
         */
        public TextExport(Context context) {
            // 从资源文件加载格式化模板
            TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note);
            mContext = context;
            // 初始化为空字符串
            mFileName = "";
            mFileDirectory = "";
        }
        /**
         * 获取指定索引的格式化模板
         * @param id 模板索引（FORMAT_FOLDER_NAME等）
         * @return 格式化字符串
         */
        private String getFormat(int id) {
            return TEXT_FORMAT[id];
        }
        /**
         * 导出指定文件夹下的所有便签
         * 按文件夹组织导出，保持原有结构
         * @param folderId 文件夹ID
         * @param ps 打印输出流，用于写入文件
         */
        private void exportFolderToText(String folderId, PrintStream ps) {
            // 查询该文件夹下的所有便签
            // Notes.CONTENT_NOTE_URI - 便签内容URI
            // NoteColumns.PARENT_ID - 父文件夹ID条件
            Cursor notesCursor = mContext.getContentResolver().query(
                    Notes.CONTENT_NOTE_URI,      // 便签表URI
                    NOTE_PROJECTION,             // 查询的字段
                    NoteColumns.PARENT_ID + "=?", // 查询条件：父ID等于指定文件夹
                    new String[] { folderId },   // 查询参数
                    null                         // 排序方式（null表示默认）
            );
            // 检查游标有效性
            if (notesCursor != null) {
                // 遍历查询结果
                if (notesCursor.moveToFirst()) {
                    do {
                        // 1. 打印便签修改时间
                        // 使用格式化模板，将时间戳格式化为可读字符串
                        ps.println(String.format(
                                getFormat(FORMAT_NOTE_DATE),
                                DateFormat.format(
                                        mContext.getString(R.string.format_datetime_mdhm), // 日期时间格式
                                        notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE)    // 时间戳
                                )
                        ));
                        // 2. 导出该便签的具体内容
                        String noteId = notesCursor.getString(NOTE_COLUMN_ID);
                        exportNoteToText(noteId, ps);
                    } while (notesCursor.moveToNext()); // 继续下一个便签
                }
                // 关闭游标，释放数据库资源
                notesCursor.close();
            }
        }
        /**
         * 导出单个便签的所有数据
         * 处理不同类型的便签：普通便签和通话记录
         * @param noteId 便签ID
         * @param ps 打印输出流
         */
        private void exportNoteToText(String noteId, PrintStream ps) {
            // 查询该便签的所有数据项
            Cursor dataCursor = mContext.getContentResolver().query(
                    Notes.CONTENT_DATA_URI,      // 便签数据表URI
                    DATA_PROJECTION,             // 查询字段
                    DataColumns.NOTE_ID + "=?",  // 查询条件：便签ID
                    new String[] { noteId },     // 查询参数
                    null                         // 排序
            );
            if (dataCursor != null) {
                if (dataCursor.moveToFirst()) {
                    do {
                        // 获取数据类型
                        String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE);
                        // 根据数据类型分别处理
                        if (DataConstants.CALL_NOTE.equals(mimeType)) {
                            // ===== 通话记录类型 =====
                            // 1. 获取通话相关数据
                            String phoneNumber = dataCursor.getString(DATA_COLUMN_PHONE_NUMBER);
                            long callDate = dataCursor.getLong(DATA_COLUMN_CALL_DATE);
                            String location = dataCursor.getString(DATA_COLUMN_CONTENT);
                            // 2. 打印电话号码（如果有）
                            if (!TextUtils.isEmpty(phoneNumber)) {
                                ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), phoneNumber));
                            }
                            // 3. 打印通话时间
                            ps.println(String.format(
                                    getFormat(FORMAT_NOTE_CONTENT),
                                    DateFormat.format(
                                            mContext.getString(R.string.format_datetime_mdhm),
                                            callDate
                                    )
                            ));
                            // 4. 打印位置信息（如果有）
                            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) {
                // 记录异常，但不中断导出流程
                Log.e(TAG, e.toString());
            }
        }
        /**
         * 导出所有便签到文本文件 - 主导出方法
         * 导出流程：
         * 1. 检查SD卡状态
         * 2. 创建输出文件
         * 3. 导出文件夹便签
         * 4. 导出根目录便签
         * 5. 关闭流
         * @return 导出状态码
         */
        public int exportToText() {
            // 1. 检查SD卡是否可用
            if (!externalStorageAvailable()) {
                Log.d(TAG, "Media was not mounted");
                return STATE_SD_CARD_UNMOUONTED;
            }
            // 2. 获取输出流
            PrintStream ps = getExportToTextPrintStream();
            if (ps == null) {
                Log.e(TAG, "get print stream error");
                return STATE_SYSTEM_ERROR;
            }
            // 3. 导出文件夹及其便签
            // 查询条件说明：
            // - 类型为文件夹 且 不在回收站中
            // - 或者 ID是通话记录文件夹
            Cursor folderCursor = mContext.getContentResolver().query(
                    Notes.CONTENT_NOTE_URI,  // 便签表
                    NOTE_PROJECTION,         // 查询字段
                    "(" + NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + ") 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));
                        }
                        // 导出该文件夹下的所有便签
                        String folderId = folderCursor.getString(NOTE_COLUMN_ID);
                        exportFolderToText(folderId, ps);
                    } while (folderCursor.moveToNext());
                }
                folderCursor.close();
            }
            // 4. 导出根目录下的便签（没有父文件夹的便签）
            // 查询条件：类型为普通便签 且 父ID为0（根目录）
            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)
                                )
                        ));
                        // 导出便签内容
                        String noteId = noteCursor.getString(NOTE_COLUMN_ID);
                        exportNoteToText(noteId, ps);
                    } while (noteCursor.moveToNext());
                }
                noteCursor.close();
            }
            // 5. 关闭输出流
            ps.close();
            return STATE_SUCCESS;
        }
        /**
         * 创建输出文件并获取打印流
         * 文件路径：SD卡根目录 + 配置路径 + 日期时间文件名
         * @return PrintStream 输出流，失败返回null
         */
        private PrintStream getExportToTextPrintStream() {
            // 生成输出文件
            File file = generateFileMountedOnSDcard(
                    mContext,
                    R.string.file_path,           // 文件路径资源ID
                    R.string.file_name_txt_format  // 文件名格式资源ID
            );
            if (file == 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) {
                // 文件未找到异常
                e.printStackTrace();
                return null;
            } catch (NullPointerException e) {
                // 空指针异常
                e.printStackTrace();
                return null;
            }
            return ps;
        }
    }
    // ======================= 静态工具方法 =======================
    /**
     * 在SD卡上创建导出文件
     * 文件命名规则：使用当前日期时间，避免重复
     * @param context 上下文
     * @param filePathResId 文件路径资源ID（如："/backup/"）
     * @param fileNameFormatResId 文件名格式资源ID（如："notes_%s.txt"）
     * @return 创建的文件对象，失败返回null
     */
    private static File generateFileMountedOnSDcard(
            Context context,
            int filePathResId,
            int fileNameFormatResId
    ) {
        // 使用StringBuilder构建文件路径，提高性能
        StringBuilder sb = new StringBuilder();
        // 1. SD卡根目录
        sb.append(Environment.getExternalStorageDirectory());
        // 2. 应用指定的文件路径
        sb.append(context.getString(filePathResId));
        // 创建目录对象
        File filedir = new File(sb.toString());
        // 3. 添加文件名（使用当前日期格式化）
        // 格式如：notes_20231215.txt
        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) {
            // 权限异常：无SD卡写入权限
            e.printStackTrace();
        } catch (IOException e) {
            // IO异常：磁盘空间不足等
            e.printStackTrace();
        }
        return null;  // 创建失败返回null
    }
 }
--- a/java/net/micode/notes/tool/DataUtils.java
+++ b/java/net/micode/notes/tool/DataUtils.java
@ -1,448 +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.
 */
 // DataUtils.java - 小米便签数据工具类
 // 主要功能：提供便签数据的批量操作、查询、验证等工具方法
 package net.micode.notes.tool;
 // ======================= 导入区域 =======================
 // Android数据操作相关类
 import android.content.ContentProviderOperation;    // 内容提供者批量操作
 import android.content.ContentProviderResult;      // 批量操作结果
 import android.content.ContentResolver;            // 内容解析器，用于访问ContentProvider
 import android.content.ContentUris;                // URI工具，用于构建带ID的URI
 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;                      // Notes主类
 import net.micode.notes.data.Notes.CallNote;             // 通话记录相关常量
 import net.micode.notes.data.Notes.NoteColumns;          // 便签表列定义
 import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute; // 小部件属性类
 // Java集合类
 import java.util.ArrayList;   // 动态数组
 import java.util.HashSet;     // 哈希集合，用于存储唯一ID
 // ======================= 数据工具主类 =======================
 /**
 * DataUtils - 便签数据操作工具类
 * 包含对便签数据的批量删除、移动、查询、验证等常用操作
 * 所有方法都是静态工具方法，无需实例化即可使用
 */
 public class DataUtils {
    // TAG - 日志标签，用于Logcat日志筛选
    public static final String TAG = "DataUtils";
    /**
     * 批量删除便签
     * 使用ContentProvider批量操作，提高删除效率
     * @param resolver 内容解析器，用于访问ContentProvider
     * @param ids 要删除的便签ID集合（HashSet保证ID唯一性）
     * @return true: 删除成功; false: 删除失败
     */
    public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
        // 参数验证
        if (ids == null) {
            Log.d(TAG, "the ids is null");
            return true;  // 空集合视为成功，无需操作
        }
        if (ids.size() == 0) {
            Log.d(TAG, "no id is in the hashset");
            return true;  // 空集合视为成功
        }
        // 创建批量操作列表
        ArrayList<ContentProviderOperation> operationList =
                new ArrayList<ContentProviderOperation>();
        // 遍历ID集合，为每个便签创建删除操作
        for (long id : ids) {
            // 禁止删除系统根文件夹
            if(id == Notes.ID_ROOT_FOLDER) {
                Log.e(TAG, "Don't delete system folder root");
                continue;  // 跳过系统文件夹
            }
            // 构建删除操作
            ContentProviderOperation.Builder builder = ContentProviderOperation
                    .newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
            operationList.add(builder.build());
        }
        // 执行批量操作
        try {
            ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
            // 验证操作结果
            if (results == null || results.length == 0 || results[0] == null) {
                Log.d(TAG, "delete notes failed, ids:" + ids.toString());
                return false;
            }
            return true;
        } catch (RemoteException e) {
            // 远程调用异常
            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
        } catch (OperationApplicationException e) {
            // 批量操作应用异常
            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
        }
        return false;
    }
    /**
     * 移动单个便签到其他文件夹
     * 更新便签的父文件夹ID，并标记为本地已修改
     * @param resolver 内容解析器
     * @param id 要移动的便签ID
     * @param srcFolderId 源文件夹ID
     * @param desFolderId 目标文件夹ID
     */
    public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
        // 创建更新数据
        ContentValues values = new ContentValues();
        values.put(NoteColumns.PARENT_ID, desFolderId);      // 新父文件夹ID
        values.put(NoteColumns.ORIGIN_PARENT_ID, srcFolderId); // 原父文件夹ID（用于同步）
        values.put(NoteColumns.LOCAL_MODIFIED, 1);           // 标记为本地已修改
        // 执行更新操作
        resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
    }
    /**
     * 批量移动便签到指定文件夹
     * 使用批量操作提高效率
     * @param resolver 内容解析器
     * @param ids 要移动的便签ID集合
     * @param folderId 目标文件夹ID
     * @return true: 移动成功; false: 移动失败
     */
    public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids,
                                            long folderId) {
        // 参数验证
        if (ids == null) {
            Log.d(TAG, "the ids is null");
            return true;  // 空集合视为成功
        }
        // 创建批量操作列表
        ArrayList<ContentProviderOperation> operationList =
                new ArrayList<ContentProviderOperation>();
        // 为每个便签创建更新操作
        for (long id : ids) {
            ContentProviderOperation.Builder builder = ContentProviderOperation
                    .newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
            builder.withValue(NoteColumns.PARENT_ID, folderId);    // 更新父文件夹ID
            builder.withValue(NoteColumns.LOCAL_MODIFIED, 1);      // 标记为本地已修改
            operationList.add(builder.build());
        }
        // 执行批量操作
        try {
            ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
            // 验证操作结果
            if (results == null || results.length == 0 || results[0] == null) {
                Log.d(TAG, "delete notes failed, ids:" + ids.toString());
                return false;
            }
            return true;
        } catch (RemoteException e) {
            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
        } catch (OperationApplicationException e) {
            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
        }
        return false;
    }
    /**
     * 获取用户文件夹数量（排除系统文件夹）
     * 统计所有用户创建的文件夹，不包括系统预置文件夹
     * @param resolver 内容解析器
     * @return 用户文件夹数量
     */
    public static int getUserFolderCount(ContentResolver resolver) {
        // 查询条件：类型为文件夹
        Cursor cursor =resolver.query(Notes.CONTENT_NOTE_URI,
                new String[] { "COUNT(*)" },  // 只查询数量
                NoteColumns.TYPE + "=?",  // 查询条件
                new String[] {
                        String.valueOf(Notes.TYPE_FOLDER)      // 参数1：文件夹类型
                },
                null);
        int count = 0;
        if(cursor != null) {
            if(cursor.moveToFirst()) {
                try {
                    count = cursor.getInt(0);  // 获取第一列（COUNT(*)结果）
                } catch (IndexOutOfBoundsException e) {
                    Log.e(TAG, "get folder count failed:" + e.toString());
                } finally {
                    cursor.close();  // 确保游标关闭
                }
            }
        }
        return count;
    }
    /**
     * 检查便签在数据库中是否可见
     * 可见条件：指定类型 且 不在回收站中
     * @param resolver 内容解析器
     * @param noteId 便签ID
     * @param type 便签类型（Notes.TYPE_NOTE 或 Notes.TYPE_FOLDER）
     * @return true: 可见; false: 不可见（在回收站中或类型不匹配）
     */
    public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
        // 查询指定便签
        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
                null,  // 查询所有列
                NoteColumns.TYPE + "=?",
                new String [] {String.valueOf(type)},  // 类型参数
                null);
        boolean exist = false;
        if (cursor != null) {
            // 只要查询到记录就表示可见
            if (cursor.getCount() > 0) {
                exist = true;
            }
            cursor.close();
        }
        return exist;
    }
    /**
     * 检查便签是否存在于数据库中
     * 不关心是否在回收站，只要存在就返回true
     * @param resolver 内容解析器
     * @param noteId 便签ID
     * @return true: 存在; false: 不存在
     */
    public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
        // 查询指定便签，无过滤条件
        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
                null, null, null, null);
        boolean exist = false;
        if (cursor != null) {
            if (cursor.getCount() > 0) {
                exist = true;
            }
            cursor.close();
        }
        return exist;
    }
    /**
     * 检查数据项是否存在于数据表中
     * 数据表存储便签的具体内容
     * @param resolver 内容解析器
     * @param dataId 数据项ID
     * @return true: 存在; false: 不存在
     */
    public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId),
                null, null, null, null);
        boolean exist = false;
        if (cursor != null) {
            if (cursor.getCount() > 0) {
                exist = true;
            }
            cursor.close();
        }
        return exist;
    }
    /**
     * 检查可见文件夹名称是否已存在
     * 用于创建文件夹时的重名检查
     * @param resolver 内容解析器
     * @param name 要检查的文件夹名称
     * @return true: 已存在; false: 不存在
     */
    public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
        // 查询条件：文件夹类型 且 名称匹配
        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,
                NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER +
                        " AND " + NoteColumns.SNIPPET + "=?",  // SNIPPET字段存储文件夹名称
                new String[] { name }, null);
        boolean exist = false;
        if(cursor != null) {
            if(cursor.getCount() > 0) {
                exist = true;
            }
            cursor.close();
        }
        return exist;
    }
    /**
     * 获取文件夹下所有便签的小部件信息
     * 用于桌面小部件管理
     * @param resolver 内容解析器
     * @param folderId 文件夹ID
     * @return 小部件属性集合，null表示无小部件
     */
    public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
        // 查询文件夹下所有便签的小部件信息
        Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
                new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE },  // 小部件相关字段
                NoteColumns.PARENT_ID + "=?",  // 父文件夹条件
                new String[] { String.valueOf(folderId) },
                null);
        HashSet<AppWidgetAttribute> set = null;
        if (c != null) {
            if (c.moveToFirst()) {
                set = new HashSet<AppWidgetAttribute>();  // 创建集合
                do {
                    try {
                        // 创建小部件属性对象
                        AppWidgetAttribute widget = new AppWidgetAttribute();
                        widget.widgetId = c.getInt(0);     // 小部件ID
                        widget.widgetType = c.getInt(1);   // 小部件类型
                        set.add(widget);                   // 添加到集合
                    } catch (IndexOutOfBoundsException e) {
                        Log.e(TAG, e.toString());  // 字段索引异常
                    }
                } while (c.moveToNext());  // 遍历所有便签
            }
            c.close();
        }
        return set;
    }
    /**
     * 根据便签ID获取通话记录的电话号码
     * 用于通话记录类型便签
     * @param resolver 内容解析器
     * @param noteId 便签ID
     * @return 电话号码，空字符串表示未找到
     */
    public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
        // 查询条件：便签ID匹配 且 类型为通话记录
        Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
                new String [] { CallNote.PHONE_NUMBER },  // 只查询电话号码
                CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?",
                new String [] {
                        String.valueOf(noteId),        // 参数1：便签ID
                        CallNote.CONTENT_ITEM_TYPE     // 参数2：通话记录类型
                },
                null);
        if (cursor != null && cursor.moveToFirst()) {
            try {
                return cursor.getString(0);  // 返回电话号码
            } catch (IndexOutOfBoundsException e) {
                Log.e(TAG, "Get call number fails " + e.toString());
            } finally {
                cursor.close();  // finally块确保游标关闭
            }
        }
        return "";  // 未找到返回空字符串
    }
    /**
     * 根据电话号码和通话时间查找便签ID
     * 用于避免创建重复的通话记录
     * @param resolver 内容解析器
     * @param phoneNumber 电话号码
     * @param callDate 通话时间戳
     * @return 便签ID，0表示未找到
     */
    public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
        // 查询条件：通话时间匹配 且 类型为通话记录 且 电话号码匹配
        // PHONE_NUMBERS_EQUAL是自定义函数，用于比较电话号码（可能处理格式差异）
        Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
                new String [] { CallNote.NOTE_ID },  // 只查询便签ID
                CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL("
                        + CallNote.PHONE_NUMBER + ",?)",
                new String [] {
                        String.valueOf(callDate),        // 参数1：通话时间
                        CallNote.CONTENT_ITEM_TYPE,      // 参数2：通话记录类型
                        phoneNumber                      // 参数3：电话号码
                },
                null);
        if (cursor != null) {
            if (cursor.moveToFirst()) {
                try {
                    return cursor.getLong(0);  // 返回便签ID
                } catch (IndexOutOfBoundsException e) {
                    Log.e(TAG, "Get call note id fails " + e.toString());
                }
            }
            cursor.close();
        }
        return 0;  // 未找到返回0
    }
    /**
     * 根据便签ID获取便签摘要
     * 摘要通常显示在列表视图中
     * @param resolver 内容解析器
     * @param noteId 便签ID
     * @return 便签摘要
     * @throws IllegalArgumentException 如果便签不存在
     */
    public static String getSnippetById(ContentResolver resolver, long noteId) {
        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
                new String [] { NoteColumns.SNIPPET },  // 只查询摘要字段
                NoteColumns.ID + "=?",
                new String [] { String.valueOf(noteId)},
                null);
        if (cursor != null) {
            String snippet = "";
            if (cursor.moveToFirst()) {
                snippet = cursor.getString(0);  // 获取摘要
            }
            cursor.close();
            return snippet;
        }
        throw new IllegalArgumentException("Note is not found with id: " + noteId);
    }
    /**
     * 格式化便签摘要
     * 处理摘要显示：去除首尾空格，只显示第一行
     * @param snippet 原始摘要
     * @return 格式化后的摘要
     */
    public static String getFormattedSnippet(String snippet) {
        if (snippet != null) {
            snippet = snippet.trim();  // 去除首尾空格
            // 查找第一个换行符
            int index = snippet.indexOf('\n');
            if (index != -1) {
                // 只保留第一行
                snippet = snippet.substring(0, index);
            }
        }
        return snippet;
    }
 }
--- a/java/net/micode/notes/tool/GTaskStringUtils.java
+++ b/java/net/micode/notes/tool/GTaskStringUtils.java
@ -1,197 +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.
 */
 // GTaskStringUtils.java - Google任务（GTasks）同步相关的字符串常量工具类
 // 主要功能：定义与Google Tasks API交互时使用的JSON键名、操作类型、元数据标识等常量
 // 这些常量用于序列化和反序列化Google Tasks的JSON数据
 package net.micode.notes.tool;
 // ======================= Google Tasks JSON键名常量 =======================
 /**
 * GTaskStringUtils - Google Tasks同步字符串常量工具类
 * 包含所有与Google Tasks API通信时使用的JSON键名、操作类型、文件夹标识等常量
 * 所有常量都是public static final，确保全局唯一且不可修改
 */
 public class GTaskStringUtils {
    // ======================= 操作相关键名 =======================
    /** 操作ID键名 - JSON中标识操作的唯一ID */
    public final static String GTASK_JSON_ACTION_ID = "action_id";
    /** 操作列表键名 - JSON中包含多个操作的数组 */
    public final static String GTASK_JSON_ACTION_LIST = "action_list";
    /** 操作类型键名 - JSON中标识操作类型的字段 */
    public final static String GTASK_JSON_ACTION_TYPE = "action_type";
    // ======================= 操作类型值 =======================
    /** 创建操作类型值 - 表示创建新项的操作 */
    public final static String GTASK_JSON_ACTION_TYPE_CREATE = "create";
    /** 获取全部操作类型值 - 表示获取所有数据的操作 */
    public final static String GTASK_JSON_ACTION_TYPE_GETALL = "get_all";
    /** 移动操作类型值 - 表示移动项到其他位置的操作 */
    public final static String GTASK_JSON_ACTION_TYPE_MOVE = "move";
    /** 更新操作类型值 - 表示更新现有项的操作 */
    public final static String GTASK_JSON_ACTION_TYPE_UPDATE = "update";
    // ======================= 创建者和版本信息 =======================
    /** 创建者ID键名 - JSON中标识创建者的字段 */
    public final static String GTASK_JSON_CREATOR_ID = "creator_id";
    /** 客户端版本键名 - JSON中标识客户端版本的字段 */
    public final static String GTASK_JSON_CLIENT_VERSION = "client_version";
    // ======================= 实体和子项相关 =======================
    /** 子实体键名 - JSON中表示子项的列表 */
    public final static String GTASK_JSON_CHILD_ENTITY = "child_entity";
    /** 实体增量键名 - JSON中表示实体变更的字段 */
    public final static String GTASK_JSON_ENTITY_DELTA = "entity_delta";
    /** 实体类型键名 - JSON中标识实体类型的字段 */
    public final static String GTASK_JSON_ENTITY_TYPE = "entity_type";
    // ======================= 状态和删除相关 =======================
    /** 完成状态键名 - JSON中标识任务是否完成的字段 */
    public final static String GTASK_JSON_COMPLETED = "completed";
    /** 删除状态键名 - JSON中标识项是否被删除的字段 */
    public final static String GTASK_JSON_DELETED = "deleted";
    /** 获取删除项键名 - JSON中标识是否获取已删除项的字段 */
    public final static String GTASK_JSON_GET_DELETED = "get_deleted";
    // ======================= ID和索引相关 =======================
    /** ID键名 - JSON中最基本的ID字段 */
    public final static String GTASK_JSON_ID = "id";
    /** 新ID键名 - JSON中表示新生成的ID字段（用于创建操作） */
    public final static String GTASK_JSON_NEW_ID = "new_id";
    /** 索引键名 - JSON中表示项在列表中的位置索引 */
    public final static String GTASK_JSON_INDEX = "index";
    /** 父项ID键名 - JSON中表示父项的ID */
    public final static String GTASK_JSON_PARENT_ID = "parent_id";
    /** 前一个兄弟项ID键名 - JSON中表示同一层级中前一项的ID（用于确定位置） */
    public final static String GTASK_JSON_PRIOR_SIBLING_ID = "prior_sibling_id";
    // ======================= 列表相关 =======================
    /** 当前列表ID键名 - JSON中表示当前活动列表的ID */
    public final static String GTASK_JSON_CURRENT_LIST_ID = "current_list_id";
    /** 默认列表ID键名 - JSON中表示默认列表的ID */
    public final static String GTASK_JSON_DEFAULT_LIST_ID = "default_list_id";
    /** 列表ID键名 - JSON中表示列表的ID */
    public final static String GTASK_JSON_LIST_ID = "list_id";
    /** 列表集合键名 - JSON中包含多个列表的数组 */
    public final static String GTASK_JSON_LISTS = "lists";
    /** 源列表键名 - JSON中表示移动操作的源列表 */
    public final static String GTASK_JSON_SOURCE_LIST = "source_list";
    /** 目标列表键名 - JSON中表示移动操作的目标列表 */
    public final static String GTASK_JSON_DEST_LIST = "dest_list";
    // ======================= 移动操作相关 =======================
    /** 目标父项键名 - JSON中表示移动操作的目标父项 */
    public final static String GTASK_JSON_DEST_PARENT = "dest_parent";
    /** 目标父项类型键名 - JSON中表示移动操作的目标父项类型 */
    public final static String GTASK_JSON_DEST_PARENT_TYPE = "dest_parent_type";
    // ======================= 时间和同步相关 =======================
    /** 最后修改时间键名 - JSON中表示项的最后修改时间戳 */
    public final static String GTASK_JSON_LAST_MODIFIED = "last_modified";
    /** 最新同步点键名 - JSON中表示最新的同步时间点（用于增量同步） */
    public final static String GTASK_JSON_LATEST_SYNC_POINT = "latest_sync_point";
    // ======================= 名称和内容相关 =======================
    /** 名称键名 - JSON中表示项的名称/标题字段 */
    public final static String GTASK_JSON_NAME = "name";
    /** 便签内容键名 - JSON中表示便签具体内容的字段 */
    public final static String GTASK_JSON_NOTES = "notes";
    // ======================= 结果和任务相关 =======================
    /** 结果键名 - JSON中表示操作结果集的字段 */
    public final static String GTASK_JSON_RESULTS = "results";
    /** 任务集合键名 - JSON中包含多个任务的数组 */
    public final static String GTASK_JSON_TASKS = "tasks";
    // ======================= 类型相关 =======================
    /** 类型键名 - JSON中表示项的类型字段 */
    public final static String GTASK_JSON_TYPE = "type";
    /** 组类型值 - JSON中表示组/文件夹类型的值 */
    public final static String GTASK_JSON_TYPE_GROUP = "GROUP";
    /** 任务类型值 - JSON中表示任务/便签类型的值 */
    public final static String GTASK_JSON_TYPE_TASK = "TASK";
    // ======================= 用户相关 =======================
    /** 用户键名 - JSON中表示用户信息的字段 */
    public final static String GTASK_JSON_USER = "user";
    // ======================= MIUI便签专用文件夹前缀 =======================
    /** MIUI文件夹前缀 - 用于标识MIUI便签创建的Google Tasks文件夹 */
    public final static String MIUI_FOLDER_PREFFIX = "[MIUI_Notes]";
    /** 默认文件夹名称 - 在Google Tasks中创建的默认文件夹名称 */
    public final static String FOLDER_DEFAULT = "Default";
    /** 通话记录文件夹名称 - 在Google Tasks中创建的通话记录专用文件夹 */
    public final static String FOLDER_CALL_NOTE = "Call_Note";
    // ======================= 元数据相关 =======================
    /** 元数据文件夹标识 - 用于标识存储同步元数据的特殊文件夹 */
    public final static String FOLDER_META = "METADATA";
    /** 元数据头-GTaskID - 元数据中存储Google Task ID的字段前缀 */
    public final static String META_HEAD_GTASK_ID = "meta_gid";
    /** 元数据头-便签 - 元数据中存储便签信息的字段前缀 */
    public final static String META_HEAD_NOTE = "meta_note";
    /** 元数据头-数据 - 元数据中存储便签详细数据的字段前缀 */
    public final static String META_HEAD_DATA = "meta_data";
    /** 元数据便签名称 - 用于存储同步元数据的特殊便签的名称（提示用户不要修改） */
    public final static String META_NOTE_NAME = "[META INFO] DON'T UPDATE AND DELETE";
 }
--- a/java/net/micode/notes/tool/ResourceParser.java
+++ b/java/net/micode/notes/tool/ResourceParser.java
@ -1,310 +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.
 */
 // ResourceParser.java - 资源解析工具类
 // 主要功能：管理便签应用的颜色主题、背景资源、字体大小等UI相关资源的映射和获取
 package net.micode.notes.tool;
 // ======================= 导入区域 =======================
 // Android相关类
 import android.content.Context;                 // 上下文，用于访问偏好设置
 import android.preference.PreferenceManager;    // 偏好设置管理器
 // 应用内部资源
 import net.micode.notes.R;                      // 资源文件R类
 import net.micode.notes.ui.NotesPreferenceActivity; // 设置Activity，包含偏好设置键名
 // ======================= 资源解析主类 =======================
 /**
 * ResourceParser - 资源解析工具类
 * 集中管理便签应用的UI资源映射关系
 * 包括：背景颜色、字体大小、编辑界面背景、列表项背景、小部件背景等
 */
 public class ResourceParser {
    // ======================= 便签背景颜色常量 =======================
    /**
     * 便签背景颜色类型常量
     * 对应五种不同的便签背景颜色主题
     */
    public static final int YELLOW           = 0; // 黄色主题
    public static final int BLUE             = 1; // 蓝色主题
    public static final int WHITE            = 2; // 白色主题
    public static final int GREEN            = 3; // 绿色主题
    public static final int RED              = 4; // 红色主题
    /** 默认背景颜色索引 - 应用启动时的默认颜色 */
    public static final int BG_DEFAULT_COLOR = YELLOW; // 默认为黄色
    // ======================= 字体大小常量 =======================
    /**
     * 字体大小类型常量
     * 对应四种不同的字体大小级别
     */
    public static final int TEXT_SMALL       = 0; // 小号字体
    public static final int TEXT_MEDIUM      = 1; // 中号字体
    public static final int TEXT_LARGE       = 2; // 大号字体
    public static final int TEXT_SUPER       = 3; // 超大号字体
    /** 默认字体大小索引 - 应用启动时的默认字体大小 */
    public static final int BG_DEFAULT_FONT_SIZE = TEXT_MEDIUM; // 默认为中号字体
    // ======================= 编辑界面背景资源类 =======================
    /**
     * NoteBgResources - 便签编辑界面背景资源类
     * 管理便签编辑页面的背景图片资源
     */
    public static class NoteBgResources {
        // 便签编辑区域背景资源数组
        // 数组索引对应颜色常量：0=黄, 1=蓝, 2=白, 3=绿, 4=红
        private final static int [] BG_EDIT_RESOURCES = new int [] {
                R.drawable.edit_yellow,  // 黄色编辑背景
                R.drawable.edit_blue,    // 蓝色编辑背景
                R.drawable.edit_white,   // 白色编辑背景
                R.drawable.edit_green,   // 绿色编辑背景
                R.drawable.edit_red      // 红色编辑背景
        };
        // 便签标题栏背景资源数组
        // 与编辑区域背景对应，但用于标题栏部分
        private final static int [] BG_EDIT_TITLE_RESOURCES = new int [] {
                R.drawable.edit_title_yellow,  // 黄色标题背景
                R.drawable.edit_title_blue,    // 蓝色标题背景
                R.drawable.edit_title_white,   // 白色标题背景
                R.drawable.edit_title_green,   // 绿色标题背景
                R.drawable.edit_title_red      // 红色标题背景
        };
        /**
         * 获取便签编辑区域背景资源ID
         * @param id 颜色索引（YELLOW/BLUE/WHITE/GREEN/RED）
         * @return 对应的drawable资源ID
         */
        public static int getNoteBgResource(int id) {
            return BG_EDIT_RESOURCES[id];
        }
        /**
         * 获取便签标题栏背景资源ID
         * @param id 颜色索引（YELLOW/BLUE/WHITE/GREEN/RED）
         * @return 对应的drawable资源ID
         */
        public static int getNoteTitleBgResource(int id) {
            return BG_EDIT_TITLE_RESOURCES[id];
        }
    }
    /**
     * 获取默认背景颜色ID
     * 根据用户设置决定：随机颜色或默认颜色
     * @param context 上下文，用于读取偏好设置
     * @return 背景颜色索引
     */
    public static int getDefaultBgId(Context context) {
        // 从偏好设置读取是否启用随机背景颜色
        if (context.getSharedPreferences(NotesPreferenceActivity.PREFERENCE_NAME, Context.MODE_PRIVATE).getBoolean(
                NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, // 偏好设置键名
                false)) {  // 默认值为false（不随机）
            // 随机选择一种颜色
            return (int) (Math.random() * NoteBgResources.BG_EDIT_RESOURCES.length);
        } else {
            // 使用默认颜色
            return BG_DEFAULT_COLOR;
        }
    }
    // ======================= 列表项背景资源类 =======================
    /**
     * NoteItemBgResources - 便签列表项背景资源类
     * 管理便签列表界面中各项的背景图片资源
     * 支持不同位置的项使用不同背景（首项、中间项、末项、单独项）
     */
    public static class NoteItemBgResources {
        // 列表首项背景资源数组
        // 用于列表中的第一个项（顶部圆角）
        private final static int [] BG_FIRST_RESOURCES = new int [] {
                R.drawable.list_yellow_up,    // 黄色首项背景
                R.drawable.list_blue_up,      // 蓝色首项背景
                R.drawable.list_white_up,     // 白色首项背景
                R.drawable.list_green_up,     // 绿色首项背景
                R.drawable.list_red_up        // 红色首项背景
        };
        // 列表中间项背景资源数组
        // 用于列表中非首尾的中间项（直角）
        private final static int [] BG_NORMAL_RESOURCES = new int [] {
                R.drawable.list_yellow_middle,  // 黄色中间项背景
                R.drawable.list_blue_middle,    // 蓝色中间项背景
                R.drawable.list_white_middle,   // 白色中间项背景
                R.drawable.list_green_middle,   // 绿色中间项背景
                R.drawable.list_red_middle      // 红色中间项背景
        };
        // 列表末项背景资源数组
        // 用于列表中的最后一个项（底部圆角）
        private final static int [] BG_LAST_RESOURCES = new int [] {
                R.drawable.list_yellow_down,   // 黄色末项背景
                R.drawable.list_blue_down,     // 蓝色末项背景
                R.drawable.list_white_down,    // 白色末项背景
                R.drawable.list_green_down,    // 绿色末项背景
                R.drawable.list_red_down,      // 红色末项背景
        };
        // 列表单独项背景资源数组
        // 用于列表中只有一个项的情况（上下都有圆角）
        private final static int [] BG_SINGLE_RESOURCES = new int [] {
                R.drawable.list_yellow_single,  // 黄色单独项背景
                R.drawable.list_blue_single,    // 蓝色单独项背景
                R.drawable.list_white_single,   // 白色单独项背景
                R.drawable.list_green_single,   // 绿色单独项背景
                R.drawable.list_red_single      // 红色单独项背景
        };
        /**
         * 获取列表首项背景资源ID
         * @param id 颜色索引
         * @return 对应的drawable资源ID
         */
        public static int getNoteBgFirstRes(int id) {
            return BG_FIRST_RESOURCES[id];
        }
        /**
         * 获取列表末项背景资源ID
         * @param id 颜色索引
         * @return 对应的drawable资源ID
         */
        public static int getNoteBgLastRes(int id) {
            return BG_LAST_RESOURCES[id];
        }
        /**
         * 获取列表单独项背景资源ID
         * @param id 颜色索引
         * @return 对应的drawable资源ID
         */
        public static int getNoteBgSingleRes(int id) {
            return BG_SINGLE_RESOURCES[id];
        }
        /**
         * 获取列表中间项背景资源ID
         * @param id 颜色索引
         * @return 对应的drawable资源ID
         */
        public static int getNoteBgNormalRes(int id) {
            return BG_NORMAL_RESOURCES[id];
        }
        /**
         * 获取文件夹项背景资源ID
         * 文件夹使用统一的背景，不区分颜色
         * @return 文件夹专用背景资源ID
         */
        public static int getFolderBgRes() {
            return R.drawable.list_folder;
        }
    }
    // ======================= 小部件背景资源类 =======================
    /**
     * WidgetBgResources - 桌面小部件背景资源类
     * 管理不同尺寸桌面小部件的背景图片资源
     */
    public static class WidgetBgResources {
        // 2x尺寸小部件背景资源数组
        // 用于2x2尺寸的桌面小部件
        private final static int [] BG_2X_RESOURCES = new int [] {
                R.drawable.widget_2x_yellow,  // 黄色2x小部件背景
                R.drawable.widget_2x_blue,    // 蓝色2x小部件背景
                R.drawable.widget_2x_white,   // 白色2x小部件背景
                R.drawable.widget_2x_green,   // 绿色2x小部件背景
                R.drawable.widget_2x_red,     // 红色2x小部件背景
        };
        /**
         * 获取2x尺寸小部件背景资源ID
         * @param id 颜色索引
         * @return 对应的drawable资源ID
         */
        public static int getWidget2xBgResource(int id) {
            return BG_2X_RESOURCES[id];
        }
        // 4x尺寸小部件背景资源数组
        // 用于4x4尺寸的桌面小部件
        private final static int [] BG_4X_RESOURCES = new int [] {
                R.drawable.widget_4x_yellow,  // 黄色4x小部件背景
                R.drawable.widget_4x_blue,    // 蓝色4x小部件背景
                R.drawable.widget_4x_white,   // 白色4x小部件背景
                R.drawable.widget_4x_green,   // 绿色4x小部件背景
                R.drawable.widget_4x_red      // 红色4x小部件背景
        };
        /**
         * 获取4x尺寸小部件背景资源ID
         * @param id 颜色索引
         * @return 对应的drawable资源ID
         */
        public static int getWidget4xBgResource(int id) {
            return BG_4X_RESOURCES[id];
        }
    }
    // ======================= 文本外观资源类 =======================
    /**
     * TextAppearanceResources - 文本外观资源类
     * 管理便签内容的字体大小样式资源
     * 包含对偏好设置中存储异常的处理
     */
    public static class TextAppearanceResources {
        // 文本外观样式资源数组
        // 索引对应字体大小常量：0=小, 1=中, 2=大, 3=超大
        private final static int [] TEXTAPPEARANCE_RESOURCES = new int [] {
                R.style.TextAppearanceNormal,  // 小号字体样式
                R.style.TextAppearanceMedium,  // 中号字体样式
                R.style.TextAppearanceLarge,   // 大号字体样式
                R.style.TextAppearanceSuper    // 超大号字体样式
        };
        /**
         * 获取文本外观样式资源ID
         * 包含对偏好设置中存储错误ID的修复处理
         * @param id 字体大小索引
         * @return 对应的style资源ID
         */
        public static int getTexAppearanceResource(int id) {
            /**
             * HACKME: 修复在偏好设置中存储资源ID的bug
             * 问题：从偏好设置读取的id可能超过资源数组长度
             * 解决：如果id超出范围，返回默认字体大小
             */
            if (id >= TEXTAPPEARANCE_RESOURCES.length) {
                return BG_DEFAULT_FONT_SIZE;  // 返回默认字体大小索引
            }
            return TEXTAPPEARANCE_RESOURCES[id];
        }
        /**
         * 获取文本外观资源数组长度
         * 用于验证和边界检查
         * @return 字体大小样式总数
         */
        public static int getResourcesSize() {
            return TEXTAPPEARANCE_RESOURCES.length;
        }
    }
 }
--- a/java/net/micode/notes/tool/SearchHistoryManager.java
+++ b/java/net/micode/notes/tool/SearchHistoryManager.java
@ -1,143 +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.tool;
 import android.content.Context;
 import android.content.SharedPreferences;
 import android.text.TextUtils;
 import android.util.Log;
 import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 /**
 * SearchHistoryManager - 搜索历史记录管理类
 * 使用SharedPreferences存储搜索历史记录
 */
 public class SearchHistoryManager {
    private static final String TAG = "SearchHistoryManager";
    // SharedPreferences文件名
    private static final String PREFERENCE_NAME = "search_history";
    // 搜索历史键
    private static final String KEY_SEARCH_HISTORY = "search_history";
    // 最大历史记录数量
    private static final int MAX_HISTORY_COUNT = 10;
    // 单例实例
    private static SearchHistoryManager sInstance;
    // SharedPreferences实例
    private SharedPreferences mSharedPreferences;
    /**
     * 私有构造函数
     * @param context 上下文
     */
    private SearchHistoryManager(Context context) {
        mSharedPreferences = context.getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
    }
    /**
     * 获取单例实例
     * @param context 上下文
     * @return SearchHistoryManager实例
     */
    public static synchronized SearchHistoryManager getInstance(Context context) {
        if (sInstance == null) {
            sInstance = new SearchHistoryManager(context.getApplicationContext());
        }
        return sInstance;
    }
    /**
     * 保存搜索关键词到历史记录
     * @param keyword 搜索关键词
     */
    public void saveSearchKeyword(String keyword) {
        if (TextUtils.isEmpty(keyword)) {
            return;
        }
        // 获取现有历史记录
        List<String> historyList = getSearchHistoryList();
        // 如果已存在，移除旧的位置
        if (historyList.contains(keyword)) {
            historyList.remove(keyword);
        }
        // 添加到最前面
        historyList.add(0, keyword);
        // 限制历史记录数量
        if (historyList.size() > MAX_HISTORY_COUNT) {
            historyList = historyList.subList(0, MAX_HISTORY_COUNT);
        }
        // 保存到SharedPreferences
        saveHistoryList(historyList);
    }
    /**
     * 获取搜索历史记录列表
     * @return 搜索历史记录列表
     */
    public List<String> getSearchHistoryList() {
        List<String> historyList = new ArrayList<>();
        try {
            String historyJson = mSharedPreferences.getString(KEY_SEARCH_HISTORY, "[]");
            JSONArray jsonArray = new JSONArray(historyJson);
            for (int i = 0; i < jsonArray.length(); i++) {
                historyList.add(jsonArray.getString(i));
            }
        } catch (JSONException e) {
            Log.e(TAG, "Failed to parse search history: " + e.getMessage());
        }
        return historyList;
    }
    /**
     * 清除所有搜索历史记录
     */
    public void clearSearchHistory() {
        mSharedPreferences.edit().remove(KEY_SEARCH_HISTORY).apply();
    }
    /**
     * 保存历史记录列表到SharedPreferences
     * @param historyList 历史记录列表
     */
    private void saveHistoryList(List<String> historyList) {
        try {
            JSONArray jsonArray = new JSONArray(historyList);
            mSharedPreferences.edit().putString(KEY_SEARCH_HISTORY, jsonArray.toString()).apply();
        } catch (Exception e) {
            Log.e(TAG, "Failed to save search history: " + e.getMessage());
        }
    }
 }
--- a/java/net/micode/notes/ui/AlarmAlertActivity.java
+++ b/java/net/micode/notes/ui/AlarmAlertActivity.java
@ -1,270 +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.
 */
 // AlarmAlertActivity.java - 闹钟提醒Activity
 // 主要功能：显示便签闹钟提醒，在指定时间弹出提醒对话框并播放提示音
 package net.micode.notes.ui;
 // ======================= 导入区域 =======================
 // Android基础类
 import android.app.Activity;                     // Activity基类
 import android.app.AlertDialog;                  // 警告对话框
 import android.content.Context;                  // 上下文
 import android.content.DialogInterface;          // 对话框接口
 import android.content.DialogInterface.OnClickListener;  // 对话框点击监听
 import android.content.DialogInterface.OnDismissListener; // 对话框关闭监听
 import android.content.Intent;                   // Intent，用于跳转
 import android.media.AudioManager;               // 音频管理
 import android.media.MediaPlayer;                // 媒体播放器
 import android.media.RingtoneManager;            // 铃声管理器
 import android.net.Uri;                          // URI
 import android.os.Bundle;                        // Bundle，用于保存状态
 import android.os.PowerManager;                  // 电源管理
 import android.provider.Settings;                // 系统设置
 import android.view.Window;                      // 窗口
 import android.view.WindowManager;               // 窗口管理器
 // 应用内部资源
 import net.micode.notes.R;                       // 资源文件R类
 import net.micode.notes.data.Notes;              // Notes主类
 import net.micode.notes.tool.DataUtils;          // 数据工具类
 // Java IO
 import java.io.IOException;                      // IO异常
 // ======================= 闹钟提醒Activity =======================
 /**
 * AlarmAlertActivity - 闹钟提醒Activity
 * 全屏对话框形式显示，即使在锁屏状态下也会弹出
 * 实现功能：显示便签内容、播放提示音、提供操作按钮
 * 实现接口：OnClickListener（对话框按钮点击），OnDismissListener（对话框关闭）
 */
 public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener {
    // 成员变量
    private long mNoteId;                          // 便签ID，从Intent中获取
    private String mSnippet;                       // 便签摘要，用于对话框显示
    private static final int SNIPPET_PREW_MAX_LEN = 60; // 摘要预览最大长度
    MediaPlayer mPlayer;                           // 媒体播放器，用于播放提示音
    // ======================= 生命周期方法 =======================
    /**
     * onCreate - Activity创建时的初始化方法
     * 主要任务：
     * 1. 设置窗口属性（全屏、锁屏显示）
     * 2. 获取便签ID和内容
     * 3. 检查便签是否存在
     * 4. 显示提醒对话框
     * 5. 播放提示音
     * @param savedInstanceState 保存的状态（此处为null，因是新建Activity）
     */
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 1. 设置窗口属性
        // 请求无标题栏
        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);        // 布局装饰
        }
        // 2. 获取Intent数据
        Intent intent = getIntent();
        try {
            // 从Intent的URI中解析便签ID
            // URI格式示例：content://micode_notes/note/123
            // getPathSegments()返回["note", "123"]，取索引1得到"123"
            mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1));
            // 通过工具类获取便签摘要
            mSnippet = DataUtils.getSnippetById(this.getContentResolver(), mNoteId);
            // 3. 处理摘要显示长度
            // 如果摘要过长，截取前60个字符并添加省略号
            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) {
            // URI解析或ID转换异常
            e.printStackTrace();
            return;  // 异常时直接返回，不继续执行
        }
        // 4. 初始化媒体播放器
        mPlayer = new MediaPlayer();
        // 5. 检查便签是否可见（存在且不在回收站）
        if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) {
            // 便签存在，显示对话框
            showActionDialog();
            // 播放提示音
            playAlarmSound();
        } else {
            // 便签不存在（可能已被删除），直接结束Activity
            finish();
        }
    }
    /**
     * 检查屏幕是否亮屏
     * @return true: 屏幕已亮; false: 屏幕关闭
     */
    private boolean isScreenOn() {
        // 获取电源管理器服务
        PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
        // 判断屏幕是否亮屏（已废弃，但兼容旧版本）
        return pm.isScreenOn();
    }
    // ======================= 提示音播放 =======================
    /**
     * 播放闹钟提示音
     * 使用系统默认的闹钟铃声
     */
    private void playAlarmSound() {
        // 1. 获取系统默认闹钟铃声URI
        Uri url = RingtoneManager.getActualDefaultRingtoneUri(this, RingtoneManager.TYPE_ALARM);
        // 2. 获取静音模式设置
        // 检查哪些音频流受静音模式影响
        int silentModeStreams = Settings.System.getInt(getContentResolver(),
                Settings.System.MODE_RINGER_STREAMS_AFFECTED, 0);
        // 3. 设置音频流类型
        // 判断闹钟音频流是否受静音模式影响
        if ((silentModeStreams & (1 << AudioManager.STREAM_ALARM)) != 0) {
            // 受静音影响，使用系统设置的类型
            mPlayer.setAudioStreamType(silentModeStreams);
        } else {
            // 不受静音影响，使用闹钟音频流
            mPlayer.setAudioStreamType(AudioManager.STREAM_ALARM);
        }
        // 4. 设置数据源并播放
        try {
            mPlayer.setDataSource(this, url);  // 设置铃声URI
            mPlayer.prepare();                  // 准备播放
            mPlayer.setLooping(true);           // 循环播放
            mPlayer.start();                    // 开始播放
        } catch (IllegalArgumentException e) {
            // URI格式错误
            e.printStackTrace();
        } catch (SecurityException e) {
            // 权限不足
            e.printStackTrace();
        } catch (IllegalStateException e) {
            // 播放器状态错误
            e.printStackTrace();
        } catch (IOException e) {
            // IO错误，文件读取失败
            e.printStackTrace();
        }
    }
    // ======================= 提醒对话框 =======================
    /**
     * 显示操作对话框
     * 对话框内容：应用名称 + 便签摘要 + 操作按钮
     */
    private void showActionDialog() {
        // 1. 创建对话框构建器
        AlertDialog.Builder dialog = new AlertDialog.Builder(this);
        // 2. 设置对话框内容
        dialog.setTitle(R.string.app_name);   // 应用名称作为标题
        dialog.setMessage(mSnippet);          // 便签摘要作为内容
        // 3. 设置按钮
        // 确定按钮 - 关闭提醒
        dialog.setPositiveButton(R.string.notealert_ok, this);
        // 如果屏幕已亮，显示"进入"按钮（跳转到便签编辑）
        if (isScreenOn()) {
            dialog.setNegativeButton(R.string.notealert_enter, this);
        }
        // 4. 显示对话框并设置关闭监听
        dialog.show().setOnDismissListener(this);
    }
    // ======================= 对话框事件处理 =======================
    /**
     * 对话框按钮点击回调
     * 实现OnClickListener接口
     * @param dialog 被点击的对话框
     * @param which 被点击的按钮标识
     *             BUTTON_POSITIVE: 确定按钮
     *             BUTTON_NEGATIVE: 进入按钮（仅在屏幕亮时显示）
     *             BUTTON_NEUTRAL: 中立按钮（未使用）
     */
    public void onClick(DialogInterface dialog, int which) {
        switch (which) {
            case DialogInterface.BUTTON_NEGATIVE:
                // "进入"按钮：跳转到便签编辑界面
                Intent intent = new Intent(this, NoteEditActivity.class);
                intent.setAction(Intent.ACTION_VIEW);  // 查看动作
                intent.putExtra(Intent.EXTRA_UID, mNoteId);  // 传递便签ID
                startActivity(intent);
                break;
            default:
                // 其他按钮（确定按钮）不执行额外操作
                // 对话框关闭后会触发onDismiss，自动结束Activity
                break;
        }
    }
    /**
     * 对话框关闭回调
     * 实现OnDismissListener接口
     * 无论点击哪个按钮，对话框关闭时都会执行
     * @param dialog 被关闭的对话框
     */
    public void onDismiss(DialogInterface dialog) {
        // 停止播放提示音
        stopAlarmSound();
        // 结束Activity
        finish();
    }
    // ======================= 资源清理 =======================
    /**
     * 停止播放提示音
     * 释放MediaPlayer资源
     */
    private void stopAlarmSound() {
        if (mPlayer != null) {
            mPlayer.stop();      // 停止播放
            mPlayer.release();   // 释放资源
            mPlayer = null;      // 置空引用，帮助GC
        }
    }
 }
--- a/java/net/micode/notes/ui/AlarmInitReceiver.java
+++ b/java/net/micode/notes/ui/AlarmInitReceiver.java
@ -1,143 +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.
 */
 // AlarmInitReceiver.java - 闹钟初始化广播接收器
 // 主要功能：在设备启动后重新注册所有未触发的便签闹钟提醒
 package net.micode.notes.ui;
 // ======================= 导入区域 =======================
 // Android闹钟相关
 import android.app.AlarmManager;       // 闹钟管理器，用于设置系统闹钟
 import android.app.PendingIntent;      // 待定意图，用于延迟执行
 // Android广播相关
 import android.content.BroadcastReceiver; // 广播接收器基类
 import android.content.ContentUris;    // URI工具，用于构建带ID的URI
 import android.content.Context;        // 上下文
 import android.content.Intent;         // 意图
 // Android数据库相关
 import android.database.Cursor;        // 数据库查询结果游标
 // 应用内部数据模型
 import net.micode.notes.data.Notes;            // Notes主类
 import net.micode.notes.data.Notes.NoteColumns; // 便签表列定义
 // ======================= 闹钟初始化广播接收器 =======================
 /**
 * AlarmInitReceiver - 闹钟初始化广播接收器
 * 继承自BroadcastReceiver，接收系统启动完成广播
 * 主要功能：设备重启后重新注册所有未来的闹钟提醒
 *
 * AndroidManifest.xml中注册：
 * <receiver android:name=".ui.AlarmInitReceiver" android:exported="true">
 *     <intent-filter>
 *         <action android:name="android.intent.action.BOOT_COMPLETED" />
 *     </intent-filter>
 * </receiver>
 */
 public class AlarmInitReceiver extends BroadcastReceiver {
    // ======================= 数据库查询配置 =======================
    /**
     * 查询投影数组 - 指定从数据库查询哪些字段
     * 优化查询性能，只获取需要的字段
     */
    private static final String [] PROJECTION = new String [] {
            NoteColumns.ID,            // 0 - 便签ID，用于构建PendingIntent
            NoteColumns.ALERTED_DATE   // 1 - 提醒时间，用于设置闹钟
    };
    // 字段索引常量 - 提高代码可读性和维护性
    private static final int COLUMN_ID                = 0;  // ID字段索引
    private static final int COLUMN_ALERTED_DATE      = 1;  // 提醒时间字段索引
    // ======================= 广播接收回调方法 =======================
    /**
     * onReceive - 广播接收回调方法
     * 当接收到android.intent.action.BOOT_COMPLETED广播时调用
     * 执行流程：
     * 1. 查询所有未来需要提醒的便签
     * 2. 为每个便签重新注册系统闹钟
     * 3. 关闭数据库游标
     *
     * @param context 广播接收器的上下文
     * @param intent 接收到的广播意图（包含BOOT_COMPLETED动作）
     */
    @Override
    public void onReceive(Context context, Intent intent) {
        // 1. 获取当前时间戳，用于查询未来提醒
        long currentDate = System.currentTimeMillis();
        // 2. 查询数据库，获取所有未来需要提醒的便签
        // 查询条件：提醒时间 > 当前时间 且 类型为普通便签
        Cursor c = context.getContentResolver().query(
                Notes.CONTENT_NOTE_URI,      // 便签表内容URI
                PROJECTION,                  // 查询字段：ID和提醒时间
                NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE,
                new String[] { String.valueOf(currentDate) },  // 查询参数：当前时间
                null);                       // 排序方式（null表示默认）
        // 3. 检查查询结果是否有效
        if (c != null) {
            // 4. 遍历查询结果，为每个便签设置闹钟
            if (c.moveToFirst()) {
                do {
                    // 4.1 获取便签的提醒时间
                    long alertDate = c.getLong(COLUMN_ALERTED_DATE);
                    // 4.2 创建AlarmReceiver的Intent
                    // AlarmReceiver是实际处理闹钟触发的广播接收器
                    Intent sender = new Intent(context, AlarmReceiver.class);
                    // 4.3 设置Intent的数据URI，包含便签ID
                    // URI格式：content://micode_notes/note/{noteId}
                    sender.setData(ContentUris.withAppendedId(
                            Notes.CONTENT_NOTE_URI,
                            c.getLong(COLUMN_ID)
                    ));
                    // 4.4 创建PendingIntent
                    // 参数说明：
                    // - context: 上下文
                    // - requestCode: 请求码（0表示默认）
                    // - intent: 要执行的Intent
                    // - flags: 标志位（0表示默认）
                    PendingIntent pendingIntent = PendingIntent.getBroadcast(
                            context,
                            0,
                            sender,
                            0
                    );
                    // 4.5 获取系统闹钟管理器
                    AlarmManager alarmManager = (AlarmManager) context
                            .getSystemService(Context.ALARM_SERVICE);
                    // 4.6 设置系统闹钟
                    // 参数说明：
                    // - AlarmManager.RTC_WAKEUP: 使用实时时钟，触发时唤醒设备
                    // - alertDate: 触发时间（毫秒时间戳）
                    // - pendingIntent: 触发时执行的PendingIntent
                    alarmManager.set(AlarmManager.RTC_WAKEUP, alertDate, pendingIntent);
                } while (c.moveToNext());  // 继续处理下一个便签
            }
            // 5. 关闭游标，释放数据库资源
            c.close();
        }
    }
 }
--- a/java/net/micode/notes/ui/AlarmReceiver.java
+++ b/java/net/micode/notes/ui/AlarmReceiver.java
@ -1,77 +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.
 */
 // AlarmReceiver.java - 闹钟触发广播接收器
 // 主要功能：接收系统闹钟触发广播，启动闹钟提醒Activity
 package net.micode.notes.ui;
 // ======================= 导入区域 =======================
 // Android广播相关
 import android.content.BroadcastReceiver;  // 广播接收器基类
 import android.content.Context;            // 上下文
 import android.content.Intent;             // 意图，用于启动Activity
 // ======================= 闹钟触发广播接收器 =======================
 /**
 * AlarmReceiver - 闹钟触发广播接收器
 * 继承自BroadcastReceiver，接收系统闹钟触发的广播
 * 主要功能：将系统闹钟广播转换为启动AlarmAlertActivity
 *
 * AndroidManifest.xml中注册：
 * <receiver
 *     android:name="net.micode.notes.ui.AlarmReceiver"
 *     android:process=":remote" />
 *
 * 独立进程运行，确保即使主进程被杀死也能接收闹钟
 */
 public class AlarmReceiver extends BroadcastReceiver {
    /**
     * onReceive - 广播接收回调方法
     * 当系统闹钟触发时被调用
     * 执行流程：
     * 1. 修改Intent的目标类为AlarmAlertActivity
     * 2. 添加NEW_TASK标志
     * 3. 启动闹钟提醒Activity
     *
     * 工作流程：
     * 系统闹钟触发 → AlarmReceiver接收 → 启动AlarmAlertActivity → 显示提醒
     *
     * @param context 广播接收器的上下文
     * @param intent 接收到的广播意图，包含以下信息：
     *               - Data URI: content://micode_notes/note/{noteId} (来自AlarmInitReceiver的设置)
     *               - 可能包含其他闹钟相关数据
     */
    @Override
    public void onReceive(Context context, Intent intent) {
        // 1. 修改Intent的目标Activity类
        // 原始Intent来自AlarmInitReceiver设置的PendingIntent
        // 这里将目标类改为AlarmAlertActivity
        intent.setClass(context, AlarmAlertActivity.class);
        // 2. 添加NEW_TASK标志
        // 原因：从广播接收器启动Activity必须在独立任务栈中
        // FLAG_ACTIVITY_NEW_TASK作用：
        // - 创建新的任务栈
        // - 允许从非Activity上下文（BroadcastReceiver）启动Activity
        // - 避免与现有Activity的任务栈冲突
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        // 3. 启动闹钟提醒Activity
        // 启动后，AlarmAlertActivity将显示全屏提醒对话框
        context.startActivity(intent);
    }
 }
--- a/java/net/micode/notes/ui/DateTimePicker.java
+++ b/java/net/micode/notes/ui/DateTimePicker.java
@ -1,680 +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.
 */
 // DateTimePicker.java - 日期时间选择器自定义控件
 // 主要功能：提供便签闹钟设置所需的日期和时间选择界面
 package net.micode.notes.ui;
 // ======================= 导入区域 =======================
 // Java日期时间相关
 import java.text.DateFormatSymbols;  // 日期格式符号，用于获取AM/PM字符串
 import java.util.Calendar;           // 日历类，用于日期时间计算
 // 应用内部资源
 import net.micode.notes.R;           // 资源文件R类
 // Android相关
 import android.content.Context;      // 上下文
 import android.text.format.DateFormat;  // 日期格式化工具
 import android.view.View;            // 视图基类
 import android.widget.FrameLayout;   // 帧布局容器
 import android.widget.NumberPicker;  // 数字选择器控件
 // ======================= 日期时间选择器控件 =======================
 /**
 * DateTimePicker - 自定义日期时间选择器
 * 继承自FrameLayout，包含多个NumberPicker控件
 * 功能：日期（近7天）、小时、分钟、AM/PM选择
 * 支持12小时制和24小时制两种显示模式
 */
 public class DateTimePicker extends FrameLayout {
    // ======================= 常量定义 =======================
    /** 默认启用状态 - 控件初始化时的默认可用状态 */
    private static final boolean DEFAULT_ENABLE_STATE = true;
    /** 半天的小时数 - 12小时制使用 */
    private static final int HOURS_IN_HALF_DAY = 12;
    /** 全天的小时数 - 24小时制使用 */
    private static final int HOURS_IN_ALL_DAY = 24;
    /** 一周的天数 - 日期选择器显示的天数范围 */
    private static final int DAYS_IN_ALL_WEEK = 7;
    // 日期选择器范围常量
    private static final int DATE_SPINNER_MIN_VAL = 0;          // 日期选择器最小值
    private static final int DATE_SPINNER_MAX_VAL = DAYS_IN_ALL_WEEK - 1; // 日期选择器最大值
    // 24小时制小时选择器范围常量
    private static final int HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW = 0;  // 24小时制最小值
    private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23; // 24小时制最大值
    // 12小时制小时选择器范围常量
    private static final int HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW = 1;  // 12小时制最小值
    private static final int HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW = 12; // 12小时制最大值
    // 分钟选择器范围常量
    private static final int MINUT_SPINNER_MIN_VAL = 0;  // 分钟最小值
    private static final int MINUT_SPINNER_MAX_VAL = 59; // 分钟最大值
    // AM/PM选择器范围常量
    private static final int AMPM_SPINNER_MIN_VAL = 0;  // AM索引
    private static final int AMPM_SPINNER_MAX_VAL = 1;  // PM索引
    // ======================= 控件成员变量 =======================
    /** 日期选择器 - 显示近7天的日期 */
    private final NumberPicker mDateSpinner;
    /** 小时选择器 - 显示小时（12/24小时制） */
    private final NumberPicker mHourSpinner;
    /** 分钟选择器 - 显示分钟 */
    private final NumberPicker mMinuteSpinner;
    /** AM/PM选择器 - 显示上午/下午（12小时制时显示） */
    private final NumberPicker mAmPmSpinner;
    /** 当前日期时间 - Calendar对象保存当前选择的时间 */
    private Calendar mDate;
    /** 日期显示值数组 - 存储近7天的格式化字符串 */
    private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];
    // ======================= 状态标志 =======================
    /** AM/PM标志 - true: 上午; false: 下午 */
    private boolean mIsAm;
    /** 24小时制标志 - true: 24小时制; false: 12小时制 */
    private boolean mIs24HourView;
    /** 启用状态标志 - 控件是否可用 */
    private boolean mIsEnabled = DEFAULT_ENABLE_STATE;
    /** 初始化标志 - 防止初始化时触发回调 */
    private boolean mInitialising;
    // ======================= 回调监听器 =======================
    /** 日期时间变化监听器 - 当选择的时间发生变化时回调 */
    private OnDateTimeChangedListener mOnDateTimeChangedListener;
    // ======================= 日期选择器值变化监听器 =======================
    /**
     * 日期选择器值变化监听器
     * 当用户滚动日期选择器时触发
     */
    private NumberPicker.OnValueChangeListener mOnDateChangedListener =
            new NumberPicker.OnValueChangeListener() {
                @Override
                public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
                    // 计算日期变化量（新值-旧值），并更新Calendar
                    mDate.add(Calendar.DAY_OF_YEAR, newVal - oldVal);
                    // 更新日期控件显示
                    updateDateControl();
                    // 触发日期时间变化回调
                    onDateTimeChanged();
                }
            };
    // ======================= 小时选择器值变化监听器 =======================
    /**
     * 小时选择器值变化监听器
     * 处理小时变化时的特殊逻辑（跨天、AM/PM切换）
     */
    private NumberPicker.OnValueChangeListener mOnHourChangedListener =
            new NumberPicker.OnValueChangeListener() {
                @Override
                public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
                    boolean isDateChanged = false;  // 日期是否变化标志
                    Calendar cal = Calendar.getInstance();  // 临时Calendar用于计算
                    if (!mIs24HourView) {
                        // ===== 12小时制处理逻辑 =====
                        // 情况1：PM 11点 -> PM 12点，需要加1天
                        if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) {
                            cal.setTimeInMillis(mDate.getTimeInMillis());
                            cal.add(Calendar.DAY_OF_YEAR, 1);
                            isDateChanged = true;
                        }
                        // 情况2：AM 12点 -> AM 11点，需要减1天
                        else if (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
                            cal.setTimeInMillis(mDate.getTimeInMillis());
                            cal.add(Calendar.DAY_OF_YEAR, -1);
                            isDateChanged = true;
                        }
                        // 处理AM/PM切换（12点前后切换时）
                        if (oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY ||
                                oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
                            mIsAm = !mIsAm;  // 切换AM/PM标志
                            updateAmPmControl();  // 更新AM/PM控件
                        }
                    } else {
                        // ===== 24小时制处理逻辑 =====
                        // 情况1：23点 -> 0点，需要加1天
                        if (oldVal == HOURS_IN_ALL_DAY - 1 && newVal == 0) {
                            cal.setTimeInMillis(mDate.getTimeInMillis());
                            cal.add(Calendar.DAY_OF_YEAR, 1);
                            isDateChanged = true;
                        }
                        // 情况2：0点 -> 23点，需要减1天
                        else if (oldVal == 0 && newVal == HOURS_IN_ALL_DAY - 1) {
                            cal.setTimeInMillis(mDate.getTimeInMillis());
                            cal.add(Calendar.DAY_OF_YEAR, -1);
                            isDateChanged = true;
                        }
                    }
                    // 计算实际的小时值（12小时制需要转换）
                    int newHour = mHourSpinner.getValue() % HOURS_IN_HALF_DAY + (mIsAm ? 0 : HOURS_IN_HALF_DAY);
                    mDate.set(Calendar.HOUR_OF_DAY, newHour);
                    // 触发回调
                    onDateTimeChanged();
                    // 如果日期发生变化，更新年月日
                    if (isDateChanged) {
                        setCurrentYear(cal.get(Calendar.YEAR));
                        setCurrentMonth(cal.get(Calendar.MONTH));
                        setCurrentDay(cal.get(Calendar.DAY_OF_MONTH));
                    }
                }
            };
    // ======================= 分钟选择器值变化监听器 =======================
    /**
     * 分钟选择器值变化监听器
     * 处理分钟滚动时的特殊逻辑（59分到0分，0分到59分）
     */
    private NumberPicker.OnValueChangeListener mOnMinuteChangedListener =
            new NumberPicker.OnValueChangeListener() {
                @Override
                public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
                    int minValue = mMinuteSpinner.getMinValue();  // 分钟最小值（0）
                    int maxValue = mMinuteSpinner.getMaxValue();  // 分钟最大值（59）
                    int offset = 0;  // 小时偏移量
                    // 情况1：59分 -> 0分，小时加1
                    if (oldVal == maxValue && newVal == minValue) {
                        offset += 1;
                    }
                    // 情况2：0分 -> 59分，小时减1
                    else if (oldVal == minValue && newVal == maxValue) {
                        offset -= 1;
                    }
                    // 如果需要调整小时
                    if (offset != 0) {
                        mDate.add(Calendar.HOUR_OF_DAY, offset);  // 调整小时
                        mHourSpinner.setValue(getCurrentHour());  // 更新小时选择器
                        updateDateControl();  // 更新日期控件
                        // 更新AM/PM状态
                        int newHour = getCurrentHourOfDay();
                        if (newHour >= HOURS_IN_HALF_DAY) {
                            mIsAm = false;
                            updateAmPmControl();
                        } else {
                            mIsAm = true;
                            updateAmPmControl();
                        }
                    }
                    // 设置新的分钟值
                    mDate.set(Calendar.MINUTE, newVal);
                    onDateTimeChanged();  // 触发回调
                }
            };
    // ======================= AM/PM选择器值变化监听器 =======================
    /**
     * AM/PM选择器值变化监听器
     * 处理上午/下午切换时的逻辑
     */
    private NumberPicker.OnValueChangeListener mOnAmPmChangedListener =
            new NumberPicker.OnValueChangeListener() {
                @Override
                public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
                    mIsAm = !mIsAm;  // 切换AM/PM标志
                    // 根据AM/PM调整小时
                    if (mIsAm) {
                        mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY);  // PM转AM，减12小时
                    } else {
                        mDate.add(Calendar.HOUR_OF_DAY, HOURS_IN_HALF_DAY);   // AM转PM，加12小时
                    }
                    updateAmPmControl();  // 更新AM/PM控件
                    onDateTimeChanged();  // 触发回调
                }
            };
    // ======================= 回调接口定义 =======================
    /**
     * OnDateTimeChangedListener - 日期时间变化监听器接口
     * 当用户修改日期时间时回调
     */
    public interface OnDateTimeChangedListener {
        /**
         * 日期时间变化回调方法
         * @param view 触发变化的DateTimePicker控件
         * @param year 年
         * @param month 月（0-11）
         * @param dayOfMonth 日（1-31）
         * @param hourOfDay 小时（0-23）
         * @param minute 分钟（0-59）
         */
        void onDateTimeChanged(DateTimePicker view, int year, int month,
                               int dayOfMonth, int hourOfDay, int minute);
    }
    // ======================= 构造函数 =======================
    /**
     * 构造函数1 - 使用当前时间
     * @param context 上下文
     */
    public DateTimePicker(Context context) {
        this(context, System.currentTimeMillis());  // 调用构造函数2
    }
    /**
     * 构造函数2 - 指定时间戳
     * @param context 上下文
     * @param date 时间戳（毫秒）
     */
    public DateTimePicker(Context context, long date) {
        this(context, date, DateFormat.is24HourFormat(context));  // 调用构造函数3
    }
    /**
     * 构造函数3 - 完整参数
     * @param context 上下文
     * @param date 时间戳（毫秒）
     * @param is24HourView 是否24小时制
     */
    public DateTimePicker(Context context, long date, boolean is24HourView) {
        super(context);
        // 1. 初始化成员变量
        mDate = Calendar.getInstance();  // 创建Calendar实例
        mInitialising = true;  // 标记为初始化中
        mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY;  // 根据当前时间判断AM/PM
        // 2. 加载布局文件
        inflate(context, R.layout.datetime_picker, this);
        // 3. 初始化日期选择器
        mDateSpinner = (NumberPicker) findViewById(R.id.date);
        mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL);
        mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL);
        mDateSpinner.setOnValueChangedListener(mOnDateChangedListener);
        // 4. 初始化小时选择器
        mHourSpinner = (NumberPicker) findViewById(R.id.hour);
        mHourSpinner.setOnValueChangedListener(mOnHourChangedListener);
        // 5. 初始化分钟选择器
        mMinuteSpinner =  (NumberPicker) findViewById(R.id.minute);
        mMinuteSpinner.setMinValue(MINUT_SPINNER_MIN_VAL);
        mMinuteSpinner.setMaxValue(MINUT_SPINNER_MAX_VAL);
        mMinuteSpinner.setOnLongPressUpdateInterval(100);  // 长按滚动间隔100ms
        mMinuteSpinner.setOnValueChangedListener(mOnMinuteChangedListener);
        // 6. 初始化AM/PM选择器
        String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings();  // 获取AM/PM本地化字符串
        mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm);
        mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL);
        mAmPmSpinner.setMaxValue(AMPM_SPINNER_MAX_VAL);
        mAmPmSpinner.setDisplayedValues(stringsForAmPm);  // 设置显示值
        mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener);
        // 7. 更新控件初始状态
        updateDateControl();  // 更新日期显示
        updateHourControl();  // 更新小时范围
        updateAmPmControl();  // 更新AM/PM显示
        // 8. 设置24小时制模式
        set24HourView(is24HourView);
        // 9. 设置当前时间
        setCurrentDate(date);
        // 10. 设置启用状态
        setEnabled(isEnabled());
        // 11. 初始化完成
        mInitialising = false;
    }
    // ======================= 控件状态管理 =======================
    /**
     * 设置控件启用状态
     * @param enabled true: 启用; false: 禁用
     */
    @Override
    public void setEnabled(boolean enabled) {
        if (mIsEnabled == enabled) {
            return;  // 状态未变化，直接返回
        }
        super.setEnabled(enabled);
        // 设置所有子控件的启用状态
        mDateSpinner.setEnabled(enabled);
        mMinuteSpinner.setEnabled(enabled);
        mHourSpinner.setEnabled(enabled);
        mAmPmSpinner.setEnabled(enabled);
        mIsEnabled = enabled;
    }
    /**
     * 获取控件启用状态
     * @return true: 启用; false: 禁用
     */
    @Override
    public boolean isEnabled() {
        return mIsEnabled;
    }
    // ======================= 获取当前日期时间 =======================
    /**
     * 获取当前日期的时间戳
     * @return 时间戳（毫秒）
     */
    public long getCurrentDateInTimeMillis() {
        return mDate.getTimeInMillis();
    }
    /**
     * 设置当前日期（时间戳版本）
     * @param date 时间戳（毫秒）
     */
    public void setCurrentDate(long date) {
        Calendar cal = Calendar.getInstance();
        cal.setTimeInMillis(date);
        setCurrentDate(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH),
                cal.get(Calendar.DAY_OF_MONTH), cal.get(Calendar.HOUR_OF_DAY),
                cal.get(Calendar.MINUTE));
    }
    /**
     * 设置当前日期（详细参数版本）
     * @param year 年
     * @param month 月（0-11）
     * @param dayOfMonth 日（1-31）
     * @param hourOfDay 小时（0-23）
     * @param minute 分钟（0-59）
     */
    public void setCurrentDate(int year, int month,
                               int dayOfMonth, int hourOfDay, int minute) {
        setCurrentYear(year);
        setCurrentMonth(month);
        setCurrentDay(dayOfMonth);
        setCurrentHour(hourOfDay);
        setCurrentMinute(minute);
    }
    // ======================= 年、月、日操作方法 =======================
    /**
     * 获取当前年
     * @return 年
     */
    public int getCurrentYear() {
        return mDate.get(Calendar.YEAR);
    }
    /**
     * 设置当前年
     * @param year 年
     */
    public void setCurrentYear(int year) {
        if (!mInitialising && year == getCurrentYear()) {
            return;  // 初始化时或值未变化时不触发回调
        }
        mDate.set(Calendar.YEAR, year);
        updateDateControl();  // 更新日期显示
        onDateTimeChanged();  // 触发回调
    }
    /**
     * 获取当前月
     * @return 月（0-11）
     */
    public int getCurrentMonth() {
        return mDate.get(Calendar.MONTH);
    }
    /**
     * 设置当前月
     * @param month 月（0-11）
     */
    public void setCurrentMonth(int month) {
        if (!mInitialising && month == getCurrentMonth()) {
            return;
        }
        mDate.set(Calendar.MONTH, month);
        updateDateControl();
        onDateTimeChanged();
    }
    /**
     * 获取当前日
     * @return 日（1-31）
     */
    public int getCurrentDay() {
        return mDate.get(Calendar.DAY_OF_MONTH);
    }
    /**
     * 设置当前日
     * @param dayOfMonth 日（1-31）
     */
    public void setCurrentDay(int dayOfMonth) {
        if (!mInitialising && dayOfMonth == getCurrentDay()) {
            return;
        }
        mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
        updateDateControl();
        onDateTimeChanged();
    }
    // ======================= 小时操作方法 =======================
    /**
     * 获取当前小时（24小时制）
     * @return 小时（0-23）
     */
    public int getCurrentHourOfDay() {
        return mDate.get(Calendar.HOUR_OF_DAY);
    }
    /**
     * 获取当前小时（根据12/24小时制转换）
     * @return 小时（12小时制：1-12；24小时制：0-23）
     */
    private int getCurrentHour() {
        if (mIs24HourView){
            return getCurrentHourOfDay();  // 24小时制直接返回
        } else {
            int hour = getCurrentHourOfDay();
            if (hour > HOURS_IN_HALF_DAY) {
                return hour - HOURS_IN_HALF_DAY;  // PM：13-23转换为1-11
            } else {
                return hour == 0 ? HOURS_IN_HALF_DAY : hour;  // AM：0点转为12点
            }
        }
    }
    /**
     * 设置当前小时（24小时制）
     * @param hourOfDay 小时（0-23）
     */
    public void setCurrentHour(int hourOfDay) {
        if (!mInitialising && hourOfDay == getCurrentHourOfDay()) {
            return;
        }
        mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
        // 12小时制时需要额外处理AM/PM
        if (!mIs24HourView) {
            if (hourOfDay >= HOURS_IN_HALF_DAY) {
                mIsAm = false;  // PM
                if (hourOfDay > HOURS_IN_HALF_DAY) {
                    hourOfDay -= HOURS_IN_HALF_DAY;  // 13-23转换为1-11
                }
            } else {
                mIsAm = true;  // AM
                if (hourOfDay == 0) {
                    hourOfDay = HOURS_IN_HALF_DAY;  // 0点转为12点
                }
            }
            updateAmPmControl();  // 更新AM/PM控件
        }
        mHourSpinner.setValue(hourOfDay);  // 设置小时选择器值
        onDateTimeChanged();  // 触发回调
    }
    // ======================= 分钟操作方法 =======================
    /**
     * 获取当前分钟
     * @return 分钟（0-59）
     */
    public int getCurrentMinute() {
        return mDate.get(Calendar.MINUTE);
    }
    /**
     * 设置当前分钟
     * @param minute 分钟（0-59）
     */
    public void setCurrentMinute(int minute) {
        if (!mInitialising && minute == getCurrentMinute()) {
            return;
        }
        mMinuteSpinner.setValue(minute);  // 设置分钟选择器
        mDate.set(Calendar.MINUTE, minute);
        onDateTimeChanged();
    }
    // ======================= 24小时制管理 =======================
    /**
     * 判断是否为24小时制
     * @return true: 24小时制; false: 12小时制
     */
    public boolean is24HourView () {
        return mIs24HourView;
    }
    /**
     * 设置24小时制模式
     * @param is24HourView true: 24小时制; false: 12小时制
     */
    public void set24HourView(boolean is24HourView) {
        if (mIs24HourView == is24HourView) {
            return;  // 模式未变化
        }
        mIs24HourView = is24HourView;
        // 显示/隐藏AM/PM选择器
        mAmPmSpinner.setVisibility(is24HourView ? View.GONE : View.VISIBLE);
        // 获取当前小时并更新控件
        int hour = getCurrentHourOfDay();
        updateHourControl();  // 更新小时选择器范围
        setCurrentHour(hour);  // 重新设置小时
        updateAmPmControl();  // 更新AM/PM状态
    }
    // ======================= 控件更新方法 =======================
    /**
     * 更新日期控件显示
     * 计算并显示当前日期前后3天的日期
     */
    private void updateDateControl() {
        Calendar cal = Calendar.getInstance();
        cal.setTimeInMillis(mDate.getTimeInMillis());
        // 从当前日期向前推4天（-3-1 = -4）
        cal.add(Calendar.DAY_OF_YEAR, -DAYS_IN_ALL_WEEK / 2 - 1);
        mDateSpinner.setDisplayedValues(null);  // 清空显示值
        // 生成7天的日期显示字符串
        for (int i = 0; i < DAYS_IN_ALL_WEEK; ++i) {
            cal.add(Calendar.DAY_OF_YEAR, 1);
            mDateDisplayValues[i] = (String) DateFormat.format("MM.dd EEEE", cal);
        }
        mDateSpinner.setDisplayedValues(mDateDisplayValues);  // 设置显示值
        mDateSpinner.setValue(DAYS_IN_ALL_WEEK / 2);  // 设置当前为中间位置
        mDateSpinner.invalidate();  // 重绘控件
    }
    /**
     * 更新AM/PM控件
     * 根据24小时制标志显示/隐藏，根据AM/PM标志设置值
     */
    private void updateAmPmControl() {
        if (mIs24HourView) {
            mAmPmSpinner.setVisibility(View.GONE);  // 24小时制隐藏
        } else {
            int index = mIsAm ? Calendar.AM : Calendar.PM;  // AM=0, PM=1
            mAmPmSpinner.setValue(index);  // 设置AM/PM选择器值
            mAmPmSpinner.setVisibility(View.VISIBLE);  // 12小时制显示
        }
    }
    /**
     * 更新小时控件范围
     * 根据12/24小时制设置不同的数值范围
     */
    private void updateHourControl() {
        if (mIs24HourView) {
            mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW);
            mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW);
        } else {
            mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW);
            mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW);
        }
    }
    // ======================= 回调管理 =======================
    /**
     * 设置日期时间变化监听器
     * @param callback 监听器实例
     */
    public void setOnDateTimeChangedListener(OnDateTimeChangedListener callback) {
        mOnDateTimeChangedListener = callback;
    }
    /**
     * 触发日期时间变化回调
     * 当日期时间发生变化时调用
     */
    private void onDateTimeChanged() {
        if (mOnDateTimeChangedListener != null) {
            mOnDateTimeChangedListener.onDateTimeChanged(this, getCurrentYear(),
                    getCurrentMonth(), getCurrentDay(), getCurrentHourOfDay(),
                    getCurrentMinute());
        }
    }
 }
--- a/java/net/micode/notes/ui/DateTimePickerDialog.java
+++ b/java/net/micode/notes/ui/DateTimePickerDialog.java
@ -1,202 +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.
 */
 // DateTimePickerDialog.java - 日期时间选择对话框
 // 主要功能：封装DateTimePicker控件，提供完整的日期时间选择对话框界面
 package net.micode.notes.ui;
 // ======================= 导入区域 =======================
 // Java日期时间
 import java.util.Calendar;  // 日历类，用于日期时间计算
 // 应用内部资源
 import net.micode.notes.R;  // 资源文件R类
 // 应用内部组件
 import net.micode.notes.ui.DateTimePicker;  // 日期时间选择器控件
 import net.micode.notes.ui.DateTimePicker.OnDateTimeChangedListener;  // 日期时间变化监听器
 // Android对话框相关
 import android.app.AlertDialog;  // 警告对话框基类
 import android.content.Context;  // 上下文
 import android.content.DialogInterface;  // 对话框接口
 import android.content.DialogInterface.OnClickListener;  // 对话框点击监听器
 // Android日期时间相关
 import android.text.format.DateFormat;  // 日期格式化工具
 import android.text.format.DateUtils;   // 日期工具类
 // ======================= 日期时间选择对话框 =======================
 /**
 * DateTimePickerDialog - 日期时间选择对话框
 * 继承自AlertDialog，包含DateTimePicker控件
 * 功能：提供日期时间选择界面，包含确定/取消按钮
 * 实现接口：OnClickListener（处理确定按钮点击）
 */
 public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
    // ======================= 成员变量 =======================
    /** 当前选择的日期时间 - Calendar对象存储用户选择的时间 */
    private Calendar mDate = Calendar.getInstance();
    /** 24小时制标志 - true: 24小时制; false: 12小时制 */
    private boolean mIs24HourView;
    /** 日期时间设置回调接口 - 当用户点击确定时回调 */
    private OnDateTimeSetListener mOnDateTimeSetListener;
    /** 日期时间选择器控件 - 核心选择组件 */
    private DateTimePicker mDateTimePicker;
    // ======================= 回调接口定义 =======================
    /**
     * OnDateTimeSetListener - 日期时间设置监听器接口
     * 当用户完成日期时间选择并点击确定按钮时回调
     */
    public interface OnDateTimeSetListener {
        /**
         * 日期时间设置回调方法
         * @param dialog 触发回调的对话框实例
         * @param date 用户选择的日期时间（时间戳，毫秒）
         */
        void OnDateTimeSet(AlertDialog dialog, long date);
    }
    // ======================= 构造函数 =======================
    /**
     * 构造函数
     * 初始化日期时间选择对话框
     * @param context 上下文
     * @param date 初始日期时间（时间戳，毫秒）
     */
    public DateTimePickerDialog(Context context, long date) {
        super(context);
        // 1. 创建日期时间选择器控件
        mDateTimePicker = new DateTimePicker(context);
        // 2. 将选择器控件设置为对话框的内容视图
        setView(mDateTimePicker);
        // 3. 设置日期时间变化监听器
        mDateTimePicker.setOnDateTimeChangedListener(new OnDateTimeChangedListener() {
            /**
             * 日期时间变化回调
             * 当用户在DateTimePicker上修改日期时间时触发
             * @param view 触发变化的DateTimePicker控件
             * @param year 年
             * @param month 月（0-11）
             * @param dayOfMonth 日（1-31）
             * @param hourOfDay 小时（0-23）
             * @param minute 分钟（0-59）
             */
            public void onDateTimeChanged(DateTimePicker view, int year, int month,
                                          int dayOfMonth, int hourOfDay, int minute) {
                // 更新内部Calendar对象
                mDate.set(Calendar.YEAR, year);
                mDate.set(Calendar.MONTH, month);
                mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
                mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
                mDate.set(Calendar.MINUTE, minute);
                // 更新对话框标题显示
                updateTitle(mDate.getTimeInMillis());
            }
        });
        // 4. 设置初始日期时间
        mDate.setTimeInMillis(date);  // 设置时间戳
        mDate.set(Calendar.SECOND, 0);  // 秒数设为0（只精确到分钟）
        // 5. 更新日期时间选择器控件的当前值
        mDateTimePicker.setCurrentDate(mDate.getTimeInMillis());
        // 6. 设置对话框按钮
        // 确定按钮 - 点击后触发回调
        setButton(context.getString(R.string.datetime_dialog_ok), this);
        // 取消按钮 - 点击后直接关闭对话框
        setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener)null);
        // 7. 设置24小时制模式（根据系统设置）
        set24HourView(DateFormat.is24HourFormat(this.getContext()));
        // 8. 更新对话框标题显示
        updateTitle(mDate.getTimeInMillis());
    }
    // ======================= 24小时制设置 =======================
    /**
     * 设置24小时制显示模式
     * @param is24HourView true: 24小时制; false: 12小时制
     */
    public void set24HourView(boolean is24HourView) {
        mIs24HourView = is24HourView;
    }
    // ======================= 回调监听器设置 =======================
    /**
     * 设置日期时间设置监听器
     * @param callBack 监听器实例
     */
    public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) {
        mOnDateTimeSetListener = callBack;
    }
    // ======================= 对话框标题更新 =======================
    /**
     * 更新对话框标题
     * 根据当前选择的日期时间格式化显示
     * @param date 日期时间（时间戳，毫秒）
     */
    private void updateTitle(long date) {
        // 设置日期时间显示格式标志
        int flag =
                DateUtils.FORMAT_SHOW_YEAR |  // 显示年份
                        DateUtils.FORMAT_SHOW_DATE |  // 显示日期
                        DateUtils.FORMAT_SHOW_TIME;   // 显示时间
        // 根据24小时制标志添加相应格式
        flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_24HOUR;
        // 注意：这里代码有bug，应该是 FORMAT_24HOUR 或 FORMAT_12HOUR
        // 格式化日期时间并设置为对话框标题
        setTitle(DateUtils.formatDateTime(this.getContext(), date, flag));
    }
    // ======================= 按钮点击处理 =======================
    /**
     * 对话框按钮点击回调
     * 实现OnClickListener接口
     * 当用户点击确定按钮时触发
     * @param arg0 被点击的对话框
     * @param arg1 被点击的按钮标识
     *             DialogInterface.BUTTON_POSITIVE: 确定按钮
     *             DialogInterface.BUTTON_NEGATIVE: 取消按钮
     *             DialogInterface.BUTTON_NEUTRAL: 中立按钮
     */
    public void onClick(DialogInterface arg0, int arg1) {
        // 只有确定按钮会触发此回调
        if (mOnDateTimeSetListener != null) {
            // 触发日期时间设置回调
            mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis());
        }
    }
 }
--- a/java/net/micode/notes/ui/DropdownMenu.java
+++ b/java/net/micode/notes/ui/DropdownMenu.java
@ -1,172 +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.
 */
 // DropdownMenu.java - 下拉菜单包装类
 // 主要功能：将Button和PopupMenu组合封装，提供简洁的下拉菜单实现
 package net.micode.notes.ui;
 // ======================= 导入区域 =======================
 // Android上下文
 import android.content.Context;  // 上下文
 // Android菜单相关
 import android.view.Menu;        // 菜单接口
 import android.view.MenuItem;    // 菜单项
 // Android视图相关
 import android.view.View;        // 视图基类
 import android.view.View.OnClickListener;  // 点击监听器
 // Android控件
 import android.widget.Button;    // 按钮控件
 import android.widget.PopupMenu; // 弹出菜单控件
 import android.widget.PopupMenu.OnMenuItemClickListener;  // 弹出菜单项点击监听器
 // 应用内部资源
 import net.micode.notes.R;       // 资源文件R类
 // ======================= 下拉菜单包装类 =======================
 /**
 * DropdownMenu - 下拉菜单包装类
 * 功能：将Button控件与PopupMenu组合，创建下拉菜单效果
 * 使用方式：将Button转换为下拉菜单按钮，点击显示菜单
 * 设计模式：外观模式（Facade），简化PopupMenu的使用
 */
 public class DropdownMenu {
    // ======================= 成员变量 =======================
    /** 按钮控件 - 显示为下拉菜单的触发器按钮 */
    private Button mButton;
    /** 弹出菜单 - 实际的PopupMenu控件，包含菜单项 */
    private PopupMenu mPopupMenu;
    /** 菜单对象 - 对应PopupMenu中的菜单，用于查找菜单项 */
    private Menu mMenu;
    // ======================= 构造函数 =======================
    /**
     * 构造函数
     * 初始化下拉菜单，将普通Button转换为下拉菜单按钮
     *
     * 工作流程：
     * 1. 保存Button引用
     * 2. 设置Button背景为下拉箭头图标
     * 3. 创建PopupMenu并关联到Button
     * 4. 获取Menu对象
     * 5. 加载菜单布局
     * 6. 设置Button点击事件显示菜单
     *
     * @param context 上下文，用于创建PopupMenu
     * @param button 按钮控件，将转换为下拉菜单触发器
     * @param menuId 菜单资源ID，对应res/menu目录下的XML文件
     *
     * 示例：
     * new DropdownMenu(context, button, R.menu.note_operation_menu);
     */
    public DropdownMenu(Context context, Button button, int menuId) {
        // 1. 保存Button引用
        mButton = button;
        // 2. 设置Button背景为下拉箭头图标
        // R.drawable.dropdown_icon: 下拉箭头图标
        // 使Button看起来像下拉菜单按钮
        mButton.setBackgroundResource(R.drawable.dropdown_icon);
        // 3. 创建PopupMenu并关联到Button
        // 第二个参数是锚点视图，菜单会显示在Button下方
        mPopupMenu = new PopupMenu(context, mButton);
        // 4. 获取PopupMenu的Menu对象
        mMenu = mPopupMenu.getMenu();
        // 5. 加载菜单布局文件
        // 从XML资源文件加载菜单项到Menu对象
        mPopupMenu.getMenuInflater().inflate(menuId, mMenu);
        // 6. 设置Button点击事件
        mButton.setOnClickListener(new OnClickListener() {
            /**
             * Button点击事件处理
             * 点击Button时显示弹出菜单
             * @param v 被点击的Button视图
             */
            public void onClick(View v) {
                mPopupMenu.show();  // 显示弹出菜单
            }
        });
    }
    // ======================= 菜单项点击监听器设置 =======================
    /**
     * 设置下拉菜单项点击监听器
     * 当用户点击菜单项时触发
     *
     * @param listener 菜单项点击监听器
     *                 实现OnMenuItemClickListener接口
     *
     * 使用示例：
     * dropdownMenu.setOnDropdownMenuItemClickListener(new OnMenuItemClickListener() {
     *     @Override
     *     public boolean onMenuItemClick(MenuItem item) {
     *         // 处理菜单项点击
     *         return true;
     *     }
     * });
     */
    public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {
        // 安全检查：确保PopupMenu已创建
        if (mPopupMenu != null) {
            mPopupMenu.setOnMenuItemClickListener(listener);
        }
    }
    // ======================= 菜单项查找 =======================
    /**
     * 根据ID查找菜单项
     * 用于动态修改菜单项属性（如启用状态、标题、图标等）
     *
     * @param id 菜单项资源ID
     * @return 找到的MenuItem对象，未找到返回null
     *
     * 使用示例：
     * MenuItem item = dropdownMenu.findItem(R.id.menu_delete);
     * if (item != null) {
     *     item.setEnabled(false);  // 禁用删除菜单项
     * }
     */
    public MenuItem findItem(int id) {
        return mMenu.findItem(id);
    }
    // ======================= 按钮标题设置 =======================
    /**
     * 设置按钮标题文本
     * 用于动态更新下拉按钮显示的文字
     *
     * @param title 按钮标题文本
     *
     * 使用示例：
     * dropdownMenu.setTitle("操作菜单");
     * 或
     * dropdownMenu.setTitle(getString(R.string.menu_title));
     */
    public void setTitle(CharSequence title) {
        mButton.setText(title);
    }
 }
--- a/java/net/micode/notes/ui/FoldersListAdapter.java
+++ b/java/net/micode/notes/ui/FoldersListAdapter.java
@ -1,183 +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.
 */
 // FoldersListAdapter.java - 文件夹列表适配器
 // 主要功能：将数据库中的文件夹数据适配到ListView显示
 package net.micode.notes.ui;
 // ======================= 导入区域 =======================
 // Android基础
 import android.content.Context;  // 上下文
 // Android数据库
 import android.database.Cursor;  // 数据库查询结果游标
 // Android视图
 import android.view.View;        // 视图基类
 import android.view.ViewGroup;   // 视图容器
 // Android适配器
 import android.widget.CursorAdapter;  // 游标适配器基类
 // Android布局
 import android.widget.LinearLayout;   // 线性布局
 // Android控件
 import android.widget.TextView;       // 文本视图
 // 应用内部资源
 import net.micode.notes.R;            // 资源文件R类
 // 应用数据模型
 import net.micode.notes.data.Notes;   // Notes主类
 import net.micode.notes.data.Notes.NoteColumns;  // 便签表列定义
 // ======================= 文件夹列表适配器 =======================
 /**
 * FoldersListAdapter - 文件夹列表适配器
 * 继承自CursorAdapter，用于在ListView中显示文件夹列表
 * 功能：从数据库查询文件夹数据，绑定到列表项视图
 * 使用场景：便签移动对话框、文件夹选择界面
 */
 public class FoldersListAdapter extends CursorAdapter {
    // ======================= 数据库查询配置 =======================
    /**
     * 查询投影数组 - 指定从数据库查询哪些字段
     * 优化查询，只获取必要的数据
     */
    public static final String [] PROJECTION = {
            NoteColumns.ID,       // 0 - 文件夹ID
            NoteColumns.SNIPPET   // 1 - 文件夹名称（存储在SNIPPET字段中）
    };
    // 字段索引常量 - 提高代码可读性
    public static final int ID_COLUMN   = 0;  // ID字段索引
    public static final int NAME_COLUMN = 1;  // 名称字段索引
    // ======================= 构造函数 =======================
    /**
     * 构造函数
     * 调用父类CursorAdapter的构造函数
     * @param context 上下文
     * @param c 数据库游标，包含文件夹数据
     */
    public FoldersListAdapter(Context context, Cursor c) {
        super(context, c);
        // TODO: 可在此处添加额外初始化代码
    }
    // ======================= 适配器核心方法 =======================
    /**
     * 创建新视图
     * 当ListView需要新的列表项视图时调用
     * @param context 上下文
     * @param cursor 当前位置的数据库游标
     * @param parent 父视图容器（ListView）
     * @return 新创建的列表项视图
     */
    @Override
    public View newView(Context context, Cursor cursor, ViewGroup parent) {
        // 创建并返回FolderListItem对象
        return new FolderListItem(context);
    }
    /**
     * 绑定数据到视图
     * 将指定位置的数据库数据绑定到列表项视图
     * @param view 要绑定数据的视图
     * @param context 上下文
     * @param cursor 当前位置的数据库游标
     */
    @Override
    public void bindView(View view, Context context, Cursor cursor) {
        // 安全检查：确保视图是FolderListItem类型
        if (view instanceof FolderListItem) {
            // 获取文件夹名称
            String folderName = null;
            // 特殊处理：如果是根文件夹（ID_ROOT_FOLDER），使用预设名称
            if (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) {
                // 根文件夹显示为"主文件夹"
                folderName = context.getString(R.string.menu_move_parent_folder);
            } else {
                // 普通文件夹使用数据库中的名称
                folderName = cursor.getString(NAME_COLUMN);
            }
            // 调用FolderListItem的bind方法设置名称
            ((FolderListItem) view).bind(folderName);
        }
    }
    // ======================= 辅助方法 =======================
    /**
     * 根据位置获取文件夹名称
     * 不依赖视图，直接从适配器数据中获取
     * 用于需要获取名称但不显示视图的场景
     *
     * @param context 上下文，用于获取根文件夹的本地化名称
     * @param position 列表中的位置
     * @return 文件夹名称
     */
    public String getFolderName(Context context, int position) {
        // 获取指定位置的Cursor对象
        Cursor cursor = (Cursor) getItem(position);
        // 与bindView中相同的逻辑处理文件夹名称
        if (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) {
            return context.getString(R.string.menu_move_parent_folder);
        } else {
            return cursor.getString(NAME_COLUMN);
        }
    }
    // ======================= 内部类：文件夹列表项视图 =======================
    /**
     * FolderListItem - 文件夹列表项内部类
     * 继承自LinearLayout，表示单个文件夹项的视图
     * 职责：管理列表项布局和控件
     */
    private class FolderListItem extends LinearLayout {
        /** 文件夹名称文本视图 */
        private TextView mName;
        /**
         * 构造函数
         * 初始化列表项视图
         * @param context 上下文
         */
        public FolderListItem(Context context) {
            super(context);
            // 1. 加载布局文件
            // R.layout.folder_list_item: 列表项布局
            // 第三个参数true: 将布局添加到当前视图
            inflate(context, R.layout.folder_list_item, this);
            // 2. 查找并保存TextView引用
            mName = (TextView) findViewById(R.id.tv_folder_name);
        }
        /**
         * 绑定数据
         * 设置文件夹名称到TextView
         * @param name 文件夹名称
         */
        public void bind(String name) {
            mName.setText(name);
        }
    }
 }
--- a/java/net/micode/notes/ui/NoteEditText.java
+++ b/java/net/micode/notes/ui/NoteEditText.java
@ -1,457 +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.
 */
 // NoteEditText.java - 自定义便签编辑文本控件
 // 主要功能：扩展EditText，支持清单模式的特殊按键处理、超链接识别和上下文菜单
 package net.micode.notes.ui;
 // ======================= 导入区域 =======================
 // Android基础
 import android.content.Context;      // 上下文
 import android.content.ContentResolver; // 内容解析器
 import android.graphics.Rect;        // 矩形区域
 // Android文本处理
 import android.text.Layout;          // 文本布局
 import android.text.Selection;       // 文本选择
 import android.text.Spanned;         // 可设置样式的文本
 import android.text.TextUtils;       // 文本工具
 import android.text.style.URLSpan;   // URL超链接样式
 import android.util.AttributeSet;    // 属性集
 import android.util.Log;             // 日志工具
 // Android菜单
 import android.view.ContextMenu;     // 上下文菜单
 import android.view.KeyEvent;        // 按键事件
 import android.view.MenuItem;        // 菜单项
 import android.view.MenuItem.OnMenuItemClickListener;  // 菜单项点击监听
 import android.view.MotionEvent;     // 触摸事件
 // Android文本处理
 import android.text.InputType;               // 输入类型
 import android.text.Spannable;               // 可设置样式的文本
 import android.text.SpannableStringBuilder;   // 可设置样式的字符串构建器
 import android.text.style.ImageSpan;         // 图片样式
 // Android输入法
 import android.view.inputmethod.EditorInfo;  // 输入法编辑器信息
 // Android控件
 import android.widget.EditText;              // 编辑文本控件基类
 import android.widget.ImageView;             // 图片视图
 // Android图形
 import android.graphics.Bitmap;               // 位图
 import android.graphics.BitmapFactory;        // 位图工厂
 import android.graphics.drawable.Drawable;    // 可绘制对象
 // Android网络
 import android.net.Uri;                      // URI工具
 // 应用内部资源
 import net.micode.notes.R;           // 资源文件R类
 // Java集合
 import java.util.HashMap;            // 哈希映射
 import java.util.Map;                // 映射接口
 // ======================= 便签编辑文本控件 =======================
 /**
 * NoteEditText - 自定义便签编辑文本控件
 * 继承自EditText，增强功能用于便签的清单模式编辑
 * 核心功能：
 * 1. 清单模式按键处理（回车新增项，删除删除项）
 * 2. 超链接识别和上下文菜单
 * 3. 焦点变化通知
 * 4. 触摸精确定位
 */
 public class NoteEditText extends EditText {
    // ======================= 常量定义 =======================
    private static final String TAG = "NoteEditText";  // 日志标签
    /** 当前项索引 - 在清单模式中标识第几个列表项 */
    private int mIndex;
    /** 删除前的选择起始位置 - 用于判断是否在开头删除 */
    private int mSelectionStartBeforeDelete;
    // 超链接协议常量
    private static final String SCHEME_TEL = "tel:";     // 电话协议
    private static final String SCHEME_HTTP = "http:";   // HTTP协议
    private static final String SCHEME_EMAIL = "mailto:"; // 邮件协议
    /**
     * 协议动作资源映射
     * 键：协议前缀，值：对应的菜单文本资源ID
     * 用于为不同类型的超链接显示不同的上下文菜单
     */
    private static final Map<String, Integer> sSchemaActionResMap = new HashMap<String, Integer>();
    static {
        sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel);    // 电话链接
        sSchemaActionResMap.put(SCHEME_HTTP, R.string.note_link_web);   // 网页链接
        sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email); // 邮件链接
    }
    // ======================= 文本变化监听器接口 =======================
    /**
     * OnTextViewChangeListener - 文本视图变化监听器接口
     * 由NoteEditActivity实现，处理清单模式的特殊按键行为
     */
    public interface OnTextViewChangeListener {
        /**
         * 删除当前编辑文本
         * 当在文本开头按下删除键且文本为空时调用
         * @param index 当前项的索引
         * @param text 当前文本内容
         */
        void onEditTextDelete(int index, String text);
        /**
         * 添加新的编辑文本
         * 当按下回车键时调用
         * @param index 新项的索引
         * @param text 要添加到新项的文本（当前光标后的内容）
         */
        void onEditTextEnter(int index, String text);
        /**
         * 文本变化通知
         * 用于显示/隐藏列表项的操作控件
         * @param index 当前项的索引
         * @param hasText 是否有文本内容
         */
        void onTextChange(int index, boolean hasText);
    }
    /** 文本变化监听器实例 */
    private OnTextViewChangeListener mOnTextViewChangeListener;
    // ======================= 构造函数 =======================
    /**
     * 构造函数1 - 简化版本
     * @param context 上下文
     */
    public NoteEditText(Context context) {
        this(context, null);
        mIndex = 0;  // 默认索引为0
    }
    /**
     * 构造函数2 - 完整属性
     * @param context 上下文
     * @param attrs 属性集
     */
    public NoteEditText(Context context, AttributeSet attrs) {
        this(context, attrs, android.R.attr.editTextStyle);
    }
    /**
     * 构造函数3 - 包含样式
     * @param context 上下文
     * @param attrs 属性集
     * @param defStyle 默认样式
     */
    public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        // 确保输入法支持中文输入
        setInputType(getInputType() | InputType.TYPE_TEXT_FLAG_MULTI_LINE | InputType.TYPE_TEXT_FLAG_CAP_SENTENCES);
        setImeOptions(EditorInfo.IME_ACTION_NONE);
    }
    /**
     * 从URI加载图片
     * @param uri 图片URI
     * @return 加载的Bitmap对象
     */
    private Bitmap loadImageFromUri(Uri uri) {
        try {
            ContentResolver resolver = getContext().getContentResolver();
            Bitmap bitmap = BitmapFactory.decodeStream(resolver.openInputStream(uri));
            if (bitmap != null) {
                // 调整图片大小以适应编辑框
                int maxWidth = getMeasuredWidth() - getPaddingLeft() - getPaddingRight();
                if (bitmap.getWidth() > maxWidth) {
                    float scale = (float) maxWidth / bitmap.getWidth();
                    int newHeight = (int) (bitmap.getHeight() * scale);
                    bitmap = Bitmap.createScaledBitmap(bitmap, maxWidth, newHeight, true);
                }
            }
            return bitmap;
        } catch (Exception e) {
            Log.e(TAG, "Failed to load image from URI: " + uri, e);
            return null;
        }
    }
    /**
     * 解析文本中的[IMAGE:uri]标签并替换为图片
     * @param text 包含图片标签的文本
     * @return 处理后的SpannableStringBuilder，包含图片
     */
    private SpannableStringBuilder parseImageTags(CharSequence text) {
        SpannableStringBuilder builder = new SpannableStringBuilder(text);
        String content = text.toString();
        int startIndex = 0;
        while (true) {
            startIndex = content.indexOf("[IMAGE:", startIndex);
            if (startIndex == -1) break;
            int endIndex = content.indexOf("]", startIndex);
            if (endIndex == -1) break;
            String imageTag = content.substring(startIndex, endIndex + 1);
            String imageUriStr = imageTag.substring(7, imageTag.length() - 1); // 去掉[IMAGE:和]
            try {
                Uri imageUri = Uri.parse(imageUriStr);
                Bitmap bitmap = loadImageFromUri(imageUri);
                if (bitmap != null) {
                    // 创建一个占位符文本，用于放置图片
                    String placeholder = "[图片]";
                    int placeholderLength = placeholder.length();
                    // 替换图片标签为占位符
                    builder.replace(startIndex, endIndex + 1, placeholder);
                    // 创建ImageSpan并添加到占位符位置
                    ImageSpan imageSpan = new ImageSpan(getContext(), bitmap);
                    builder.setSpan(imageSpan, startIndex, startIndex + placeholderLength, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
                    // 更新content和startIndex以继续处理
                    content = builder.toString();
                    startIndex += placeholderLength;
                } else {
                    startIndex = endIndex + 1;
                }
            } catch (Exception e) {
                Log.e(TAG, "Failed to parse image URI: " + imageUriStr, e);
                startIndex = endIndex + 1;
            }
        }
        return builder;
    }
    /**
     * 重写setText方法，解析图片标签并显示图片
     */
    @Override
    public void setText(CharSequence text, BufferType type) {
        if (text != null) {
            SpannableStringBuilder builder = parseImageTags(text);
            super.setText(builder, BufferType.SPANNABLE);
        } else {
            super.setText(text, type);
        }
    }
    // ======================= 设置方法 =======================
    /**
     * 设置项索引
     * 在清单模式中标识当前是第几个列表项
     * @param index 索引值
     */
    public void setIndex(int index) {
        mIndex = index;
    }
    /**
     * 设置文本变化监听器
     * @param listener 监听器实例
     */
    public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
        mOnTextViewChangeListener = listener;
    }
    // ======================= 触摸事件处理 =======================
    /**
     * 触摸事件处理
     * 重写以实现精确的触摸位置选择
     * @param event 触摸事件
     * @return true: 已处理; false: 未处理
     */
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                // 计算触摸点在文本中的精确位置
                int x = (int) event.getX();
                int y = (int) event.getY();
                x -= getTotalPaddingLeft();   // 减去内边距
                y -= getTotalPaddingTop();
                x += getScrollX();            // 加上滚动偏移
                y += getScrollY();
                // 获取布局并计算字符偏移
                Layout layout = getLayout();
                int line = layout.getLineForVertical(y);
                int off = layout.getOffsetForHorizontal(line, x);
                // 设置选择位置
                Selection.setSelection(getText(), off);
                break;
        }
        return super.onTouchEvent(event);
    }
    // ======================= 按键按下事件 =======================
    /**
     * 按键按下事件处理
     * 拦截特殊按键进行预处理
     * @param keyCode 按键代码
     * @param event 按键事件
     * @return true: 已处理; false: 未处理
     */
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        switch (keyCode) {
            case KeyEvent.KEYCODE_ENTER:
                // 拦截回车键，在onKeyUp中处理
                if (mOnTextViewChangeListener != null) {
                    return false;  // 返回false让系统继续处理
                }
                break;
            case KeyEvent.KEYCODE_DEL:
                // 记录删除前的选择位置
                mSelectionStartBeforeDelete = getSelectionStart();
                break;
            default:
                break;
        }
        return super.onKeyDown(keyCode, event);
    }
    // ======================= 按键抬起事件 =======================
    /**
     * 按键抬起事件处理
     * 处理清单模式的特殊按键逻辑
     * @param keyCode 按键代码
     * @param event 按键事件
     * @return true: 已处理; false: 未处理
     */
    @Override
    public boolean onKeyUp(int keyCode, KeyEvent event) {
        switch(keyCode) {
            case KeyEvent.KEYCODE_DEL:
                // 删除键处理
                if (mOnTextViewChangeListener != null) {
                    // 条件：在文本开头删除 且 不是第一项
                    if (0 == mSelectionStartBeforeDelete && mIndex != 0) {
                        // 触发删除回调
                        mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString());
                        return true;  // 已处理
                    }
                } else {
                    Log.d(TAG, "OnTextViewChangeListener was not seted");
                }
                break;
            case KeyEvent.KEYCODE_ENTER:
                // 回车键处理
                if (mOnTextViewChangeListener != null) {
                    int selectionStart = getSelectionStart();
                    // 分割文本：光标前保留，光标后移到新项
                    String text = getText().subSequence(selectionStart, length()).toString();
                    setText(getText().subSequence(0, selectionStart));
                    // 触发新增回调
                    mOnTextViewChangeListener.onEditTextEnter(mIndex + 1, text);
                } else {
                    Log.d(TAG, "OnTextViewChangeListener was not seted");
                }
                break;
            default:
                break;
        }
        return super.onKeyUp(keyCode, event);
    }
    // ======================= 焦点变化处理 =======================
    /**
     * 焦点变化处理
     * 当焦点变化时通知监听器文本状态
     * @param focused 是否获得焦点
     * @param direction 焦点方向
     * @param previouslyFocusedRect 之前获得焦点的矩形区域
     */
    @Override
    protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
        if (mOnTextViewChangeListener != null) {
            // 失去焦点且文本为空时，通知隐藏操作控件
            if (!focused && TextUtils.isEmpty(getText())) {
                mOnTextViewChangeListener.onTextChange(mIndex, false);
            } else {
                // 其他情况通知显示操作控件
                mOnTextViewChangeListener.onTextChange(mIndex, true);
            }
        }
        super.onFocusChanged(focused, direction, previouslyFocusedRect);
    }
    // ======================= 上下文菜单创建 =======================
    /**
     * 创建上下文菜单
     * 检测选中的文本是否包含超链接，并为不同类型的链接创建对应的菜单项
     * @param menu 上下文菜单
     */
    @Override
    protected void onCreateContextMenu(ContextMenu menu) {
        // 检查文本是否包含样式（可能包含超链接）
        if (getText() instanceof Spanned) {
            int selStart = getSelectionStart();
            int selEnd = getSelectionEnd();
            // 计算选择范围
            int min = Math.min(selStart, selEnd);
            int max = Math.max(selStart, selEnd);
            // 获取选择范围内的超链接
            final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class);
            // 只处理单个超链接的情况
            if (urls.length == 1) {
                int defaultResId = 0;
                // 根据URL协议确定菜单文本
                for(String schema: sSchemaActionResMap.keySet()) {
                    if(urls[0].getURL().indexOf(schema) >= 0) {
                        defaultResId = sSchemaActionResMap.get(schema);
                        break;
                    }
                }
                // 未知协议使用默认文本
                if (defaultResId == 0) {
                    defaultResId = R.string.note_link_other;
                }
                // 添加菜单项
                menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener(
                        new OnMenuItemClickListener() {
                            public boolean onMenuItemClick(MenuItem item) {
                                // 触发超链接点击
                                urls[0].onClick(NoteEditText.this);
                                return true;
                            }
                        });
            }
        }
        super.onCreateContextMenu(menu);
    }
 }
--- a/java/net/micode/notes/ui/NoteItemData.java
+++ b/java/net/micode/notes/ui/NoteItemData.java
@ -1,421 +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.
 */
 // NoteItemData.java - 便签项数据模型类
 // 主要功能：封装便签列表项的数据，提供便捷的访问方法和位置判断逻辑
 package net.micode.notes.ui;
 // ======================= 导入区域 =======================
 // Android基础
 import android.content.Context;  // 上下文
 import android.database.Cursor;  // 数据库查询结果游标
 import android.text.TextUtils;   // 文本工具
 // 应用内部工具
 import net.micode.notes.data.Contact;  // 联系人工具类
 import net.micode.notes.data.Notes;    // Notes主类
 import net.micode.notes.data.Notes.NoteColumns;  // 便签表列定义
 import net.micode.notes.tool.DataUtils;  // 数据工具
 // ======================= 便签项数据模型 =======================
 /**
 * NoteItemData - 便签项数据模型类
 * 功能：从数据库Cursor解析便签数据，封装为对象模型
 * 用途：在便签列表适配器中表示单个便签项的数据
 * 特点：包含位置判断逻辑，用于列表项背景选择
 */
 public class NoteItemData {
    // ======================= 数据库查询配置 =======================
    /**
     * 查询投影数组 - 指定从数据库查询哪些字段
     * 包含便签表的所有重要字段
     */
    static final String [] PROJECTION = new String [] {
            NoteColumns.ID,               // 0 - 便签ID
            NoteColumns.ALERTED_DATE,     // 1 - 提醒时间
            NoteColumns.BG_COLOR_ID,      // 2 - 背景颜色ID
            NoteColumns.CREATED_DATE,     // 3 - 创建时间
            NoteColumns.HAS_ATTACHMENT,   // 4 - 是否有附件
            NoteColumns.MODIFIED_DATE,    // 5 - 修改时间
            NoteColumns.NOTES_COUNT,      // 6 - 包含的便签数（文件夹用）
            NoteColumns.PARENT_ID,        // 7 - 父文件夹ID
            NoteColumns.SNIPPET,          // 8 - 便签摘要
            NoteColumns.TYPE,             // 9 - 便签类型
            NoteColumns.WIDGET_ID,        // 10 - 小部件ID
            NoteColumns.WIDGET_TYPE,      // 11 - 小部件类型
            NoteColumns.PINNED            // 12 - 是否置顶
    };
    // ======================= 字段索引常量 =======================
    // 使用常量而非魔法数字，提高代码可读性
    private static final int ID_COLUMN                    = 0;  // ID字段索引
    private static final int ALERTED_DATE_COLUMN          = 1;  // 提醒时间字段索引
    private static final int BG_COLOR_ID_COLUMN           = 2;  // 背景颜色字段索引
    private static final int CREATED_DATE_COLUMN          = 3;  // 创建时间字段索引
    private static final int HAS_ATTACHMENT_COLUMN        = 4;  // 附件字段索引
    private static final int MODIFIED_DATE_COLUMN         = 5;  // 修改时间字段索引
    private static final int NOTES_COUNT_COLUMN           = 6;  // 便签数字段索引
    private static final int PARENT_ID_COLUMN             = 7;  // 父ID字段索引
    private static final int SNIPPET_COLUMN               = 8;  // 摘要字段索引
    private static final int TYPE_COLUMN                  = 9;  // 类型字段索引
    private static final int WIDGET_ID_COLUMN             = 10; // 小部件ID字段索引
    private static final int WIDGET_TYPE_COLUMN           = 11; // 小部件类型字段索引
    private static final int PINNED_COLUMN                = 12; // 是否置顶字段索引
    // ======================= 数据成员 =======================
    // 基本数据字段
    private long mId;                // 便签ID
    private long mAlertDate;         // 提醒时间戳
    private int mBgColorId;          // 背景颜色索引
    private long mCreatedDate;       // 创建时间戳
    private boolean mHasAttachment;  // 是否有附件
    private long mModifiedDate;      // 修改时间戳
    private int mNotesCount;         // 包含的便签数（文件夹）
    private long mParentId;          // 父文件夹ID
    private String mSnippet;         // 便签摘要
    private int mType;               // 便签类型
    private int mWidgetId;           // 小部件ID
    private int mWidgetType;         // 小部件类型
    private boolean mPinned;         // 是否置顶
    // 通话记录相关
    private String mName;            // 联系人姓名
    private String mPhoneNumber;     // 电话号码
    // 位置状态标志
    private boolean mIsLastItem;               // 是否是列表最后一项
    private boolean mIsFirstItem;              // 是否是列表第一项
    private boolean mIsOnlyOneItem;            // 是否是唯一一项
    private boolean mIsOneNoteFollowingFolder; // 是否是文件夹后的唯一便签
    private boolean mIsMultiNotesFollowingFolder; // 是否是文件夹后的多个便签之一
    // ======================= 构造函数 =======================
    /**
     * 构造函数
     * 从Cursor解析数据并初始化对象
     * 执行流程：
     * 1. 从Cursor读取所有字段
     * 2. 清理清单标记
     * 3. 处理通话记录
     * 4. 检查位置状态
     *
     * @param context 上下文，用于联系人查询
     * @param cursor 数据库游标，必须包含PROJECTION指定的字段
     */
    public NoteItemData(Context context, Cursor cursor) {
        // 1. 读取基本字段
        mId = cursor.getLong(ID_COLUMN);
        mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN);
        mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN);
        mCreatedDate = cursor.getLong(CREATED_DATE_COLUMN);
        mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0) ? true : false;
        mModifiedDate = cursor.getLong(MODIFIED_DATE_COLUMN);
        mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN);
        mParentId = cursor.getLong(PARENT_ID_COLUMN);
        mSnippet = cursor.getString(SNIPPET_COLUMN);
        mType = cursor.getInt(TYPE_COLUMN);
        mWidgetId = cursor.getInt(WIDGET_ID_COLUMN);
        mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN);
        mPinned = (cursor.getInt(PINNED_COLUMN) > 0) ? true : false;
        // 2. 清理摘要中的清单标记
        // 移除已勾选(√)和未勾选(□)标记，只显示纯文本
        mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(
                NoteEditActivity.TAG_UNCHECKED, "");
        // 3. 处理通话记录
        mPhoneNumber = "";  // 初始化电话号码
        if (mParentId == Notes.ID_CALL_RECORD_FOLDER) {
            // 从通话记录文件夹中获取电话号码
            mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId);
            if (!TextUtils.isEmpty(mPhoneNumber)) {
                // 根据电话号码查询联系人姓名
                mName = Contact.getContact(context, mPhoneNumber);
                if (mName == null) {
                    // 未找到联系人，使用电话号码作为显示名称
                    mName = mPhoneNumber;
                }
            }
        }
        // 确保名称不为null
        if (mName == null) {
            mName = "";
        }
        // 4. 检查位置状态
        checkPostion(cursor);
    }
    // ======================= 位置检查方法 =======================
    /**
     * 检查便签在列表中的位置状态
     * 用于确定列表项应使用的背景样式
     * 位置判断逻辑：
     * 1. 基本位置：首项、末项、唯一项
     * 2. 文件夹后位置：文件夹后的第一个便签、多个便签
     *
     * @param cursor 数据库游标，用于位置判断
     */
    private void checkPostion(Cursor cursor) {
        // 1. 基本位置判断
        mIsLastItem = cursor.isLast() ? true : false;   // 是否是最后一项
        mIsFirstItem = cursor.isFirst() ? true : false; // 是否是第一项
        mIsOnlyOneItem = (cursor.getCount() == 1);      // 是否是唯一一项
        // 初始化文件夹后位置标志
        mIsMultiNotesFollowingFolder = false;
        mIsOneNoteFollowingFolder = false;
        // 2. 判断是否是文件夹后的便签
        // 条件：当前是便签类型 且 不是第一项
        if (mType == Notes.TYPE_NOTE && !mIsFirstItem) {
            int position = cursor.getPosition();  // 获取当前游标位置
            // 向前移动游标检查前一项
            if (cursor.moveToPrevious()) {
                // 判断前一项是否是文件夹或系统文件夹
                if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER
                        || cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) {
                    // 判断后面是否还有更多项
                    if (cursor.getCount() > (position + 1)) {
                        // 文件夹后有多个便签
                        mIsMultiNotesFollowingFolder = true;
                    } else {
                        // 文件夹后只有一个便签
                        mIsOneNoteFollowingFolder = true;
                    }
                }
                // 移动回原位置
                if (!cursor.moveToNext()) {
                    throw new IllegalStateException("cursor move to previous but can't move back");
                }
            }
        }
    }
    // ======================= 位置状态获取方法 =======================
    /**
     * 是否是文件夹后的唯一便签
     * 用于选择列表项背景：list_{color}_single
     * @return true: 是文件夹后的唯一便签
     */
    public boolean isOneFollowingFolder() {
        return mIsOneNoteFollowingFolder;
    }
    /**
     * 是否是文件夹后的多个便签之一
     * 用于选择列表项背景：list_{color}_middle
     * @return true: 是文件夹后的多个便签之一
     */
    public boolean isMultiFollowingFolder() {
        return mIsMultiNotesFollowingFolder;
    }
    /**
     * 是否是列表最后一项
     * 用于选择列表项背景：list_{color}_down
     * @return true: 是最后一项
     */
    public boolean isLast() {
        return mIsLastItem;
    }
    /**
     * 获取通话记录联系人姓名
     * 用于通话记录便签的显示
     * @return 联系人姓名，无联系人时返回电话号码
     */
    public String getCallName() {
        return mName;
    }
    /**
     * 是否是列表第一项
     * 用于选择列表项背景：list_{color}_up
     * @return true: 是第一项
     */
    public boolean isFirst() {
        return mIsFirstItem;
    }
    /**
     * 是否是列表唯一项
     * 用于选择列表项背景：list_{color}_single
     * @return true: 是唯一项
     */
    public boolean isSingle() {
        return mIsOnlyOneItem;
    }
    // ======================= 基本属性获取方法 =======================
    /**
     * 获取便签ID
     * @return 便签ID
     */
    public long getId() {
        return mId;
    }
    /**
     * 获取提醒时间
     * @return 提醒时间戳，0表示无提醒
     */
    public long getAlertDate() {
        return mAlertDate;
    }
    /**
     * 获取创建时间
     * @return 创建时间戳
     */
    public long getCreatedDate() {
        return mCreatedDate;
    }
    /**
     * 是否包含附件
     * @return true: 包含附件
     */
    public boolean hasAttachment() {
        return mHasAttachment;
    }
    /**
     * 获取修改时间
     * @return 修改时间戳
     */
    public long getModifiedDate() {
        return mModifiedDate;
    }
    /**
     * 获取背景颜色ID
     * @return 背景颜色索引
     */
    public int getBgColorId() {
        return mBgColorId;
    }
    /**
     * 获取父文件夹ID
     * @return 父文件夹ID
     */
    public long getParentId() {
        return mParentId;
    }
    /**
     * 获取包含的便签数
     * 仅对文件夹类型有效
     * @return 便签数量
     */
    public int getNotesCount() {
        return mNotesCount;
    }
    /**
     * 获取文件夹ID（同getParentId）
     * 用于语义化访问
     * @return 文件夹ID
     */
    public long getFolderId () {
        return mParentId;
    }
    /**
     * 获取便签类型
     * @return 类型常量：TYPE_NOTE, TYPE_FOLDER, TYPE_SYSTEM
     */
    public int getType() {
        return mType;
    }
    /**
     * 获取小部件类型
     * @return 小部件类型：TYPE_WIDGET_INVALIDE, TYPE_WIDGET_2X, TYPE_WIDGET_4X
     */
    public int getWidgetType() {
        return mWidgetType;
    }
    /**
     * 获取便签是否置顶
     * @return true: 置顶, false: 不置顶
     */
    public boolean isPinned() {
        return mPinned;
    }
    /**
     * 获取小部件ID
     * @return 小部件ID
     */
    public int getWidgetId() {
        return mWidgetId;
    }
    /**
     * 获取便签摘要
     * 已清理清单标记
     * @return 便签摘要文本
     */
    public String getSnippet() {
        return mSnippet;
    }
    // ======================= 状态判断方法 =======================
    /**
     * 是否有提醒设置
     * @return true: 设置了提醒
     */
    public boolean hasAlert() {
        return (mAlertDate > 0);
    }
    /**
     * 是否是通话记录
     * 判断条件：在通话记录文件夹中 且 有电话号码
     * @return true: 是通话记录
     */
    public boolean isCallRecord() {
        return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber));
    }
    // ======================= 静态工具方法 =======================
    /**
     * 从Cursor获取便签类型
     * 静态方法，无需创建对象
     * @param cursor 数据库游标
     * @return 便签类型
     */
    public static int getNoteType(Cursor cursor) {
        return cursor.getInt(TYPE_COLUMN);
    }
 }
--- a/java/net/micode/notes/ui/NotesListAdapter.java
+++ b/java/net/micode/notes/ui/NotesListAdapter.java
@ -1,318 +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.
 */
 // NotesListAdapter.java - 便签列表适配器
 // 主要功能：为便签列表提供数据适配，支持多选模式和选中状态管理
 package net.micode.notes.ui;
 // ======================= 导入区域 =======================
 // Android基础
 import android.content.Context;      // 上下文
 import android.database.Cursor;      // 数据库查询结果游标
 import android.util.Log;             // 日志工具
 // Android视图
 import android.view.View;            // 视图基类
 import android.view.ViewGroup;       // 视图容器
 // Android适配器
 import android.widget.CursorAdapter; // 游标适配器基类
 // 应用数据模型
 import net.micode.notes.data.Notes;  // Notes主类
 // Java集合
 import java.util.Collection;         // 集合接口
 import java.util.HashMap;            // 哈希映射
 import java.util.HashSet;            // 哈希集合
 import java.util.Iterator;           // 迭代器
 // ======================= 便签列表适配器 =======================
 /**
 * NotesListAdapter - 便签列表适配器
 * 继承自CursorAdapter，用于在ListView中显示便签和文件夹列表
 * 核心功能：
 * 1. 便签列表数据绑定
 * 2. 多选模式支持
 * 3. 选中状态管理
 * 4. 小部件关联管理
 */
 public class NotesListAdapter extends CursorAdapter {
    // ======================= 常量定义 =======================
    private static final String TAG = "NotesListAdapter";  // 日志标签
    // ======================= 成员变量 =======================
    /** 上下文 */
    private Context mContext;
    /** 选中索引映射 - 存储列表位置与选中状态的映射 */
    private HashMap<Integer, Boolean> mSelectedIndex;
    /** 便签总数 - 不包括文件夹，用于全选判断 */
    private int mNotesCount;
    /** 选择模式标志 - true: 多选模式; false: 普通模式 */
    private boolean mChoiceMode;
    // ======================= 小部件属性内部类 =======================
    /**
     * AppWidgetAttribute - 应用小部件属性内部类
     * 用于存储便签关联的小部件信息
     */
    public static class AppWidgetAttribute {
        public int widgetId;    // 小部件ID
        public int widgetType;  // 小部件类型
    };
    // ======================= 构造函数 =======================
    /**
     * 构造函数
     * 初始化适配器
     * @param context 上下文
     */
    public NotesListAdapter(Context context) {
        super(context, null);  // 初始游标为null
        mSelectedIndex = new HashMap<Integer, Boolean>();
        mContext = context;
        mNotesCount = 0;  // 初始便签数为0
    }
    // ======================= 适配器核心方法 =======================
    /**
     * 创建新视图
     * 当ListView需要新的列表项视图时调用
     * @param context 上下文
     * @param cursor 当前位置的数据库游标
     * @param parent 父视图容器（ListView）
     * @return 新创建的NotesListItem视图
     */
    @Override
    public View newView(Context context, Cursor cursor, ViewGroup parent) {
        return new NotesListItem(context);
    }
    /**
     * 绑定数据到视图
     * 将指定位置的数据库数据绑定到列表项视图
     * @param view 要绑定数据的视图
     * @param context 上下文
     * @param cursor 当前位置的数据库游标
     */
    @Override
    public void bindView(View view, Context context, Cursor cursor) {
        if (view instanceof NotesListItem) {
            // 创建便签数据项
            NoteItemData itemData = new NoteItemData(context, cursor);
            // 绑定数据到列表项
            ((NotesListItem) view).bind(context, itemData, mChoiceMode,
                    isSelectedItem(cursor.getPosition()));
        }
    }
    // ======================= 选择模式管理 =======================
    /**
     * 设置项选中状态
     * 在多选模式下标记或取消标记项
     * @param position 列表位置
     * @param checked 选中状态（true: 选中; false: 取消选中）
     */
    public void setCheckedItem(final int position, final boolean checked) {
        mSelectedIndex.put(position, checked);
        notifyDataSetChanged();  // 通知视图更新
    }
    /**
     * 是否在选择模式中
     * @return true: 在多选模式中; false: 在普通模式中
     */
    public boolean isInChoiceMode() {
        return mChoiceMode;
    }
    /**
     * 设置选择模式
     * 进入或退出多选模式
     * @param mode 模式标志（true: 进入多选模式; false: 退出多选模式）
     */
    public void setChoiceMode(boolean mode) {
        mSelectedIndex.clear();  // 清除所有选中状态
        mChoiceMode = mode;
    }
    /**
     * 全选/取消全选
     * 选择或取消选择所有便签（不包括文件夹）
     * @param checked 全选状态（true: 全选; false: 取消全选）
     */
    public void selectAll(boolean checked) {
        Cursor cursor = getCursor();
        for (int i = 0; i < getCount(); i++) {
            if (cursor.moveToPosition(i)) {
                // 只选择便签类型，不选择文件夹
                if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) {
                    setCheckedItem(i, checked);
                }
            }
        }
    }
    // ======================= 选中项ID获取 =======================
    /**
     * 获取选中项的ID集合
     * 用于批量操作（删除、移动等）
     * @return 选中项的ID集合
     */
    public HashSet<Long> getSelectedItemIds() {
        HashSet<Long> itemSet = new HashSet<Long>();
        for (Integer position : mSelectedIndex.keySet()) {
            if (mSelectedIndex.get(position) == true) {
                Long id = getItemId(position);
                // 安全检查：排除根文件夹
                if (id == Notes.ID_ROOT_FOLDER) {
                    Log.d(TAG, "Wrong item id, should not happen");
                } else {
                    itemSet.add(id);
                }
            }
        }
        return itemSet;
    }
    // ======================= 选中项小部件获取 =======================
    /**
     * 获取选中项的小部件属性集合
     * 用于批量操作后更新关联的小部件
     * @return 小部件属性集合
     */
    public HashSet<AppWidgetAttribute> getSelectedWidget() {
        HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>();
        for (Integer position : mSelectedIndex.keySet()) {
            if (mSelectedIndex.get(position) == true) {
                Cursor c = (Cursor) getItem(position);
                if (c != null) {
                    AppWidgetAttribute widget = new AppWidgetAttribute();
                    NoteItemData item = new NoteItemData(mContext, c);
                    widget.widgetId = item.getWidgetId();
                    widget.widgetType = item.getWidgetType();
                    itemSet.add(widget);
                    /**
                     * 注意：不要在此处关闭游标
                     * 只有适配器可以关闭游标
                     */
                } else {
                    Log.e(TAG, "Invalid cursor");
                    return null;
                }
            }
        }
        return itemSet;
    }
    // ======================= 选中计数 =======================
    /**
     * 获取选中项数量
     * @return 选中项的数量
     */
    public int getSelectedCount() {
        Collection<Boolean> values = mSelectedIndex.values();
        if (null == values) {
            return 0;
        }
        Iterator<Boolean> iter = values.iterator();
        int count = 0;
        while (iter.hasNext()) {
            if (true == iter.next()) {
                count++;
            }
        }
        return count;
    }
    /**
     * 是否全选
     * 判断所有便签是否都被选中
     * @return true: 所有便签都被选中; false: 有便签未选中
     */
    public boolean isAllSelected() {
        int checkedCount = getSelectedCount();
        return (checkedCount != 0 && checkedCount == mNotesCount);
    }
    /**
     * 判断指定位置项是否被选中
     * @param position 列表位置
     * @return true: 被选中; false: 未选中
     */
    public boolean isSelectedItem(final int position) {
        if (null == mSelectedIndex.get(position)) {
            return false;
        }
        return mSelectedIndex.get(position);
    }
    // ======================= 数据变化处理 =======================
    /**
     * 内容变化回调
     * 当数据变化时重新计算便签数量
     */
    @Override
    protected void onContentChanged() {
        super.onContentChanged();
        calcNotesCount();  // 重新计算便签数
    }
    /**
     * 切换游标
     * 切换数据源时重新计算便签数量
     * @param cursor 新游标
     */
    @Override
    public void changeCursor(Cursor cursor) {
        super.changeCursor(cursor);
        calcNotesCount();  // 重新计算便签数
    }
    // ======================= 便签数量计算 =======================
    /**
     * 计算便签数量
     * 遍历游标，统计TYPE_NOTE类型的数量
     */
    private void calcNotesCount() {
        mNotesCount = 0;  // 重置计数
        for (int i = 0; i < getCount(); i++) {
            Cursor c = (Cursor) getItem(i);
            if (c != null) {
                // 只统计便签类型，不统计文件夹
                if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) {
                    mNotesCount++;
                }
            } else {
                Log.e(TAG, "Invalid cursor");
                return;
            }
        }
    }
 }
--- a/java/net/micode/notes/ui/NotesListItem.java
+++ b/java/net/micode/notes/ui/NotesListItem.java
@ -1,277 +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.
 */
 // NotesListItem.java - 便签列表项自定义视图
 // 主要功能：显示便签或文件夹列表项的完整视图，包括图标、文本、时间等
 package net.micode.notes.ui;
 // ======================= 导入区域 =======================
 // Android基础
 import android.content.Context;          // 上下文
 import android.text.format.DateUtils;    // 日期工具，用于相对时间显示
 // Android视图
 import android.view.View;                // 视图基类
 // Android控件
 import android.widget.CheckBox;          // 复选框
 import android.widget.ImageView;         // 图片视图
 import android.widget.LinearLayout;      // 线性布局容器
 import android.widget.TextView;          // 文本视图
 // 应用内部资源
 import net.micode.notes.R;               // 资源文件R类
 // 应用数据模型
 import net.micode.notes.data.Notes;      // Notes主类
 // 应用工具
 import net.micode.notes.tool.DataUtils;  // 数据工具
 // 应用资源解析
 import net.micode.notes.tool.ResourceParser.NoteItemBgResources;  // 列表项背景资源
 // ======================= 便签列表项视图 =======================
 /**
 * NotesListItem - 便签列表项自定义视图
 * 继承自LinearLayout，表示便签列表中的单个项
 * 功能：显示便签/文件夹的完整信息，包括标题、时间、图标、背景等
 * 职责：数据绑定、视图更新、背景选择
 */
 public class NotesListItem extends LinearLayout {
    // ======================= 成员变量 =======================
    /** 提醒图标 - 显示便签是否有提醒 */
    private ImageView mAlert;
    /** 置顶图标 - 显示便签是否置顶 */
    private ImageView mPinned;
    /** 标题文本 - 显示便签摘要或文件夹名称 */
    private TextView mTitle;
    /** 时间文本 - 显示修改时间（相对时间） */
    private TextView mTime;
    /** 联系人姓名文本 - 通话记录专用，显示联系人姓名 */
    private TextView mCallName;
    /** 便签数据项 - 当前项绑定的数据 */
    private NoteItemData mItemData;
    /** 复选框 - 多选模式下显示，用于选择操作 */
    private CheckBox mCheckBox;
    // ======================= 构造函数 =======================
    /**
     * 构造函数
     * 初始化列表项视图，加载布局并查找子视图
     * @param context 上下文
     */
    public NotesListItem(Context context) {
        super(context);
        // 1. 加载布局文件
        // R.layout.note_item: 列表项布局
        // 第三个参数true: 将布局添加到当前LinearLayout
        inflate(context, R.layout.note_item, this);
        // 2. 查找并保存子视图引用
        mAlert = (ImageView) findViewById(R.id.iv_alert_icon);
        mPinned = (ImageView) findViewById(R.id.iv_pinned_icon);
        mTitle = (TextView) findViewById(R.id.tv_title);
        mTime = (TextView) findViewById(R.id.tv_time);
        mCallName = (TextView) findViewById(R.id.tv_name);
        mCheckBox = (CheckBox) findViewById(android.R.id.checkbox);
    }
    // ======================= 数据绑定方法 =======================
    /**
     * 绑定数据到视图
     * 根据便签数据类型和状态更新所有UI元素
     * 绑定流程：
     * 1. 处理选择模式复选框
     * 2. 根据便签类型设置不同显示
     * 3. 更新标题、时间、图标
     * 4. 设置合适的背景
     *
     * @param context 上下文，用于获取资源和字符串
     * @param data 便签数据项
     * @param choiceMode 是否在选择模式中
     * @param checked 该项是否被选中
     */
    public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
        // 1. 处理选择模式复选框
        if (choiceMode && data.getType() == Notes.TYPE_NOTE) {
            // 选择模式且是便签类型：显示复选框
            mCheckBox.setVisibility(View.VISIBLE);
            mCheckBox.setChecked(checked);
        } else {
            // 非选择模式或非便签类型：隐藏复选框
            mCheckBox.setVisibility(View.GONE);
        }
        // 保存数据引用
        mItemData = data;
        // 2. 根据便签类型设置不同显示
        if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
            // 情况1：通话记录文件夹
            bindCallRecordFolder(context, data);
        } else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
            // 情况2：通话记录文件夹中的便签
            bindCallRecordNote(context, data);
        } else {
            // 情况3：普通文件夹或便签
            bindNormalItem(context, data);
        }
        // 3. 更新时间显示（所有类型都显示）
        mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));
        // 4. 设置背景
        setBackground(data);
    }
    // ======================= 通话记录文件夹绑定 =======================
    /**
     * 绑定通话记录文件夹
     * 特殊显示：文件夹图标 + 便签数量
     * @param context 上下文
     * @param data 文件夹数据
     */
    private void bindCallRecordFolder(Context context, NoteItemData data) {
        // 隐藏联系人姓名
        mCallName.setVisibility(View.GONE);
        // 显示提醒图标（文件夹图标）
        mAlert.setVisibility(View.VISIBLE);
        // 设置主标题样式
        mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
        // 设置标题文本：文件夹名称 + 文件数量
        mTitle.setText(context.getString(R.string.call_record_folder_name)
                + context.getString(R.string.format_folder_files_count, data.getNotesCount()));
        // 设置文件夹图标
        mAlert.setImageResource(R.drawable.call_record);
    }
    // ======================= 通话记录便签绑定 =======================
    /**
     * 绑定通话记录便签
     * 特殊显示：联系人姓名 + 提醒图标
     * @param context 上下文
     * @param data 便签数据
     */
    private void bindCallRecordNote(Context context, NoteItemData data) {
        // 显示联系人姓名
        mCallName.setVisibility(View.VISIBLE);
        mCallName.setText(data.getCallName());
        // 设置副标题样式
        mTitle.setTextAppearance(context,R.style.TextAppearanceSecondaryItem);
        // 设置标题文本（格式化摘要）
        mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
        // 根据是否有提醒设置图标
        if (data.hasAlert()) {
            mAlert.setImageResource(R.drawable.clock);
            mAlert.setVisibility(View.VISIBLE);
        } else {
            mAlert.setVisibility(View.GONE);
        }
    }
    // ======================= 普通项绑定 =======================
    /**
     * 绑定普通文件夹或便签
     * 通用显示逻辑
     * @param context 上下文
     * @param data 便签/文件夹数据
     */
    private void bindNormalItem(Context context, NoteItemData data) {
        // 隐藏联系人姓名
        mCallName.setVisibility(View.GONE);
        // 设置主标题样式
        mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
        if (data.getType() == Notes.TYPE_FOLDER) {
            // 文件夹：显示名称 + 文件数量
            mTitle.setText(data.getSnippet()
                    + context.getString(R.string.format_folder_files_count,
                    data.getNotesCount()));
            mAlert.setVisibility(View.GONE);  // 文件夹不显示提醒图标
        } else {
            // 普通便签：显示格式化摘要
            mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
            // 根据是否有提醒设置图标
            if (data.hasAlert()) {
                mAlert.setImageResource(R.drawable.clock);
                mAlert.setVisibility(View.VISIBLE);
            } else {
                mAlert.setVisibility(View.GONE);
            }
            // 根据是否置顶设置置顶图标
            if (data.isPinned()) {
                mPinned.setVisibility(View.VISIBLE);
            } else {
                mPinned.setVisibility(View.GONE);
            }
        }
    }
    // ======================= 背景设置 =======================
    /**
     * 设置列表项背景
     * 根据便签类型和位置选择不同的背景图片
     * 背景选择规则：
     * 1. 便签：根据位置选择不同背景（首项、中间项、末项、单独项）
     * 2. 文件夹：统一使用文件夹背景
     *
     * @param data 便签数据项
     */
    private void setBackground(NoteItemData data) {
        int id = data.getBgColorId();  // 获取背景颜色ID
        if (data.getType() == Notes.TYPE_NOTE) {
            // 便签类型：根据位置选择背景
            if (data.isSingle() || data.isOneFollowingFolder()) {
                // 单独项或文件夹后的唯一便签：单独项背景
                setBackgroundResource(NoteItemBgResources.getNoteBgSingleRes(id));
            } else if (data.isLast()) {
                // 最后一项：底部圆角背景
                setBackgroundResource(NoteItemBgResources.getNoteBgLastRes(id));
            } else if (data.isFirst() || data.isMultiFollowingFolder()) {
                // 第一项或文件夹后的多个便签之一：顶部圆角背景
                setBackgroundResource(NoteItemBgResources.getNoteBgFirstRes(id));
            } else {
                // 中间项：普通直角背景
                setBackgroundResource(NoteItemBgResources.getNoteBgNormalRes(id));
            }
        } else {
            // 文件夹类型：统一使用文件夹背景
            setBackgroundResource(NoteItemBgResources.getFolderBgRes());
        }
    }
    // ======================= 数据获取方法 =======================
    /**
     * 获取便签数据项
     * 用于获取当前视图绑定的数据
     * @return 便签数据项
     */
    public NoteItemData getItemData() {
        return mItemData;
    }
 }
--- a/java/net/micode/notes/widget/NoteWidgetProvider.java
+++ b/java/net/micode/notes/widget/NoteWidgetProvider.java
@ -1,257 +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.
 */
 // NoteWidgetProvider.java - 便签小部件提供者抽象基类
 // 主要功能：为便签小部件提供基础实现，包括数据加载、视图更新、点击处理
 package net.micode.notes.widget;
 // ======================= 导入区域 =======================
 // Android小部件
 import android.app.PendingIntent;           // 待定意图
 import android.appwidget.AppWidgetManager;  // 小部件管理器
 import android.appwidget.AppWidgetProvider; // 小部件提供者基类
 // Android数据
 import android.content.ContentValues;       // 内容值
 import android.content.Context;             // 上下文
 import android.content.Intent;              // 意图
 import android.database.Cursor;             // 数据库查询结果游标
 import android.util.Log;                    // 日志工具
 // Android小部件视图
 import android.widget.RemoteViews;          // 远程视图
 // 应用内部资源
 import net.micode.notes.R;                  // 资源文件R类
 // 应用数据模型
 import net.micode.notes.data.Notes;         // Notes主类
 import net.micode.notes.data.Notes.NoteColumns;  // 便签表列定义
 // 应用资源解析
 import net.micode.notes.tool.ResourceParser;  // 资源解析器
 // 应用界面
 import net.micode.notes.ui.NoteEditActivity;  // 便签编辑Activity
 import net.micode.notes.ui.NotesListActivity; // 便签列表Activity
 // ======================= 便签小部件提供者抽象基类 =======================
 /**
 * NoteWidgetProvider - 便签小部件提供者抽象基类
 * 继承自AppWidgetProvider，为便签小部件提供通用基础功能
 * 抽象类，具体小部件类型（2x、4x）需要实现抽象方法
 * 核心功能：
 * 1. 小部件数据加载和显示
 * 2. 小部件点击事件处理
 * 3. 小部件删除时数据清理
 * 4. 隐私模式支持
 */
 public abstract class NoteWidgetProvider extends AppWidgetProvider {
    // ======================= 数据库查询配置 =======================
    /**
     * 查询投影数组 - 指定从数据库查询哪些字段
     * 包含小部件显示所需的最小字段集
     */
    public static final String [] PROJECTION = new String [] {
            NoteColumns.ID,           // 0 - 便签ID
            NoteColumns.BG_COLOR_ID,  // 1 - 背景颜色ID
            NoteColumns.SNIPPET       // 2 - 便签摘要
    };
    // ======================= 字段索引常量 =======================
    public static final int COLUMN_ID           = 0;  // ID字段索引
    public static final int COLUMN_BG_COLOR_ID  = 1;  // 背景颜色字段索引
    public static final int COLUMN_SNIPPET      = 2;  // 摘要字段索引
    // ======================= 常量定义 =======================
    private static final String TAG = "NoteWidgetProvider";  // 日志标签
    // ======================= 小部件生命周期方法 =======================
    /**
     * 小部件删除回调
     * 当用户从小部件列表中删除小部件时调用
     * 功能：清理数据库中与该小部件关联的便签的小部件ID
     *
     * @param context 上下文
     * @param appWidgetIds 被删除的小部件ID数组
     */
    @Override
    public void onDeleted(Context context, int[] appWidgetIds) {
        // 创建内容值，用于更新数据库
        ContentValues values = new ContentValues();
        // 将小部件ID设置为无效值
        values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
        // 遍历所有被删除的小部件
        for (int i = 0; i < appWidgetIds.length; i++) {
            // 更新数据库，清理关联的小部件ID
            context.getContentResolver().update(Notes.CONTENT_NOTE_URI,
                    values,
                    NoteColumns.WIDGET_ID + "=?",  // 条件：小部件ID匹配
                    new String[] { String.valueOf(appWidgetIds[i])});
        }
    }
    // ======================= 小部件信息查询 =======================
    /**
     * 获取便签小部件信息
     * 根据小部件ID查询关联的便签信息
     * 注意：排除回收站中的便签
     *
     * @param context 上下文
     * @param widgetId 小部件ID
     * @return 便签信息游标，包含ID、背景颜色、摘要
     */
    private Cursor getNoteWidgetInfo(Context context, int widgetId) {
        return context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
                PROJECTION,
                // 条件：小部件ID匹配 且 不在回收站中
                NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?",
                new String[] { String.valueOf(widgetId), String.valueOf(Notes.ID_TRASH_FOLER) },
                null);
    }
    // ======================= 小部件更新方法 =======================
    /**
     * 更新小部件（公开方法）
     * 默认使用非隐私模式更新
     *
     * @param context 上下文
     * @param appWidgetManager 小部件管理器
     * @param appWidgetIds 要更新的小部件ID数组
     */
    protected void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
        update(context, appWidgetManager, appWidgetIds, false);  // 默认非隐私模式
    }
    /**
     * 更新小部件（私有方法）
     * 实际执行小部件更新逻辑
     * 更新流程：
     * 1. 查询便签信息
     * 2. 构建远程视图
     * 3. 设置点击意图
     * 4. 更新小部件
     *
     * @param context 上下文
     * @param appWidgetManager 小部件管理器
     * @param appWidgetIds 要更新的小部件ID数组
     * @param privacyMode 是否处于隐私模式
     *                  true: 隐私模式，显示"浏览中"文本
     *                  false: 正常模式，显示便签内容
     */
    private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds,
                        boolean privacyMode) {
        // 遍历所有要更新的小部件
        for (int i = 0; i < appWidgetIds.length; i++) {
            if (appWidgetIds[i] != AppWidgetManager.INVALID_APPWIDGET_ID) {
                int bgId = ResourceParser.getDefaultBgId(context);  // 默认背景颜色
                String snippet = "";  // 便签摘要
                // 构建点击意图
                Intent intent = new Intent(context, NoteEditActivity.class);
                intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
                intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]);
                intent.putExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, getWidgetType());
                // 查询小部件关联的便签信息
                Cursor c = getNoteWidgetInfo(context, appWidgetIds[i]);
                if (c != null && c.moveToFirst()) {
                    // 安全检查：确保没有多个便签关联到同一小部件
                    if (c.getCount() > 1) {
                        Log.e(TAG, "Multiple message with same widget id:" + appWidgetIds[i]);
                        c.close();
                        return;  // 数据异常，直接返回
                    }
                    // 从游标获取数据
                    snippet = c.getString(COLUMN_SNIPPET);
                    bgId = c.getInt(COLUMN_BG_COLOR_ID);
                    intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID));  // 便签ID
                    intent.setAction(Intent.ACTION_VIEW);  // 查看模式
                } else {
                    // 无关联便签：显示默认文本
                    snippet = context.getResources().getString(R.string.widget_havenot_content);
                    intent.setAction(Intent.ACTION_INSERT_OR_EDIT);  // 创建/编辑模式
                }
                // 关闭游标
                if (c != null) {
                    c.close();
                }
                // 创建远程视图
                RemoteViews rv = new RemoteViews(context.getPackageName(), getLayoutId());
                // 设置背景图片
                rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId));
                intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId);
                /**
                 * 生成待定意图，用于启动小部件对应的Activity
                 */
                PendingIntent pendingIntent = null;
                if (privacyMode) {
                    // 隐私模式：显示"浏览中"文本，点击进入列表
                    rv.setTextViewText(R.id.widget_text,
                            context.getString(R.string.widget_under_visit_mode));
                    pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], new Intent(
                            context, NotesListActivity.class), PendingIntent.FLAG_UPDATE_CURRENT);
                } else {
                    // 正常模式：显示便签内容，点击编辑便签
                    rv.setTextViewText(R.id.widget_text, snippet);
                    pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], intent,
                            PendingIntent.FLAG_UPDATE_CURRENT);
                }
                // 设置点击事件
                rv.setOnClickPendingIntent(R.id.widget_text, pendingIntent);
                // 更新小部件
                appWidgetManager.updateAppWidget(appWidgetIds[i], rv);
            }
        }
    }
    // ======================= 抽象方法 =======================
    /**
     * 获取背景资源ID
     * 将背景颜色ID映射到实际的Drawable资源ID
     * 抽象方法，由具体子类实现
     *
     * @param bgId 背景颜色ID
     * @return Drawable资源ID
     */
    protected abstract int getBgResourceId(int bgId);
    /**
     * 获取布局ID
     * 返回小部件使用的布局资源ID
     * 抽象方法，由具体子类实现
     *
     * @return 布局资源ID
     */
    protected abstract int getLayoutId();
    /**
     * 获取小部件类型
     * 返回小部件的类型常量
     * 抽象方法，由具体子类实现
     *
     * @return 小部件类型：TYPE_WIDGET_2X 或 TYPE_WIDGET_4X
     */
    protected abstract int getWidgetType();
 }
--- a/java/net/micode/notes/widget/NoteWidgetProvider_2x.java
+++ b/java/net/micode/notes/widget/NoteWidgetProvider_2x.java
@ -1,99 +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.
 */
 // NoteWidgetProvider_2x.java - 2x2便签小部件提供者
 // 主要功能：实现2x2尺寸便签小部件的具体逻辑
 package net.micode.notes.widget;
 // ======================= 导入区域 =======================
 // Android小部件
 import android.appwidget.AppWidgetManager;  // 小部件管理器
 // Android基础
 import android.content.Context;             // 上下文
 // 应用内部资源
 import net.micode.notes.R;                  // 资源文件R类
 // 应用数据模型
 import net.micode.notes.data.Notes;         // Notes主类
 // 应用资源解析
 import net.micode.notes.tool.ResourceParser;  // 资源解析器
 // ======================= 2x2便签小部件提供者 =======================
 /**
 * NoteWidgetProvider_2x - 2x2便签小部件提供者
 * 继承自NoteWidgetProvider抽象基类
 * 功能：实现2x2尺寸便签小部件的具体逻辑
 * 尺寸：2x2单元格（通常为2行2列）
 * 布局：widget_2x.xml
 */
 public class NoteWidgetProvider_2x extends NoteWidgetProvider {
    // ======================= 小部件生命周期方法 =======================
    /**
     * 小部件更新回调
     * 当小部件需要更新时调用，包括创建、定时更新、配置变更等
     * 实现：调用父类的update()方法
     *
     * @param context 上下文
     * @param appWidgetManager 小部件管理器
     * @param appWidgetIds 需要更新的小部件ID数组
     */
    @Override
    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
        // 调用父类的update()方法执行通用更新逻辑
        super.update(context, appWidgetManager, appWidgetIds);
    }
    // ======================= 抽象方法实现 =======================
    /**
     * 获取布局ID
     * 返回2x2小部件使用的布局资源ID
     * 布局文件：R.layout.widget_2x
     *
     * @return 2x2小部件布局资源ID
     */
    @Override
    protected int getLayoutId() {
        return R.layout.widget_2x;
    }
    /**
     * 获取背景资源ID
     * 将背景颜色ID映射到2x2小部件的实际Drawable资源ID
     * 通过ResourceParser.WidgetBgResources获取对应资源
     *
     * @param bgId 背景颜色ID
     * @return 2x2小部件背景Drawable资源ID
     */
    @Override
    protected int getBgResourceId(int bgId) {
        return ResourceParser.WidgetBgResources.getWidget2xBgResource(bgId);
    }
    /**
     * 获取小部件类型
     * 返回2x2小部件的类型常量
     * 类型常量定义在Notes类中
     *
     * @return 小部件类型：Notes.TYPE_WIDGET_2X
     */
    @Override
    protected int getWidgetType() {
        return Notes.TYPE_WIDGET_2X;
    }
 }
--- a/java/net/micode/notes/widget/NoteWidgetProvider_4x.java
+++ b/java/net/micode/notes/widget/NoteWidgetProvider_4x.java
@ -1,104 +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.
 */
 // NoteWidgetProvider_4x.java - 4x4便签小部件提供者
 // 主要功能：实现4x4尺寸便签小部件的具体逻辑
 package net.micode.notes.widget;
 // ======================= 导入区域 =======================
 // Android小部件
 import android.appwidget.AppWidgetManager;  // 小部件管理器
 // Android基础
 import android.content.Context;             // 上下文
 // 应用内部资源
 import net.micode.notes.R;                  // 资源文件R类
 // 应用数据模型
 import net.micode.notes.data.Notes;         // Notes主类
 // 应用资源解析
 import net.micode.notes.tool.ResourceParser;  // 资源解析器
 // ======================= 4x4便签小部件提供者 =======================
 /**
 * NoteWidgetProvider_4x - 4x4便签小部件提供者
 * 继承自NoteWidgetProvider抽象基类
 * 功能：实现4x4尺寸便签小部件的具体逻辑
 * 尺寸：4x4单元格（通常为4行4列）
 * 布局：widget_4x.xml
 * 特点：更大显示面积，可显示更多便签内容
 */
 public class NoteWidgetProvider_4x extends NoteWidgetProvider {
    // ======================= 小部件生命周期方法 =======================
    /**
     * 小部件更新回调
     * 当小部件需要更新时调用，包括创建、定时更新、配置变更等
     * 实现：调用父类的update()方法
     * 与2x版本逻辑完全相同，复用父类通用更新逻辑
     *
     * @param context 上下文
     * @param appWidgetManager 小部件管理器
     * @param appWidgetIds 需要更新的小部件ID数组
     */
    @Override
    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
        // 调用父类的update()方法执行通用更新逻辑
        super.update(context, appWidgetManager, appWidgetIds);
    }
    // ======================= 抽象方法实现 =======================
    /**
     * 获取布局ID
     * 返回4x4小部件使用的布局资源ID
     * 布局文件：R.layout.widget_4x
     * 布局特点：更大的显示区域，适合显示更多文本内容
     *
     * @return 4x4小部件布局资源ID
     */
    @Override
    protected int getLayoutId() {
        return R.layout.widget_4x;
    }
    /**
     * 获取背景资源ID
     * 将背景颜色ID映射到4x4小部件的实际Drawable资源ID
     * 通过ResourceParser.WidgetBgResources获取对应资源
     * 注意：使用4x专用的背景资源，适配4x4尺寸
     *
     * @param bgId 背景颜色ID
     * @return 4x4小部件背景Drawable资源ID
     */
    @Override
    protected int getBgResourceId(int bgId) {
        return ResourceParser.WidgetBgResources.getWidget4xBgResource(bgId);
    }
    /**
     * 获取小部件类型
     * 返回4x4小部件的类型常量
     * 类型常量定义在Notes类中
     * 用于数据库记录和业务逻辑区分
     *
     * @return 小部件类型：Notes.TYPE_WIDGET_4X
     */
    @Override
    protected int getWidgetType() {
        return Notes.TYPE_WIDGET_4X;
    }
 }
--- a/res/color/primary_text_dark.xml
+++ b/res/color/primary_text_dark.xml
@ -1,77 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
  ============================================================================
  selector_color_btn.xml - 按钮颜色选择器资源文件
  ============================================================================
  功能：定义按钮在不同状态下的文本颜色
  用途：应用于便签应用中的按钮，提供视觉反馈
  文件位置：res/color/selector_color_btn.xml
  ============================================================================
  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.
  ============================================================================
 -->
 <!--
  ======================= 颜色选择器定义 =======================
  功能：根据按钮状态切换文本颜色
  原理：系统根据按钮当前状态自动选择匹配的颜色
  状态优先级：按定义顺序从上到下匹配，第一个匹配的状态生效
 -->
 <selector xmlns:android="http://schemas.android.com/apk/res/android">
    <!--
      ======================= 按下状态 =======================
      状态：android:state_pressed="true"
      颜色：#88555555
      说明：
      - 当用户按下按钮时应用此颜色
      - 颜色值：#88555555
        - 前两位(88): Alpha通道，约50%透明度
        - 后六位(555555): RGB颜色，深灰色
      - 视觉反馈：半透明深灰色，表示按钮被按下
      应用场景：用户触摸按钮时的即时反馈
    -->
    <item android:state_pressed="true" android:color="#88555555" />
    <!--
      ======================= 选中状态 =======================
      状态：android:state_selected="true"
      颜色：#ff999999
      说明：
      - 当按钮被选中时应用此颜色
      - 颜色值：#ff999999
        - 前两位(ff): Alpha通道，完全不透明
        - 后六位(999999): RGB颜色，中灰色
      - 视觉反馈：中灰色，表示按钮被选中
      应用场景：导航选中、标签选中等状态
    -->
    <item android:state_selected="true" android:color="#ff999999" />
    <!--
      ======================= 默认状态 =======================
      状态：无状态条件（默认项）
      颜色：#ff000000
      说明：
      - 当按钮处于普通状态时应用此颜色
      - 颜色值：#ff000000
        - 前两位(ff): Alpha通道，完全不透明
        - 后六位(000000): RGB颜色，纯黑色
      - 视觉反馈：纯黑色文本，正常显示
      应用场景：按钮的默认外观
      注意：必须放在最后，作为默认状态
    -->
    <item android:color="#ff000000" />
 </selector>
--- a/res/color/secondary_text_dark.xml
+++ b/res/color/secondary_text_dark.xml
@ -1,58 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
  ============================================================================
  selector_color_footer.xml - 底部区域颜色选择器资源文件
  ============================================================================
  功能：定义便签列表底部区域的背景或文本颜色
  用途：应用于便签列表的底部视图，提供半透明遮罩效果
  文件位置：res/color/selector_color_footer.xml
  ============================================================================
  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.
  ============================================================================
 -->
 <!--
  ======================= 单状态颜色选择器 =======================
  功能：提供固定的半透明黑色颜色
  特点：只有默认状态，无状态切换
  用途：创建半透明的遮罩或背景效果
  设计理念：简约、一致、功能明确
 -->
 <selector xmlns:android="http://schemas.android.com/apk/res/android">
    <!--
      ======================= 唯一颜色项 =======================
      状态：无状态条件（始终应用此颜色）
      颜色：#50000000
      说明：
      - 这是一个固定颜色，不随状态变化
      - 颜色值：#50000000
        - 前两位(50): Alpha通道，31.25%透明度
          - 十六进制：0x50 = 十进制 80
          - 透明度：80/255 ≈ 31.37%
        - 后六位(000000): RGB颜色，纯黑色
      - 视觉效果：31%透明度的黑色遮罩
      应用场景：
      1. 列表底部渐变遮罩
      2. 半透明背景层
      3. 视觉分隔效果
      设计目的：
      1. 创建视觉层次
      2. 提供内容聚焦
      3. 增强界面深度
    -->
    <item android:color="#50000000" />
 </selector>
--- a/res/values-zh/strings.xml
+++ b/res/values-zh/strings.xml
@ -1,137 +0,0 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources xmlns:android="http://schemas.android.com/apk/res/android">
    <!-- 应用基本信息 -->
    <string name="app_name">便签</string>
    <string name="app_widget2x2">便签 2x2</string>
    <string name="app_widget4x4">便签 4x4</string>
    <!-- 小部件相关字符串 -->
    <string name="widget_havenot_content">未找到关联便签，点击创建关联便签。</string>
    <string name="widget_under_visit_mode">隐私模式，无法查看便签内容</string>
    <string name="notelist_string_info">...</string>
    <string name="notelist_menu_new">新建便签</string>
    <!-- 提醒相关字符串 -->
    <string name="note_alert_expired">已过期</string>
    <string name="format_date_ymd">yyyyMMdd</string>
    <string name="format_datetime_mdhm">MMMd kk:mm</string>
    <string name="notealert_ok">知道了</string>
    <string name="notealert_enter">查看</string>
    <!-- 超链接菜单字符串 -->
    <string name="note_link_tel">拨号</string>
    <string name="note_link_email">发送邮件</string>
    <string name="note_link_web">浏览网页</string>
    <string name="note_link_other">打开地图</string>
    <!-- 文本导出相关字符串 -->
    <string name="file_path">/MIUI/notes/</string>
    <string name="file_name_txt_format">notes_%s.txt</string>
    <!-- 便签列表相关字符串 -->
    <string name="format_folder_files_count">(%d)</string>
    <string name="menu_create_folder">新建文件夹</string>
    <string name="menu_export_text">导出文本</string>
    <string name="menu_sync">同步</string>
    <string name="menu_sync_cancel">取消同步</string>
    <string name="menu_setting">设置</string>
    <string name="menu_search">搜索</string>
    <string name="menu_pin">置顶</string>
    <string name="menu_unpin">取消置顶</string>
    <string name="menu_delete">删除</string>
    <string name="menu_move">移动到文件夹</string>
    <string name="menu_select_title">已选择 %d 项</string>
    <string name="menu_select_none">未选择任何项，操作无效</string>
    <string name="menu_select_all">全选</string>
    <string name="menu_deselect_all">取消全选</string>
    <string name="menu_batch_select">批量选择</string>
    <!-- 字体大小 -->
    <string name="menu_font_size">字体大小</string>
    <string name="menu_font_small">小</string>
    <string name="menu_font_normal">中</string>
    <string name="menu_font_large">大</string>
    <string name="menu_font_super">超大</string>
    <!-- 清单模式 -->
    <string name="menu_list_mode">进入清单模式</string>
    <string name="menu_normal_mode">退出清单模式</string>
    <!-- 文件夹操作 -->
    <string name="menu_folder_view">查看文件夹</string>
    <string name="menu_folder_delete">删除文件夹</string>
    <string name="menu_folder_change_name">重命名文件夹</string>
    <string name="folder_exist">文件夹 %1$s 已存在，请重新命名</string>
    <!-- 便签编辑菜单 -->
    <string name="menu_share">分享</string>
    <string name="menu_send_to_desktop">发送到桌面</string>
    <string name="menu_alert">提醒我</string>
    <string name="menu_remove_remind">删除提醒</string>
    <string name="menu_insert_image">插入图片</string>
    <string name="menu_title_select_folder">选择文件夹</string>
    <string name="menu_move_parent_folder">父文件夹</string>
    <string name="info_note_enter_desktop">便签已添加到桌面</string>
    <!-- 确认对话框 -->
    <string name="alert_message_delete_folder">确认删除文件夹及其包含的便签？</string>
    <string name="alert_title_delete">删除选择的便签</string>
    <string name="alert_message_delete_notes">确认删除选择的 %d 个便签？</string>
    <string name="alert_message_delete_note">确认删除此便签？</string>
    <string name="format_move_notes_to_folder">已将选择的 %1$d 个便签移动到 %2$s 文件夹</string>
    <!-- 错误信息 -->
    <string name="error_sdcard_unmounted">SD卡正忙，暂不可用</string>
    <string name="error_sdcard_export">导出失败，请检查SD卡</string>
    <string name="error_note_not_exist">便签不存在</string>
    <string name="error_note_empty_for_clock">抱歉，不能为空便签设置提醒</string>
    <string name="error_note_empty_for_send_to_desktop">抱歉，不能将空便签发送到桌面</string>
    <string name="success_sdcard_export">导出成功</string>
    <string name="failed_sdcard_export">导出失败</string>
    <string name="format_exported_file_location">已将文本文件 (%1$s) 导出到SD卡 (%2$s) 目录</string>
    <!-- 同步相关 -->
    <string name="ticker_syncing">正在同步便签...</string>
    <string name="ticker_success">同步成功</string>
    <string name="ticker_fail">同步失败</string>
    <string name="ticker_cancel">同步已取消</string>
    <string name="success_sync_account">已成功与账户 %1$s 同步</string>
    <string name="error_sync_network">同步失败，请检查网络和账户设置</string>
    <string name="error_sync_internal">同步失败，发生内部错误</string>
    <string name="error_sync_cancelled">同步已取消</string>
    <string name="sync_progress_login">正在登录 %1$s...</string>
    <string name="sync_progress_init_list">正在获取远程便签列表...</string>
    <string name="sync_progress_syncing">正在将本地便签与Google Task同步...</string>
    <!-- 设置界面 -->
    <string name="preferences_title">设置</string>
    <string name="preferences_account_title">同步账户</string>
    <string name="preferences_account_summary">将便签与Google Task同步</string>
    <string name="preferences_last_sync_time">上次同步时间 %1$s</string>
    <string name="preferences_last_sync_time_format">yyyy-MM-dd hh:mm:ss</string>
    <string name="preferences_add_account">添加账户</string>
    <string name="preferences_menu_change_account">更改同步账户</string>
    <string name="preferences_menu_remove_account">移除同步账户</string>
    <string name="preferences_menu_cancel">取消</string>
    <string name="preferences_button_sync_immediately">立即同步</string>
    <string name="preferences_button_sync_cancel">取消同步</string>
    <string name="preferences_dialog_change_account_title">当前账户 %1$s</string>
    <string name="preferences_dialog_change_account_warn_msg">将删除所有同步相关信息，可能会导致某些项目重复</string>
    <string name="preferences_dialog_select_account_title">同步便签</string>
    <string name="preferences_dialog_select_account_tips">请选择一个Google账户。本地便签将与Google Task同步。</string>
    <string name="preferences_toast_cannot_change_account">无法更改账户，因为同步正在进行中</string>
    <string name="preferences_toast_success_set_accout">%1$s 已被设置为同步账户</string>
    <string name="preferences_bg_random_appear_title">新便签背景颜色随机</string>
    <!-- 其他功能 -->
    <string name="call_record_folder_name">通话便签</string>
    <string name="hint_foler_name">输入名称</string>
    <string name="search_label">搜索便签</string>
    <string name="search_hint">搜索便签</string>
    <string name="search_setting_description">便签中的文本</string>
    <string name="search_history">搜索历史</string>
    <string name="datetime_dialog_ok">设置</string>
    <string name="datetime_dialog_cancel">取消</string>
 </resources>
--- a/res/values/arrays.xml
+++ b/res/values/arrays.xml
@ -1,105 +0,0 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!--
  ============================================================================
  arrays.xml - 数组资源定义文件
  ============================================================================
  功能：定义便签应用中使用的字符串数组资源
  本文件：定义便签导出格式模板数组
  文件位置：res/values/arrays.xml
  ============================================================================
  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.
  ============================================================================
 -->
 <resources>
    <!--
      ======================= 导出便签格式数组 =======================
      名称：format_for_exported_note
      类型：字符串数组 (string-array)
      功能：定义导出便签到文本文件时的格式模板
      用途：在BackupUtils.exportToText()方法中使用
      格式：每行使用不同的格式化字符串，支持参数替换
      设计理念：结构化、可读性、灵活性
      数组结构说明：
      索引 | 格式模板     | 对应字符串资源         | 说明
       0  | "-%s"       | format_folder_name  | 文件夹名称行
       1  | "-%s"      | format_folder_note_date | 文件夹内便签日期
       2  | "-%s"      | format_note_date    | 便签日期
       3  | "-%s"      | format_note_content | 便签内容
      使用流程：
      1. 遍历文件夹结构
      2. 对每个文件夹使用索引0的格式
      3. 对文件夹内每个便签依次使用索引1-3的格式
      4. 将格式化后的文本写入文件
    -->
    <string-array name="format_for_exported_note">
        <!--
          索引0：文件夹名称行格式
          格式："-%s"
          参数：文件夹名称
          示例："-工作便签"
          设计：
          - 前缀"-"：表示文件夹层级
          - 一个减号：第一级缩进
          - 无额外空格：简洁显示
          对应字符串资源：format_folder_name
        -->
        <item>-%s</item>      <!-- format_folder_name -->
        <!--
          索引1：文件夹内便签日期行格式
          格式："- -%s"
          参数：便签创建/修改日期
          示例："[2023-12-15 14:30]" 注意：将- -改为其他字符避免XML注释问题
          设计：
          - 使用两个减号作为前缀
          - 表示该便签属于上面的文件夹
          - 日期格式在代码中定义
          对应字符串资源：format_folder_note_date
          注意：在注释中不能使用连续的两个减号，这里用描述代替
        -->
        <item>--%s</item>     <!-- format_folder_note_date -->
        <!--
          索引2：便签日期行格式（可能冗余，实际应与索引1相同）
          格式："- -%s"
          参数：便签日期
          示例：类似索引1的格式
          注意：与索引1格式相同，可能用于不同上下文
          对应字符串资源：format_note_date
          设计考虑：保持格式一致，便于未来扩展
        -->
        <item>--%s</item>     <!-- format_note_date -->
        <!--
          索引3：便签内容行格式
          格式："- -%s"
          参数：便签内容文本
          示例："这是便签内容"
          设计：
          - 使用两个减号作为前缀
          - 与日期行对齐
          - 保持统一的缩进级别
          - 多行内容时每行都使用此格式
          对应字符串资源：format_note_content
        -->
        <item>--%s</item>     <!-- format_note_content -->
    </string-array>
 </resources>
--- a/res/values/colors.xml
+++ b/res/values/colors.xml
@ -1,59 +0,0 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!--
  ============================================================================
  colors.xml - 颜色资源定义文件
  ============================================================================
  功能：定义便签应用中使用的颜色值
  本文件：定义搜索高亮颜色
  文件位置：res/values/colors.xml
  ============================================================================
  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.
  ============================================================================
 -->
 <!--
  ======================= 颜色资源定义 =======================
  功能：集中管理应用中的颜色值
  优势：
  1. 一致性：确保相同语义的颜色值一致
  2. 可维护性：修改颜色只需改一处
  3. 主题支持：便于实现主题切换
  4. 性能优化：系统可缓存颜色资源
 -->
 <resources>
    <!--
      ======================= 搜索高亮颜色 =======================
      名称：user_query_highlight
      颜色值：#335b5b5b
      功能：在便签搜索功能中，高亮显示用户搜索关键词的背景颜色
      使用场景：
      1. 在便签列表中，搜索结果列表项的高亮
      2. 在便签编辑界面，搜索关键词的高亮
      3. 在便签预览中，匹配文本的高亮
    -->
    <color name="user_query_highlight">#335b5b5b</color>
    <!--
      ======================= 便签背景颜色 =======================
      名称：note_background
      颜色值：#ffffff
      功能：便签的默认背景颜色
      使用场景：
      1. 便签编辑界面背景
      2. 便签列表项背景
    -->
    <color name="note_background">#ffffff</color>
 </resources>
--- a/res/values/dimens.xml
+++ b/res/values/dimens.xml
@ -1,145 +0,0 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!--
  ============================================================================
  dimens.xml - 尺寸资源定义文件
  ============================================================================
  功能：定义便签应用中使用的尺寸值，特别是字体大小
  文件位置：res/values/dimens.xml
  作用：集中管理字体大小，支持多设备适配
  ============================================================================
  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.
  ============================================================================
 -->
 <!--
  ======================= 字体尺寸资源定义 =======================
  功能：定义便签编辑界面的5种字体大小级别
  设计理念：提供从超小到超大的完整字体大小梯度
  使用场景：NoteEditActivity中的字体大小选择功能
  尺寸单位说明：
  sp (scale-independent pixel)：缩放独立像素
  - 与dp类似，但会受系统字体大小设置影响
  - 适合用于字体尺寸，能响应用户的字号偏好
  - 在系统设置中调整字体大小时，sp会相应缩放
 -->
 <resources>
    <!--
      ======================= 超大字体尺寸 =======================
      名称：text_font_size_super
      值：33sp
      功能：最大的字体尺寸，用于视力不佳的用户或需要特别突出的内容
      使用场景：
      1. 视力辅助：为视力较差的用户提供
      2. 演示展示：需要远距离观看的场景
      3. 重点强调：特别重要的内容提示
      设计考虑：
      - 33sp是相当大的字体，在手机上可能一行显示字数较少
      - 适合便签标题或少量关键信息
      - 可能需要调整行间距和布局适配
      用户体验：
      - 优点：极佳的可读性，清晰易见
      - 缺点：屏幕利用率低，需频繁滚动
    -->
    <dimen name="text_font_size_super">33sp</dimen>
    <!--
      ======================= 大字体尺寸 =======================
      名称：text_font_size_large
      值：26sp
      功能：较大的字体尺寸，提供良好的阅读体验
      使用场景：
      1. 舒适阅读：适合长时间阅读
      2. 中老年人：满足视力下降的用户需求
      3. 一般强调：比标准稍大的显示
      设计考虑：
      - 26sp是比较舒适的阅读大小
      - 在保持可读性和屏幕利用率间取得平衡
      - 适合大多数便签内容的阅读
      用户体验：
      - 优点：阅读舒适，不费力
      - 适中：适合大多数用户
    -->
    <dimen name="text_font_size_large">26sp</dimen>
    <!--
      ======================= 中字体尺寸 =======================
      名称：text_font_size_medium
      值：20sp
      功能：中等字体尺寸，标准略大的显示
      使用场景：
      1. 标准阅读：通用的便签浏览大小
      2. 平衡显示：在内容和可读性间平衡
      3. 默认选项：可能作为默认字体大小
      设计考虑：
      - 20sp是Android应用中常见的正文大小
      - 既保证可读性，又充分利用屏幕空间
      - 适合显示中等长度的便签内容
      用户体验：
      - 适中：适合大多数使用场景
      - 通用：默认的舒适选择
    -->
    <dimen name="text_font_size_medium">20sp</dimen>
    <!--
      ======================= 标准字体尺寸 =======================
      名称：text_font_size_normal
      值：17sp
      功能：标准字体尺寸，接近系统默认大小
      使用场景：
      1. 紧凑显示：需要显示更多内容
      2. 年轻用户：视力较好的用户选择
      3. 系统一致：与系统其他应用保持协调
      设计考虑：
      - 17sp接近Android默认的16sp
      - 在屏幕空间和可读性间偏向空间利用
      - 适合内容较多、需要概览的便签
      用户体验：
      - 优点：显示效率高，一屏内容多
      - 缺点：对视力不佳者可能偏小
    -->
    <dimen name="text_font_size_normal">17sp</dimen>
    <!--
      ======================= 小字体尺寸 =======================
      名称：text_font_size_small
      值：14sp
      功能：较小的字体尺寸，用于最大化屏幕利用率
      使用场景：
      1. 内容密集：便签内容非常多时
      2. 视力优秀：年轻或视力极佳的用户
      3. 临时查看：快速浏览而非详细阅读
      设计考虑：
      - 14sp是较小的字体，接近可读性的下限
      - 适合显示大量文字内容
      - 可能需要用户靠近屏幕或仔细查看
      用户体验：
      - 优点：最大化信息密度
      - 缺点：阅读较吃力，不适合长时间
      安全考虑：14sp是Android建议的最小可读字体大小
    -->
    <dimen name="text_font_size_small">14sp</dimen>
 </resources>
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@ -1,135 +0,0 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources xmlns:android="http://schemas.android.com/apk/res/android">
    <!-- 应用基本信息 -->
    <string name="app_name">Notes</string>
    <string name="app_widget2x2">Notes 2x2</string>
    <string name="app_widget4x4">Notes 4x4</string>
    <!-- 小部件相关字符串 -->
    <string name="widget_havenot_content">No associated note found, click to create an associated note.</string>
    <string name="widget_under_visit_mode">Privacy mode, cannot view note content</string>
    <string name="notelist_string_info">...</string>
    <string name="notelist_menu_new">New Note</string>
    <!-- 提醒相关字符串 -->
    <string name="note_alert_expired">Expired</string>
    <string name="format_date_ymd">yyyyMMdd</string>
    <string name="format_datetime_mdhm">MMMd kk:mm</string>
    <string name="notealert_ok">OK</string>
    <string name="notealert_enter">View</string>
    <!-- 超链接菜单字符串 -->
    <string name="note_link_tel">Call</string>
    <string name="note_link_email">Send Email</string>
    <string name="note_link_web">Browse Web</string>
    <string name="note_link_other">Open Map</string>
    <!-- 文本导出相关字符串 -->
    <string name="file_path">/MIUI/notes/</string>
    <string name="file_name_txt_format">notes_%s.txt</string>
    <!-- 便签列表相关字符串 -->
    <string name="format_folder_files_count">(%d)</string>
    <string name="menu_create_folder">New Folder</string>
    <string name="menu_export_text">Export Text</string>
    <string name="menu_sync">Sync</string>
    <string name="menu_sync_cancel">Cancel Sync</string>
    <string name="menu_setting">Settings</string>
    <string name="menu_search">Search</string>
    <string name="menu_pin">Pin</string>
    <string name="menu_unpin">Unpin</string>
    <string name="menu_delete">Delete</string>
    <string name="menu_move">Move to Folder</string>
    <string name="menu_select_title">Selected %d items</string>
    <string name="menu_select_none">No items selected, operation invalid</string>
    <string name="menu_select_all">Select All</string>
    <string name="menu_deselect_all">Deselect All</string>
    <string name="menu_batch_select">Batch Select</string>
    <!-- 字体大小 -->
    <string name="menu_font_size">Font Size</string>
    <string name="menu_font_small">Small</string>
    <string name="menu_font_normal">Medium</string>
    <string name="menu_font_large">Large</string>
    <string name="menu_font_super">Extra Large</string>
    <!-- 清单模式 -->
    <string name="menu_list_mode">Enter List Mode</string>
    <string name="menu_normal_mode">Exit List Mode</string>
    <!-- 文件夹操作 -->
    <string name="menu_folder_view">View Folder</string>
    <string name="menu_folder_delete">Delete Folder</string>
    <string name="menu_folder_change_name">Rename Folder</string>
    <string name="folder_exist">Folder %1$s already exists, please rename</string>
    <!-- 便签编辑菜单 -->
    <string name="menu_share">Share</string>
    <string name="menu_send_to_desktop">Send to Desktop</string>
    <string name="menu_alert">Remind Me</string>
    <string name="menu_remove_remind">Remove Reminder</string>
    <string name="menu_insert_image">Insert Image</string>
    <string name="menu_title_select_folder">Select Folder</string>
    <string name="menu_move_parent_folder">Parent Folder</string>
    <string name="info_note_enter_desktop">Note added to desktop</string>
    <!-- 确认对话框 -->
    <string name="alert_message_delete_folder">Confirm delete folder and its notes?</string>
    <string name="alert_title_delete">Delete Selected Notes</string>
    <string name="alert_message_delete_notes">Confirm delete selected %d notes?</string>
    <string name="alert_message_delete_note">Confirm delete this note?</string>
    <string name="format_move_notes_to_folder">Moved selected %1$d notes to %2$s folder</string>
    <!-- 错误信息 -->
    <string name="error_sdcard_unmounted">SD card is busy, temporarily unavailable</string>
    <string name="error_sdcard_export">Export failed, please check SD card</string>
    <string name="error_note_not_exist">Note does not exist</string>
    <string name="error_note_empty_for_clock">Sorry, cannot set reminder for empty note</string>
    <string name="error_note_empty_for_send_to_desktop">Sorry, cannot send empty note to desktop</string>
    <string name="success_sdcard_export">Export successful</string>
    <string name="failed_sdcard_export">Export failed</string>
    <string name="format_exported_file_location">Exported text file (%1$s) to SD card (%2$s) directory</string>
    <!-- 同步相关 -->
    <string name="ticker_syncing">Syncing notes...</string>
    <string name="ticker_success">Sync successful</string>
    <string name="ticker_fail">Sync failed</string>
    <string name="ticker_cancel">Sync cancelled</string>
    <string name="success_sync_account">Successfully synced with account %1$s</string>
    <string name="error_sync_network">Sync failed, please check network and account settings</string>
    <string name="error_sync_internal">Sync failed, internal error occurred</string>
    <string name="error_sync_cancelled">Sync cancelled</string>
    <string name="sync_progress_login">Logging in to %1$s...</string>
    <string name="sync_progress_init_list">Retrieving remote notes list...</string>
    <string name="sync_progress_syncing">Syncing local notes with Google Task...</string>
    <!-- 设置界面 -->
    <string name="preferences_title">Settings</string>
    <string name="preferences_account_title">Sync Account</string>
    <string name="preferences_account_summary">Sync notes with Google Task</string>
    <string name="preferences_last_sync_time">Last sync time %1$s</string>
    <string name="preferences_last_sync_time_format">yyyy-MM-dd hh:mm:ss</string>
    <string name="preferences_add_account">Add Account</string>
    <string name="preferences_menu_change_account">Change Sync Account</string>
    <string name="preferences_menu_remove_account">Remove Sync Account</string>
    <string name="preferences_menu_cancel">Cancel</string>
    <string name="preferences_button_sync_immediately">Sync Now</string>
    <string name="preferences_button_sync_cancel">Cancel Sync</string>
    <string name="preferences_dialog_change_account_title">Current account %1$s</string>
    <string name="preferences_dialog_change_account_warn_msg">All sync-related information will be deleted, which may cause some items to be duplicated</string>
    <string name="preferences_dialog_select_account_title">Sync Notes</string>
    <string name="preferences_dialog_select_account_tips">Please select a Google account. Local notes will be synced with Google Task.</string>
    <string name="preferences_toast_cannot_change_account">Cannot change account because sync is in progress</string>
    <string name="preferences_toast_success_set_accout">%1$s has been set as the sync account</string>
    <string name="preferences_bg_random_appear_title">New note background color random</string>
    <!-- 其他功能 -->
    <string name="call_record_folder_name">Call Notes</string>
    <string name="hint_foler_name">Enter name</string>
    <string name="search_label">Search Notes</string>
    <string name="search_hint">Search notes</string>
    <string name="search_setting_description">Text in notes</string>
    <string name="search_history">Search History</string>
    <string name="datetime_dialog_ok">Set</string>
    <string name="datetime_dialog_cancel">Cancel</string>
 </resources>
--- a/res/values/styles.xml
+++ b/res/values/styles.xml
@ -1,310 +0,0 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!--
  ============================================================================
  styles.xml - 样式资源定义文件
  ============================================================================
  功能：定义便签应用中的文本外观样式和主题
  文件位置：res/values/styles.xml
  作用：统一应用视觉风格，提供一致的文本显示
  ============================================================================
  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.
  ============================================================================
 -->
 <!--
  ======================= 样式资源定义 =======================
  功能：集中管理应用中使用的文本样式和主题
  分类：
  1. 字体大小样式：对应5种字体大小级别
  2. 列表项样式：便签列表中的文本样式
  3. 菜单样式：界面元素的文本样式
  4. 应用主题：整体应用的主题定义
  设计理念：通过样式系统实现视觉一致性
 -->
 <resources>
    <!--
      ======================= 超大字体样式 =======================
      名称：TextAppearanceSuper
      父样式：无（直接定义）
      功能：定义超大字体（33sp）的文本外观
      使用场景：
      1. 便签编辑界面中的超大字体模式
      2. 需要特别突出的文本内容
      3. 视力辅助显示模式
      样式属性：
      1. textSize: @dimen/text_font_size_super (33sp)
         - 使用dimens.xml中定义的超大字体尺寸
         - 提供最佳的可读性和可见性
      2. textColorLink: #0000ff (纯蓝色)
         - 超链接文本的颜色
         - 标准蓝色：#0000ff (RGB: 0,0,255)
         - 设计：传统蓝色超链接，用户易于识别
      在代码中的使用：
      TextAppearanceResources.getTexAppearanceResource(id)
      映射到对应样式资源
    -->
    <style name="TextAppearanceSuper">
        <item name="android:textSize">@dimen/text_font_size_super</item>
        <item name="android:textColorLink">#0000ff</item>
    </style>
    <!--
      ======================= 大字体样式 =======================
      名称：TextAppearanceLarge
      父样式：无（直接定义）
      功能：定义大字体（26sp）的文本外观
      使用场景：
      1. 便签编辑界面中的大字体模式
      2. 舒适阅读模式
      3. 中老年人友好显示
      样式属性：
      1. textSize: @dimen/text_font_size_large (26sp)
         - 使用dimens.xml中定义的大字体尺寸
         - 提供优秀的阅读体验
      2. textColorLink: #0000ff (纯蓝色)
         - 超链接文本的颜色
         - 与超大字体样式保持一致的链接颜色
      设计考虑：
      - 大字体适合长时间阅读
      - 链接颜色保持一致，建立视觉关联
    -->
    <style name="TextAppearanceLarge">
        <item name="android:textSize">@dimen/text_font_size_large</item>
        <item name="android:textColorLink">#0000ff</item>
    </style>
    <!--
      ======================= 中字体样式 =======================
      名称：TextAppearanceMedium
      父样式：无（直接定义）
      功能：定义中字体（20sp）的文本外观
      使用场景：
      1. 便签编辑界面中的中字体模式
      2. 标准阅读模式（可能为默认）
      3. 平衡显示的内容
      样式属性：
      1. textSize: @dimen/text_font_size_medium (20sp)
         - 使用dimens.xml中定义的中字体尺寸
         - 在可读性和信息密度间取得平衡
      2. textColorLink: #0000ff (纯蓝色)
         - 超链接文本的颜色
         - 保持所有字体大小样式的链接颜色一致
      设计位置：
      这个样式可能是应用默认的字体大小
    -->
    <style name="TextAppearanceMedium">
        <item name="android:textSize">@dimen/text_font_size_medium</item>
        <item name="android:textColorLink">#0000ff</item>
    </style>
    <!--
      ======================= 标准字体样式 =======================
      名称：TextAppearanceNormal
      父样式：无（直接定义）
      功能：定义标准字体（17sp）的文本外观
      使用场景：
      1. 便签编辑界面中的标准字体模式
      2. 紧凑显示模式
      3. 年轻用户偏好
      样式属性：
      1. textSize: @dimen/text_font_size_normal (17sp)
         - 使用dimens.xml中定义的标准字体尺寸
         - 接近系统默认字体大小
      2. textColorLink: #0000ff (纯蓝色)
         - 超链接文本的颜色
         - 统一的链接视觉识别
      设计考虑：
      - 17sp是Android应用中常见的标准大小
      - 适合显示较多内容
    -->
    <style name="TextAppearanceNormal">
        <item name="android:textSize">@dimen/text_font_size_normal</item>
        <item name="android:textColorLink">#0000ff</item>
    </style>
    <!--
      ======================= 主列表项文本样式 =======================
      名称：TextAppearancePrimaryItem
      父样式：无（直接定义）
      功能：定义便签列表中主项（文件夹/便签标题）的文本外观
      使用场景：
      1. 便签列表中的文件夹名称
      2. 便签列表中的便签标题/摘要
      3. 通话记录文件夹中的便签标题
      样式属性：
      1. textSize: @dimen/text_font_size_normal (17sp)
         - 使用标准字体大小
         - 确保列表项标题清晰可读
      2. textColor: @color/primary_text_dark
         - 主文本颜色，引用颜色资源
         - 应为较深的颜色，确保对比度和可读性
         - 对应颜色值可能在colors.xml中定义
      视觉设计：
      - 字体适中：17sp在列表中清晰但不占太多空间
      - 颜色突出：较深颜色突出主项内容
      - 层级明确：作为列表的主要信息层级
    -->
    <style name="TextAppearancePrimaryItem">
        <item name="android:textSize">@dimen/text_font_size_normal</item>
        <item name="android:textColor">@color/primary_text_dark</item>
    </style>
    <!--
      ======================= 副列表项文本样式 =======================
      名称：TextAppearanceSecondaryItem
      父样式：无（直接定义）
      功能：定义便签列表中副项（通话记录联系人）的文本外观
      使用场景：
      1. 通话记录文件夹中的联系人姓名
      2. 可能需要区分的次要信息
      样式属性：
      1. textSize: @dimen/text_font_size_small (14sp)
         - 使用小字体大小
         - 表示次要信息，不喧宾夺主
      2. textColor: @color/secondary_text_dark
         - 副文本颜色，引用颜色资源
         - 应比主文本颜色略浅，表示次要层级
         - 对应颜色值可能在colors.xml中定义
      视觉设计：
      - 字体较小：14sp表示次要信息
      - 颜色较浅：与主项形成视觉层次
      - 用途特定：专为通话记录联系人设计
    -->
    <style name="TextAppearanceSecondaryItem">
        <item name="android:textSize">@dimen/text_font_size_small</item>
        <item name="android:textColor">@color/secondary_text_dark</item>
    </style>
    <!--
      ======================= 菜单图标下文本样式 =======================
      名称：TextAppearanceUnderMenuIcon
      父样式：无（直接定义）
      功能：定义菜单图标下方说明文本的外观
      使用场景：
      1. 菜单图标下方的标签文本
      2. 工具栏图标的说明文字
      3. 底部导航的标签
      样式属性：
      1. textSize: @dimen/text_font_size_normal (17sp)
         - 使用标准字体大小
         - 确保标签清晰可读
      2. textColor: @android:color/black
         - 使用系统定义的黑色
         - 在浅色主题上确保对比度
         - 标准黑色：#000000
      设计考虑：
      - 通用性：使用系统颜色资源
      - 可读性：黑色在浅色背景上清晰
      - 一致性：与系统菜单样式协调
    -->
    <style name="TextAppearanceUnderMenuIcon">
        <item name="android:textSize">@dimen/text_font_size_normal</item>
        <item name="android:textColor">@android:color/black</item>
    </style>
    <!--
      ======================= 应用主题 =======================
      名称：NoteTheme
      父主题：@android:style/Theme.Holo.Light
      功能：定义便签应用的整体视觉主题
      使用场景：
      1. AndroidManifest.xml中应用全局主题
      2. 所有Activity继承此主题
      父主题说明：
      Theme.Holo.Light：Android 3.0+ 的浅色Holo主题
      - 浅色背景，深色文本
      - 蓝色高亮色
      - 现代、简洁的设计语言
      样式属性：
      1. actionBarStyle: @style/NoteActionBarStyle
         - 自定义操作栏样式
         - 覆盖父主题的操作栏样式
      主题特点：
      - 浅色主题：适合文本阅读类应用
      - Holo设计：Android 3.0+ 的标准设计语言
      - 一致性：与系统其他应用协调
      在AndroidManifest中的使用：
      <application
          android:theme="@style/NoteTheme"
          ...>
    -->
    <style name="NoteTheme" parent="@android:style/Theme.Holo.Light">
        <item name="android:actionBarStyle">@style/NoteActionBarStyle</item>
        <item name="android:windowBackground">@android:color/white</item>
        <item name="android:textColor">@android:color/primary_text_light</item>
        <item name="android:textColorSecondary">@android:color/secondary_text_light</item>
    </style>
    <!--
      ======================= 操作栏样式 =======================
      名称：NoteActionBarStyle
      父样式：@android:style/Widget.Holo.Light.ActionBar.Solid
      功能：定义便签应用操作栏的具体样式
      使用场景：
      1. 应用所有Activity的操作栏
      2. 继承自NoteTheme主题
      父样式说明：
      Widget.Holo.Light.ActionBar.Solid：
      - 浅色Holo主题的实心操作栏
      - 标准操作栏部件样式
      样式属性：
      1. visibility: visible
         - 确保操作栏可见
         - 可能用于覆盖某些主题的隐藏设置
      设计考虑：
      - 保持可见：便签应用需要操作栏提供导航和菜单
      - 继承系统样式：确保与系统协调
      - 简单定制：只修改必要的属性
    -->
    <style name="NoteActionBarStyle" parent="@android:style/Widget.Holo.Light.ActionBar.Solid">
        <item name="android:visibility">visible</item>
        <item name="android:background">@android:color/white</item>
        <item name="android:titleTextStyle">@android:style/TextAppearance.Holo.Widget.ActionBar.Title</item>
    </style>
 </resources>
--- a/res/xml/searchable.xml
+++ b/res/xml/searchable.xml
@ -1,148 +0,0 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!--
  ============================================================================
  searchable.xml - Android可搜索配置资源文件
  ============================================================================
  功能：定义便签应用与Android系统搜索框架的集成配置
  位置：res/xml/searchable.xml
  用途：将便签内容集成到Android全局搜索系统
  ============================================================================
  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.
  ============================================================================
 -->
 <!--
  ======================= 搜索配置定义 =======================
  searchable元素：Android搜索框架的核心配置元素
  所有搜索相关属性都在此元素中定义
  注意：XML注释必须完全在元素外部，不能在元素开始标记内
 -->
 <searchable
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:label="@string/search_label"
    android:hint="@string/search_hint"
    android:searchMode="queryRewriteFromText"
    android:searchSuggestAuthority="micode_notes"
    android:searchSuggestIntentAction="android.intent.action.VIEW"
    android:searchSettingsDescription="@string/search_setting_description"
    android:includeInGlobalSearch="true" />
    <!--
      ======================= Android命名空间声明 =======================
      属性：xmlns:android
      值：http://schemas.android.com/apk/res/android
      功能：声明Android框架的XML命名空间
      用途：使代码能够使用Android特定的属性和资源
      要求：必须是searchable元素的第一个属性
      注意：命名空间URI是固定的，不能更改
    -->
    <!--
      ======================= 搜索应用显示标签 =======================
      属性：android:label
      值：@string/search_label
      功能：在系统搜索设置界面中显示的便签应用名称
      对应字符串：R.string.search_label = "Searching Notes"
      用户可见：用户在系统设置→搜索→可搜索项中看到此名称
      重要性：帮助用户识别和启用便签的搜索功能
    -->
    <!--
      ======================= 搜索输入框提示文本 =======================
      属性：android:hint
      值：@string/search_hint
      功能：在搜索输入框中显示的灰色占位提示文本
      对应字符串：R.string.search_hint = "Search notes"
      用户引导：提示用户在便签中搜索内容
      设计：简洁明了，使用动词开头
    -->
    <!--
      ======================= 搜索结果呈现模式 =======================
      属性：android:searchMode
      值：queryRewriteFromText
      功能：定义用户从搜索结果进入应用时的数据传递方式
      模式说明：queryRewriteFromText表示传递搜索查询文本
      处理流程：
        1. 用户从系统搜索选择便签结果
        2. 系统将搜索查询文本传递给便签应用
        3. 应用接收文本并执行搜索逻辑
        4. 应用显示自定义的搜索结果界面
      优势：应用完全控制搜索逻辑和结果显示
    -->
    <!--
      ======================= 搜索建议数据源标识 =======================
      属性：android:searchSuggestAuthority
      值：notes
      功能：定义提供实时搜索建议的ContentProvider权限
      技术实现：对应AndroidManifest.xml中的ContentProvider声明
      工作机制：
        1. 用户在搜索框输入时，系统查询此数据源
        2. 系统向content://notes/search_suggest_query发送查询
        3. ContentProvider返回匹配的便签建议
        4. 系统显示建议列表供用户选择
      要求：应用需实现对应的ContentProvider支持搜索建议
    -->
    <!--
      ======================= 搜索建议点击动作 =======================
      属性：android:searchSuggestIntentAction
      值：android.intent.action.VIEW
      功能：定义用户点击搜索建议时系统创建的Intent动作
      动作说明：ACTION_VIEW表示查看内容的标准动作
      处理流程：
        1. 用户从搜索建议列表选择一项
        2. 系统创建ACTION_VIEW Intent
        3. Intent包含选中便签的数据URI
        4. 系统启动能够处理此Intent的Activity
        5. NoteEditActivity接收并显示便签内容
      数据格式：Intent包含content://notes/notes/便签ID
    -->
    <!--
      ======================= 搜索功能描述文本 =======================
      属性：android:searchSettingsDescription
      值：@string/search_setting_description
      功能：在系统搜索设置中显示的详细功能描述
      对应字符串：R.string.search_setting_description = "Text in your notes"
      用户可见：用户点击搜索设置项时看到的说明
      设计目的：明确告知用户搜索的内容范围
      重要性：帮助用户理解便签搜索功能
    -->
    <!--
      ======================= 全局搜索集成开关 =======================
      属性：android:includeInGlobalSearch
      值：true
      功能：控制是否将便签内容集成到Android全局搜索
      启用效果：
        1. 便签内容出现在系统全局搜索结果中
        2. 用户可从任何地方搜索便签内容
        3. 支持多种搜索入口：
           - 设备搜索物理键
           - 桌面搜索小部件
           - 语音搜索命令
           - 快捷搜索方式
      用户控制：用户可在系统设置中禁用此集成
      设计理念：提供统一的无缝搜索体验
    -->
--- a/res/xml/widget_2x_info.xml
+++ b/res/xml/widget_2x_info.xml
@ -1,71 +0,0 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!--
  ============================================================================
  widget_2x_info.xml - 2x2便签小部件配置
  ============================================================================
  位置：res/xml/widget_2x_info.xml
  功能：定义2x2便签小部件的基本属性
  ============================================================================
  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.
  ============================================================================
 -->
 <!--
  ======================= 2x2小部件提供者配置 =======================
  文件：widget_2x_info.xml
  用途：配置NoteWidgetProvider_2x小部件的元数据
  关联：AndroidManifest.xml中的meta-data引用此文件
 -->
 <appwidget-provider
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:initialLayout="@layout/widget_2x"
    android:minWidth="146dip"
    android:minHeight="146dip">
    </appwidget-provider>
    <!--
      ======================= Android命名空间 =======================
      属性：xmlns:android
      值：http://schemas.android.com/apk/res/android
      功能：声明Android框架的XML命名空间
    -->
    <!--
      ======================= 小部件初始布局 =======================
      属性：android:initialLayout
      值：@layout/widget_2x
      功能：指定小部件使用的布局文件
      布局：R.layout.widget_2x 定义2x2小部件界面
    -->
    <!--
      ======================= 小部件最小宽度 =======================
      属性：android:minWidth
      值：146dip
      功能：定义小部件在桌面的最小宽度
      计算：2个网格单元格 × 74dp ≈ 146dp
    -->
    <!--
      ======================= 小部件最小高度 =======================
      属性：android:minHeight
      值：146dip
      功能：定义小部件在桌面的最小高度
      设计：正方形小部件，宽度高度相等
    -->
--- a/res/xml/widget_4x_info.xml
+++ b/res/xml/widget_4x_info.xml
@ -1,76 +0,0 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!-- 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.
 -->
 <!--
  ======================= 4x4便签小部件配置文件 =======================
  文件：widget_4x_info.xml
  对应：NoteWidgetProvider_4x 小部件提供者
  引用：在AndroidManifest.xml的meta-data中引用
  作用：定义4x4便签小部件在桌面上的基本属性
 -->
 <!--
  ======================= 小部件提供者配置元素 =======================
  appwidget-provider：Android小部件配置的核心元素
  包含小部件的基本属性定义
 -->
 <appwidget-provider
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:initialLayout="@layout/widget_4x"
    android:minWidth="294dip"
    android:minHeight="294dip">
    </appwidget-provider>
    <!--
      ======================= Android框架命名空间 =======================
      xmlns:android：声明Android框架的XML命名空间
      值：标准的Android命名空间URI
      作用：启用Android特定的XML属性和资源引用
      位置：必须是appwidget-provider的第一个属性
    -->
    <!--
      ======================= 4x4小部件初始布局 =======================
      android:initialLayout：指定小部件的初始布局文件
      值：@layout/widget_4x
      对应文件：res/layout/widget_4x.xml
      内容：4x4便签小部件的界面布局
      包含：背景图片、便签文本显示、点击区域
    -->
    <!--
      ======================= 4x4小部件最小宽度 =======================
      android:minWidth：定义小部件在桌面网格中的最小宽度
      值：294dip (density-independent pixels)
      计算：4个网格单元格 × 74dp ≈ 296dp
      实际：294dp (考虑边距和渲染误差)
      单位：dip等同于dp，旧版Android使用的单位
      作用：确保小部件至少占用4个网格宽度
    -->
    <!--
      ======================= 4x4小部件最小高度 =======================
      android:minHeight：定义小部件在桌面网格中的最小高度
      值：294dip
      计算：与宽度相同，4×74≈296dp
      实际：294dp
      设计：正方形小部件，宽度和高度相等
      布局：4×4网格，提供较大的显示区域
    -->
--- a/src/Notes-master/.gitignore
+++ b/src/Notes-master/.gitignore
@ -0,0 +1,9 @@
 # generated files
 bin/
 gen/
 # Local configuration file (sdk path, etc)
 project.properties
 .settings/
 .classpath
 .project
--- a/src/Notes-master/.gradle/7.3.3/checksums/checksums.lock
+++ b/src/Notes-master/.gradle/7.3.3/checksums/checksums.lock
--- a/src/Notes-master/.gradle/7.3.3/fileChanges/last-build.bin
+++ b/src/Notes-master/.gradle/7.3.3/fileChanges/last-build.bin
--- a/src/Notes-master/.gradle/7.3.3/fileHashes/fileHashes.lock
+++ b/src/Notes-master/.gradle/7.3.3/fileHashes/fileHashes.lock
--- a/src/Notes-master/.gradle/7.3.3/gc.properties
+++ b/src/Notes-master/.gradle/7.3.3/gc.properties
--- a/src/Notes-master/.gradle/8.5/checksums/checksums.lock
+++ b/src/Notes-master/.gradle/8.5/checksums/checksums.lock
--- a/src/Notes-master/.gradle/8.5/checksums/md5-checksums.bin
+++ b/src/Notes-master/.gradle/8.5/checksums/md5-checksums.bin
--- a/src/Notes-master/.gradle/8.5/checksums/sha1-checksums.bin
+++ b/src/Notes-master/.gradle/8.5/checksums/sha1-checksums.bin
--- a/src/Notes-master/.gradle/8.5/dependencies-accessors/dependencies-accessors.lock
+++ b/src/Notes-master/.gradle/8.5/dependencies-accessors/dependencies-accessors.lock
--- a/src/Notes-master/.gradle/8.5/dependencies-accessors/gc.properties
+++ b/src/Notes-master/.gradle/8.5/dependencies-accessors/gc.properties
--- a/src/Notes-master/.gradle/8.5/fileChanges/last-build.bin
+++ b/src/Notes-master/.gradle/8.5/fileChanges/last-build.bin
--- a/src/Notes-master/.gradle/8.5/fileHashes/fileHashes.lock
+++ b/src/Notes-master/.gradle/8.5/fileHashes/fileHashes.lock
--- a/src/Notes-master/.gradle/8.5/gc.properties
+++ b/src/Notes-master/.gradle/8.5/gc.properties
--- a/src/Notes-master/.gradle/buildOutputCleanup/buildOutputCleanup.lock
+++ b/src/Notes-master/.gradle/buildOutputCleanup/buildOutputCleanup.lock
--- a/src/Notes-master/.gradle/buildOutputCleanup/cache.properties
+++ b/src/Notes-master/.gradle/buildOutputCleanup/cache.properties
@ -0,0 +1,2 @@
 #Thu Nov 13 20:58:02 CST 2025
 gradle.version=8.5
--- a/src/Notes-master/.gradle/vcs-1/gc.properties
+++ b/src/Notes-master/.gradle/vcs-1/gc.properties
--- a/src/Notes-master/.idea/.gitignore
+++ b/src/Notes-master/.idea/.gitignore
@ -0,0 +1,3 @@
 # Default ignored files
 /shelf/
 /workspace.xml
--- a/src/Notes-master/.idea/AndroidProjectSystem.xml
+++ b/src/Notes-master/.idea/AndroidProjectSystem.xml
@ -0,0 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="AndroidProjectSystem">
    <option name="providerId" value="com.android.tools.idea.GradleProjectSystem" />
  </component>
 </project>
--- a/src/Notes-master/.idea/gradle.xml
+++ b/src/Notes-master/.idea/gradle.xml
@ -0,0 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="GradleMigrationSettings" migrationVersion="1" />
  <component name="GradleSettings">
    <option name="linkedExternalProjectsSettings">
      <GradleProjectSettings>
        <option name="testRunner" value="CHOOSE_PER_TEST" />
        <option name="externalProjectPath" value="$PROJECT_DIR$" />
        <option name="gradleJvm" value="jbr-21" />
      </GradleProjectSettings>
    </option>
  </component>
 </project>
--- a/src/Notes-master/.idea/misc.xml
+++ b/src/Notes-master/.idea/misc.xml
@ -0,0 +1,6 @@
 <project version="4">
  <component name="ExternalStorageConfigurationManager" enabled="true" />
  <component name="ProjectRootManager" version="2" project-jdk-name="Android API 36.0, extension level 17 Platform" project-jdk-type="Android SDK">
    <output url="file://$PROJECT_DIR$/out" />
  </component>
 </project>
--- a/src/Notes-master/.idea/modules.xml
+++ b/src/Notes-master/.idea/modules.xml
@ -0,0 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="ProjectModuleManager">
    <modules>
      <module fileurl="file://$PROJECT_DIR$/Notes-master.iml" filepath="$PROJECT_DIR$/Notes-master.iml" />
    </modules>
  </component>
 </project>
--- a/src/Notes-master/.idea/runConfigurations.xml
+++ b/src/Notes-master/.idea/runConfigurations.xml
@ -0,0 +1,17 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="RunConfigurationProducerService">
    <option name="ignoredProducers">
      <set>
        <option value="com.intellij.execution.junit.AbstractAllInDirectoryConfigurationProducer" />
        <option value="com.intellij.execution.junit.AllInPackageConfigurationProducer" />
        <option value="com.intellij.execution.junit.PatternConfigurationProducer" />
        <option value="com.intellij.execution.junit.TestInClassConfigurationProducer" />
        <option value="com.intellij.execution.junit.UniqueIdConfigurationProducer" />
        <option value="com.intellij.execution.junit.testDiscovery.JUnitTestDiscoveryConfigurationProducer" />
        <option value="org.jetbrains.kotlin.idea.junit.KotlinJUnitRunConfigurationProducer" />
        <option value="org.jetbrains.kotlin.idea.junit.KotlinPatternConfigurationProducer" />
      </set>
    </option>
  </component>
 </project>
--- a/src/Notes-master/NOTICE
+++ b/src/Notes-master/NOTICE
@ -0,0 +1,190 @@
   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.
   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.
                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/
   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
   1. Definitions.
      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.
      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.
      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.
      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.
      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.
      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.
      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).
      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.
      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."
      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.
   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.
   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.
   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:
      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and
      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and
      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and
      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.
      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.
   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.
   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.
   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.
   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.
   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.
   END OF TERMS AND CONDITIONS
--- a/src/Notes-master/Notes-master.iml
+++ b/src/Notes-master/Notes-master.iml
@ -0,0 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module type="JAVA_MODULE" version="4">
  <component name="NewModuleRootManager" inherit-compiler-output="true">
    <exclude-output />
    <content url="file://$MODULE_DIR$">
      <sourceFolder url="file://$MODULE_DIR$/app/src/main/java/src" isTestSource="false" />
    </content>
    <orderEntry type="inheritedJdk" />
    <orderEntry type="sourceFolder" forTests="false" />
  </component>
 </module>
--- a/src/Notes-master/README
+++ b/src/Notes-master/README
@ -0,0 +1,23 @@
 [中文]
 1. MiCode便签是小米便签的社区开源版，由MIUI团队(www.miui.com) 发起并贡献第一批代码，遵循NOTICE文件所描述的开源协议，
   今后为MiCode社区(www.micode.net) 拥有，并由社区发布和维护。
 2. Bug反馈和跟踪，请访问Github,
   https://github.com/MiCode/Notes/issues?sort=created&direction=desc&state=open
 3. 功能建议和综合讨论，请访问MiCode,
   http://micode.net/forum.php?mod=forumdisplay&fid=38
 [English]
 1. MiCode Notes is open source edition of XM notepad, it's first initiated and sponsored by MIUI team (www.miui.com).
   It's opened under license described by NOTICE file. It's owned by the MiCode community (www.micode.net). In future,
   the MiCode community will release and maintain this project.
 2. Regarding issue tracking, please visit Github,
   https://github.com/MiCode/Notes/issues?sort=created&direction=desc&state=open
 3. Regarding feature request and general discussion, please visit Micode forum,
   http://micode.net/forum.php?mod=forumdisplay&fid=38
--- a/src/Notes-master/app/build.gradle
+++ b/src/Notes-master/app/build.gradle
@ -0,0 +1,34 @@
 plugins {
    id 'com.android.application'
 }
 android {
    compileSdk 32
    defaultConfig {
        applicationId "com.miui.notes"
        minSdk 21
        targetSdk 32
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
    // 关键：设置Java版本为17
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_17
        targetCompatibility JavaVersion.VERSION_17
    }
 }
 dependencies {
    implementation 'androidx.appcompat:appcompat:1.4.2'
    implementation 'com.google.android.material:material:1.6.1'
    implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
 }
--- a/src/Notes-master/app/src/main/AndroidManifest.xml
+++ b/src/Notes-master/app/src/main/AndroidManifest.xml
@ -0,0 +1,150 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!-- 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.
 -->
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="net.micode.notes"
    android:versionCode="1"
    android:versionName="0.1" >
    <uses-sdk android:minSdkVersion="14" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="com.android.launcher.permission.INSTALL_SHORTCUT" />
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.READ_CONTACTS" />
    <uses-permission android:name="android.permission.MANAGE_ACCOUNTS" />
    <uses-permission android:name="android.permission.AUTHENTICATE_ACCOUNTS" />
    <uses-permission android:name="android.permission.GET_ACCOUNTS" />
    <uses-permission android:name="android.permission.USE_CREDENTIALS" />
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
    <application
        android:icon="@drawable/icon_app"
        android:label="@string/app_name" >
        <activity
            android:name=".ui.NotesListActivity"
            android:configChanges="keyboardHidden|orientation|screenSize"
            android:label="@string/app_name"
            android:launchMode="singleTop"
            android:theme="@style/NoteTheme"
            android:uiOptions="splitActionBarWhenNarrow"
            android:windowSoftInputMode="adjustPan" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity
            android:name=".ui.NoteEditActivity"
            android:configChanges="keyboardHidden|orientation|screenSize"
            android:launchMode="singleTop"
            android:theme="@style/NoteTheme" >
            <intent-filter>
                <action android:name="android.intent.action.VIEW" />
                <category android:name="android.intent.category.DEFAULT" />
                <data android:mimeType="vnd.android.cursor.item/text_note" />
                <data android:mimeType="vnd.android.cursor.item/call_note" />
            </intent-filter>
            <intent-filter>
                <action android:name="android.intent.action.INSERT_OR_EDIT" />
                <category android:name="android.intent.category.DEFAULT" />
                <data android:mimeType="vnd.android.cursor.item/text_note" />
                <data android:mimeType="vnd.android.cursor.item/call_note" />
            </intent-filter>
            <intent-filter>
                <action android:name="android.intent.action.SEARCH" />
                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
            <meta-data
                android:name="android.app.searchable"
                android:resource="@xml/searchable" />
        </activity>
        <provider
            android:name="net.micode.notes.data.NotesProvider"
            android:authorities="micode_notes"
            android:multiprocess="true" />
        <receiver
            android:name=".widget.NoteWidgetProvider_2x"
            android:label="@string/app_widget2x2" >
            <intent-filter>
                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
                <action android:name="android.appwidget.action.APPWIDGET_DELETED" />
                <action android:name="android.intent.action.PRIVACY_MODE_CHANGED" />
            </intent-filter>
            <meta-data
                android:name="android.appwidget.provider"
                android:resource="@xml/widget_2x_info" />
        </receiver>
        <receiver
            android:name=".widget.NoteWidgetProvider_4x"
            android:label="@string/app_widget4x4" >
            <intent-filter>
                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
                <action android:name="android.appwidget.action.APPWIDGET_DELETED" />
                <action android:name="android.intent.action.PRIVACY_MODE_CHANGED" />
            </intent-filter>
            <meta-data
                android:name="android.appwidget.provider"
                android:resource="@xml/widget_4x_info" />
        </receiver>
        <receiver android:name=".ui.AlarmInitReceiver" >
            <intent-filter>
                <action android:name="android.intent.action.BOOT_COMPLETED" />
            </intent-filter>
        </receiver>
        <receiver
            android:name="net.micode.notes.ui.AlarmReceiver"
            android:process=":remote" >
        </receiver>
        <activity
            android:name=".ui.AlarmAlertActivity"
            android:label="@string/app_name"
            android:launchMode="singleInstance"
            android:theme="@android:style/Theme.Holo.Wallpaper.NoTitleBar" >
        </activity>
        <activity
            android:name="net.micode.notes.ui.NotesPreferenceActivity"
            android:label="@string/preferences_title"
            android:launchMode="singleTop"
            android:theme="@android:style/Theme.Holo.Light" >
        </activity>
        <service
            android:name="net.micode.notes.gtask.remote.GTaskSyncService"
            android:exported="false" >
        </service>
        <meta-data
            android:name="android.app.default_searchable"
            android:value=".ui.NoteEditActivity" />
    </application>
 </manifest>
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/data/Contact.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/data/Contact.java
@ -0,0 +1,73 @@
 /*
 * 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.Context;
 import android.database.Cursor;
 import android.provider.ContactsContract.CommonDataKinds.Phone;
 import android.provider.ContactsContract.Data;
 import android.telephony.PhoneNumberUtils;
 import android.util.Log;
 import java.util.HashMap;
 public class Contact {
    private static HashMap<String, String> sContactCache;
    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));
        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;
        }
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/data/Notes.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/data/Notes.java
@ -0,0 +1,279 @@
 /*
 * 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.net.Uri;
 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;
    /**
     * 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;
    public static final int ID_TEMPARAY_FOLDER = -1;
    public static final int ID_CALL_RECORD_FOLDER = -2;
    public static final int ID_TRASH_FOLER = -3;
    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";
    public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_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";
    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;
    public static final int TYPE_WIDGET_4X            = 1;
    public static class DataConstants {
        public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
        public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
    }
    /**
     * Uri to query all notes and folders
     */
    public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
    /**
     * Uri to query data
     */
    public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
    public interface NoteColumns {
        /**
         * The unique ID for a row
         * <P> Type: INTEGER (long) </P>
         */
        public static final String ID = "_id";
        /**
         * The parent's id for note or folder
         * <P> Type: INTEGER (long) </P>
         */
        public static final String PARENT_ID = "parent_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";
        /**
         * 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";
        /**
         * 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";
        /**
         * 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";
        /**
         * The gtask id
         * <P> Type : TEXT </P>
         */
        public static final String GTASK_ID = "gtask_id";
        /**
         * The version code
         * <P> Type : INTEGER (long) </P>
         */
        public static final String VERSION = "version";
    }
    public interface DataColumns {
        /**
         * The unique ID for a row
         * <P> Type: INTEGER (long) </P>
         */
        public static final String ID = "_id";
        /**
         * The MIME type of the item represented by this row.
         * <P> Type: Text </P>
         */
        public static final String MIME_TYPE = "mime_type";
        /**
         * The reference id to note that this data belongs to
         * <P> Type: INTEGER (long) </P>
         */
        public static final String NOTE_ID = "note_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";
    }
    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;
        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";
        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";
        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
    }
    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;
        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";
        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";
        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/data/NotesDatabaseHelper.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/data/NotesDatabaseHelper.java
@ -0,0 +1,362 @@
 /*
 * 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;
    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" +
        ")";
    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 ''" +
        ")";
    private static final String CREATE_DATA_NOTE_ID_INDEX_SQL =
        "CREATE INDEX IF NOT EXISTS note_id_index ON " +
        TABLE.DATA + "(" + DataColumns.NOTE_ID + ");";
    /**
     * Increase folder's note count when move note to the folder
     */
    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";
    /**
     * Decrease folder's note count when move note from folder
     */
    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";
    /**
     * Increase folder's note count when insert new note to the folder
     */
    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";
    /**
     * Decrease folder's note count when delete note from the folder
     */
    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";
    /**
     * Update note's content when insert data with type {@link DataConstants#NOTE}
     */
    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";
    /**
     * Update note's content when data with {@link DataConstants#NOTE} type has changed
     */
    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";
    /**
     * Update note's content when data with {@link DataConstants#NOTE} type has deleted
     */
    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";
    /**
     * Delete datas belong to note which has been deleted
     */
    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";
    /**
     * Delete notes belong to folder which has been deleted
     */
    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";
    /**
     * Move notes belong to folder which has been moved to trash folder
     */
    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();
        /**
         * call record foler for call notes
         */
        values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER);
        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
        db.insert(TABLE.NOTE, null, values);
        /**
         * root folder which is default folder
         */
        values.clear();
        values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER);
        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
        db.insert(TABLE.NOTE, null, values);
        /**
         * temporary folder which is used for moving note
         */
        values.clear();
        values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER);
        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
        db.insert(TABLE.NOTE, null, values);
        /**
         * create trash folder
         */
        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");
        }
    }
    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);
    }
    private void upgradeToV3(SQLiteDatabase db) {
        // drop unused triggers
        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");
        // add a column for gtask id
        db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID
                + " TEXT NOT NULL DEFAULT ''");
        // add a trash system folder
        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);
    }
    private void upgradeToV4(SQLiteDatabase db) {
        db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
                + " INTEGER NOT NULL DEFAULT 0");
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/data/NotesProvider.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/data/NotesProvider.java
@ -0,0 +1,305 @@
 /*
 * 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;
 public class NotesProvider extends ContentProvider {
    private static final UriMatcher mMatcher;
    private NotesDatabaseHelper mHelper;
    private static final String TAG = "NotesProvider";
    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;
    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)) {
            case URI_NOTE:
                c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
                        sortOrder);
                break;
            case URI_NOTE_ITEM:
                id = uri.getPathSegments().get(1);
                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);
                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);
        }
        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)) {
            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);
                } 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);
    }
    @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)) {
            case URI_NOTE:
                selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 ";
                count = db.delete(TABLE.NOTE, selection, selectionArgs);
                break;
            case URI_NOTE_ITEM:
                id = uri.getPathSegments().get(1);
                /**
                 * 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);
                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)) {
            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);
                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);
                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());
    }
    @Override
    public String getType(Uri uri) {
        // TODO Auto-generated method stub
        return null;
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/data/MetaData.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/data/MetaData.java
@ -0,0 +1,82 @@
 /*
 * 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;
 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;
    }
    @Override
    public boolean isWorthSaving() {
        return getNotes() != null;
    }
    @Override
    public void setContentByRemoteJSON(JSONObject js) {
        super.setContentByRemoteJSON(js);
        if (getNotes() != null) {
            try {
                JSONObject metaInfo = new JSONObject(getNotes().trim());
                mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
            } catch (JSONException e) {
                Log.w(TAG, "failed to get related gid");
                mRelatedGid = null;
            }
        }
    }
    @Override
    public void setContentByLocalJSON(JSONObject js) {
        // this function should not be called
        throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
    }
    @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/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/data/Node.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/data/Node.java
@ -0,0 +1,101 @@
 /*
 * 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;
 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;
        mDeleted = false;
    }
    public abstract JSONObject getCreateAction(int actionId);
    public abstract JSONObject getUpdateAction(int actionId);
    public abstract void setContentByRemoteJSON(JSONObject js);
    public abstract void setContentByLocalJSON(JSONObject js);
    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/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/data/SqlData.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/data/SqlData.java
@ -0,0 +1,189 @@
 /*
 * 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;
 public class SqlData {
    private static final String TAG = SqlData.class.getSimpleName();
    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;
    private String mDataMimeType;
    private String mDataContent;
    private long mDataContentData1;
    private String mDataContentData3;
    private ContentValues mDiffDataValues;
    public SqlData(Context context) {
        mContentResolver = context.getContentResolver();
        mIsCreate = true;
        mDataId = INVALID_ID;
        mDataMimeType = DataConstants.NOTE;
        mDataContent = "";
        mDataContentData1 = 0;
        mDataContentData3 = "";
        mDiffDataValues = new ContentValues();
    }
    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);
    }
    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;
    }
    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;
    }
    public long getId() {
        return mDataId;
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/data/SqlNote.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/data/SqlNote.java
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/data/Task.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/data/Task.java
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/data/TaskList.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/data/TaskList.java
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/exception/ActionFailureException.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/exception/ActionFailureException.java
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/exception/NetworkFailureException.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/exception/NetworkFailureException.java
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/remote/GTaskASyncTask.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/remote/GTaskASyncTask.java
@ -1,3 +1,4 @@
 /*
 * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
 *
@ -17,15 +18,11 @@
 package net.micode.notes.gtask.remote;
 import android.app.Notification;
 import android.app.NotificationChannel;
 import android.app.NotificationManager;
 import android.app.PendingIntent;
 import android.content.Context;
 import android.content.Intent;
 import android.os.AsyncTask;
 import android.os.Build;
 import androidx.core.app.NotificationCompat;
 import net.micode.notes.R;
 import net.micode.notes.ui.NotesListActivity;
@ -35,7 +32,6 @@ import net.micode.notes.ui.NotesPreferenceActivity;
 public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
    private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
    private static final String CHANNEL_ID = "gtask_sync_channel"; // 新增通知渠道ID
    public interface OnCompleteListener {
        void onComplete();
@ -55,23 +51,6 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
        mNotifiManager = (NotificationManager) mContext
                .getSystemService(Context.NOTIFICATION_SERVICE);
        mTaskManager = GTaskManager.getInstance();
        // 初始化通知渠道（仅Android 8.0+需要）
        createNotificationChannel();
    }
    // 新增：创建通知渠道
    private void createNotificationChannel() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            CharSequence name = mContext.getString(R.string.app_name); // 渠道名称
            String description = "GTask同步通知"; // 渠道描述
            int importance = NotificationManager.IMPORTANCE_DEFAULT;
            NotificationChannel channel = new NotificationChannel(CHANNEL_ID, name, importance);
            channel.setDescription(description);
            // 向系统注册渠道
            if (mNotifiManager != null) {
                mNotifiManager.createNotificationChannel(channel);
            }
        }
    }
    public void cancelSync() {
@ -80,34 +59,27 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
    public void publishProgess(String message) {
        publishProgress(new String[] {
-                message
+            message
        });
    }
    private void showNotification(int tickerId, String content) {
-        // 替换为NotificationCompat.Builder构建通知
+        Notification notification = new Notification(R.drawable.notification, mContext
-        NotificationCompat.Builder builder = new NotificationCompat.Builder(mContext, CHANNEL_ID)
+                .getString(tickerId), System.currentTimeMillis());
-                .setSmallIcon(R.drawable.notification) // 保持原图标
+        notification.defaults = Notification.DEFAULT_LIGHTS;
-                .setContentTitle(mContext.getString(R.string.app_name)) // 原标题
+        notification.flags = Notification.FLAG_AUTO_CANCEL;
                .setContentText(content) // 原内容
                .setTicker(mContext.getString(tickerId)) // 原滚动提示文字
                .setWhen(System.currentTimeMillis()) // 原时间戳
                .setDefaults(Notification.DEFAULT_LIGHTS) // 保持原灯光效果
                .setAutoCancel(true); // 保持点击自动取消
        // 设置跳转意图（保持原逻辑）
        PendingIntent pendingIntent;
        if (tickerId != R.string.ticker_success) {
            pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
-                    NotesPreferenceActivity.class), PendingIntent.FLAG_IMMUTABLE); // 适配高版本
+                    NotesPreferenceActivity.class), 0);
        } else {
            pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
-                    NotesListActivity.class), PendingIntent.FLAG_IMMUTABLE); // 适配高版本
+                    NotesListActivity.class), 0);
        }
-        builder.setContentIntent(pendingIntent);
+        notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content,
-
+                pendingIntent);
-        // 发送通知（保持原ID）
+        mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
        mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, builder.build());
    }
    @Override
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/remote/GTaskClient.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/remote/GTaskClient.java
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/remote/GTaskManager.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/remote/GTaskManager.java
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/remote/GTaskSyncService.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/gtask/remote/GTaskSyncService.java
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/model/Note.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/model/Note.java
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/model/WorkingNote.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/model/WorkingNote.java
@ -29,7 +29,6 @@ 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;
@ -189,19 +188,6 @@ public class WorkingNote {
    }
    public synchronized boolean saveNote() {
        if (mIsDeleted && existInDatabase()) {
            // 如果便签已被标记为删除且存在于数据库中，则执行删除操作
            int rows = mContext.getContentResolver().delete(
                    ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId),
                    null, null);
            if (rows > 0) {
                Log.d(TAG, "Deleted empty note with id:" + mNoteId);
            } else {
                Log.e(TAG, "Failed to delete empty note with id:" + mNoteId);
            }
            return true;
        }
        if (isWorthSaving()) {
            if (!existInDatabase()) {
                if ((mNoteId = Note.getNewNoteId(mContext, mFolderId)) == 0) {
@ -210,11 +196,7 @@ public class WorkingNote {
                }
            }
-            // 更新便签数据
+            mNote.syncNote(mContext, mNoteId);
            mNote.setTextData(DataColumns.CONTENT, mContent);
            // 同步到数据库
            boolean result = mNote.syncNote(mContext, mNoteId);
            /**
             * Update widget content if there exist any widget of this note
@ -224,7 +206,7 @@ public class WorkingNote {
                    && mNoteSettingStatusListener != null) {
                mNoteSettingStatusListener.onWidgetChanged();
            }
-            return result;
+            return true;
        } else {
            return false;
        }
@ -235,24 +217,12 @@ public class WorkingNote {
    }
    private boolean isWorthSaving() {
-        if (mIsDeleted) {
+        if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
-            return false;
+                || (existInDatabase() && !mNote.isLocalModified())) {
        }
        // 如果便签不存在于数据库且内容为空，则不值得保存
        if (!existInDatabase() && TextUtils.isEmpty(mContent)) {
            return false;
        }
        // 如果便签已存在于数据库但内容为空，则需要删除它
        if (existInDatabase() && TextUtils.isEmpty(mContent)) {
            // 标记为需要删除
            mIsDeleted = true;
            return false;
        }
        // 如果便签已存在于数据库但未被修改，则不需要保存
        if (existInDatabase() && !mNote.isLocalModified()) {
            return false;
        } else {
            return true;
        }
        return true;
    }
    public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
@ -372,8 +342,6 @@ public class WorkingNote {
        return mWidgetType;
    }
    public interface NoteSettingChangedListener {
        /**
         * Called when the background color of current note has just changed
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/tool/BackupUtils.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/tool/BackupUtils.java
@ -0,0 +1,344 @@
 /*
 * 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;
 public class BackupUtils {
    private static final String TAG = "BackupUtils";
    // Singleton stuff
    private static BackupUtils sInstance;
    public static synchronized BackupUtils getInstance(Context context) {
        if (sInstance == null) {
            sInstance = new BackupUtils(context);
        }
        return sInstance;
    }
    /**
     * Following states are signs to represents backup or restore
     * status
     */
    // Currently, the sdcard is not mounted
    public static final int STATE_SD_CARD_UNMOUONTED           = 0;
    // The backup file not exist
    public static final int STATE_BACKUP_FILE_NOT_EXIST        = 1;
    // The data is not well formated, may be changed by other programs
    public static final int STATE_DATA_DESTROIED               = 2;
    // Some run-time exception which causes restore or backup fails
    public static final int STATE_SYSTEM_ERROR                 = 3;
    // Backup or restore success
    public static final int STATE_SUCCESS                      = 4;
    private TextExport mTextExport;
    private BackupUtils(Context context) {
        mTextExport = new TextExport(context);
    }
    private static boolean externalStorageAvailable() {
        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;
    }
    private static class TextExport {
        private static final String[] NOTE_PROJECTION = {
                NoteColumns.ID,
                NoteColumns.MODIFIED_DATE,
                NoteColumns.SNIPPET,
                NoteColumns.TYPE
        };
        private static final int NOTE_COLUMN_ID = 0;
        private static final int NOTE_COLUMN_MODIFIED_DATE = 1;
        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,
        };
        private static final int DATA_COLUMN_CONTENT = 0;
        private static final int DATA_COLUMN_MIME_TYPE = 1;
        private static final int DATA_COLUMN_CALL_DATE = 2;
        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;
        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];
        }
        /**
         * Export the folder identified by folder id to text
         */
        private void exportFolderToText(String folderId, PrintStream ps) {
            // Query notes belong to this folder
            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 {
                        // Print note's last modified date
                        ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
                                mContext.getString(R.string.format_datetime_mdhm),
                                notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
                        // Query data belong to this note
                        String noteId = notesCursor.getString(NOTE_COLUMN_ID);
                        exportNoteToText(noteId, ps);
                    } while (notesCursor.moveToNext());
                }
                notesCursor.close();
            }
        }
        /**
         * Export note identified by id to a print stream
         */
        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 {
                        String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE);
                        if (DataConstants.CALL_NOTE.equals(mimeType)) {
                            // Print phone number
                            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));
                            }
                            // Print call date
                            ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), DateFormat
                                    .format(mContext.getString(R.string.format_datetime_mdhm),
                                            callDate)));
                            // Print call attachment location
                            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();
            }
            // print a line separator between note
            try {
                ps.write(new byte[] {
                        Character.LINE_SEPARATOR, Character.LETTER_NUMBER
                });
            } catch (IOException e) {
                Log.e(TAG, e.toString());
            }
        }
        /**
         * Note will be exported as text which is user readable
         */
        public int exportToText() {
            if (!externalStorageAvailable()) {
                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;
            }
            // First export folder and its notes
            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 {
                        // Print folder's name
                        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));
                        }
                        String folderId = folderCursor.getString(NOTE_COLUMN_ID);
                        exportFolderToText(folderId, ps);
                    } while (folderCursor.moveToNext());
                }
                folderCursor.close();
            }
            // Export notes in root's folder
            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))));
                        // Query data belong to this note
                        String noteId = noteCursor.getString(NOTE_COLUMN_ID);
                        exportNoteToText(noteId, ps);
                    } while (noteCursor.moveToNext());
                }
                noteCursor.close();
            }
            ps.close();
            return STATE_SUCCESS;
        }
        /**
         * Get a print stream pointed to the file {@generateExportedTextFile}
         */
        private PrintStream getExportToTextPrintStream() {
            File file = generateFileMountedOnSDcard(mContext, R.string.file_path,
                    R.string.file_name_txt_format);
            if (file == 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) {
                e.printStackTrace();
                return null;
            } catch (NullPointerException e) {
                e.printStackTrace();
                return null;
            }
            return ps;
        }
    }
    /**
     * Generate the text file to store imported data
     */
    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) {
            e.printStackTrace();
        }
        return null;
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/tool/DataUtils.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/tool/DataUtils.java
@ -0,0 +1,295 @@
 /*
 * 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;
 public class DataUtils {
    public static final String TAG = "DataUtils";
    public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
        if (ids == null) {
            Log.d(TAG, "the ids is null");
            return true;
        }
        if (ids.size() == 0) {
            Log.d(TAG, "no id is in the hashset");
            return true;
        }
        ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
        for (long id : ids) {
            if(id == Notes.ID_ROOT_FOLDER) {
                Log.e(TAG, "Don't delete system folder root");
                continue;
            }
            ContentProviderOperation.Builder builder = ContentProviderOperation
                    .newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
            operationList.add(builder.build());
        }
        try {
            ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
            if (results == null || results.length == 0 || results[0] == null) {
                Log.d(TAG, "delete notes failed, ids:" + ids.toString());
                return false;
            }
            return true;
        } catch (RemoteException e) {
            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
        } catch (OperationApplicationException e) {
            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
        }
        return false;
    }
    public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
        ContentValues values = new ContentValues();
        values.put(NoteColumns.PARENT_ID, desFolderId);
        values.put(NoteColumns.ORIGIN_PARENT_ID, srcFolderId);
        values.put(NoteColumns.LOCAL_MODIFIED, 1);
        resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
    }
    public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids,
            long folderId) {
        if (ids == null) {
            Log.d(TAG, "the ids is null");
            return true;
        }
        ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
        for (long id : ids) {
            ContentProviderOperation.Builder builder = ContentProviderOperation
                    .newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
            builder.withValue(NoteColumns.PARENT_ID, folderId);
            builder.withValue(NoteColumns.LOCAL_MODIFIED, 1);
            operationList.add(builder.build());
        }
        try {
            ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
            if (results == null || results.length == 0 || results[0] == null) {
                Log.d(TAG, "delete notes failed, ids:" + ids.toString());
                return false;
            }
            return true;
        } catch (RemoteException e) {
            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
        } catch (OperationApplicationException e) {
            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
        }
        return false;
    }
    /**
     * Get the all folder count except system folders {@link Notes#TYPE_SYSTEM}}
     */
    public static int getUserFolderCount(ContentResolver resolver) {
        Cursor cursor =resolver.query(Notes.CONTENT_NOTE_URI,
                new String[] { "COUNT(*)" },
                NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>?",
                new String[] { String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER)},
                null);
        int count = 0;
        if(cursor != null) {
            if(cursor.moveToFirst()) {
                try {
                    count = cursor.getInt(0);
                } catch (IndexOutOfBoundsException e) {
                    Log.e(TAG, "get folder count failed:" + e.toString());
                } finally {
                    cursor.close();
                }
            }
        }
        return count;
    }
    public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
                null,
                NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER,
                new String [] {String.valueOf(type)},
                null);
        boolean exist = false;
        if (cursor != null) {
            if (cursor.getCount() > 0) {
                exist = true;
            }
            cursor.close();
        }
        return exist;
    }
    public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
                null, null, null, null);
        boolean exist = false;
        if (cursor != null) {
            if (cursor.getCount() > 0) {
                exist = true;
            }
            cursor.close();
        }
        return exist;
    }
    public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId),
                null, null, null, null);
        boolean exist = false;
        if (cursor != null) {
            if (cursor.getCount() > 0) {
                exist = true;
            }
            cursor.close();
        }
        return exist;
    }
    public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,
                NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER +
                " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER +
                " AND " + NoteColumns.SNIPPET + "=?",
                new String[] { name }, null);
        boolean exist = false;
        if(cursor != null) {
            if(cursor.getCount() > 0) {
                exist = true;
            }
            cursor.close();
        }
        return exist;
    }
    public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
        Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
                new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE },
                NoteColumns.PARENT_ID + "=?",
                new String[] { String.valueOf(folderId) },
                null);
        HashSet<AppWidgetAttribute> set = null;
        if (c != null) {
            if (c.moveToFirst()) {
                set = new HashSet<AppWidgetAttribute>();
                do {
                    try {
                        AppWidgetAttribute widget = new AppWidgetAttribute();
                        widget.widgetId = c.getInt(0);
                        widget.widgetType = c.getInt(1);
                        set.add(widget);
                    } catch (IndexOutOfBoundsException e) {
                        Log.e(TAG, e.toString());
                    }
                } while (c.moveToNext());
            }
            c.close();
        }
        return set;
    }
    public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
        Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
                new String [] { CallNote.PHONE_NUMBER },
                CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?",
                new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE },
                null);
        if (cursor != null && cursor.moveToFirst()) {
            try {
                return cursor.getString(0);
            } catch (IndexOutOfBoundsException e) {
                Log.e(TAG, "Get call number fails " + e.toString());
            } finally {
                cursor.close();
            }
        }
        return "";
    }
    public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
        Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
                new String [] { CallNote.NOTE_ID },
                CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL("
                + CallNote.PHONE_NUMBER + ",?)",
                new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber },
                null);
        if (cursor != null) {
            if (cursor.moveToFirst()) {
                try {
                    return cursor.getLong(0);
                } catch (IndexOutOfBoundsException e) {
                    Log.e(TAG, "Get call note id fails " + e.toString());
                }
            }
            cursor.close();
        }
        return 0;
    }
    public static String getSnippetById(ContentResolver resolver, long noteId) {
        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
                new String [] { NoteColumns.SNIPPET },
                NoteColumns.ID + "=?",
                new String [] { String.valueOf(noteId)},
                null);
        if (cursor != null) {
            String snippet = "";
            if (cursor.moveToFirst()) {
                snippet = cursor.getString(0);
            }
            cursor.close();
            return snippet;
        }
        throw new IllegalArgumentException("Note is not found with id: " + noteId);
    }
    public static String getFormattedSnippet(String snippet) {
        if (snippet != null) {
            snippet = snippet.trim();
            int index = snippet.indexOf('\n');
            if (index != -1) {
                snippet = snippet.substring(0, index);
            }
        }
        return snippet;
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/tool/GTaskStringUtils.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/tool/GTaskStringUtils.java
@ -0,0 +1,113 @@
 /*
 * 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;
 public class GTaskStringUtils {
    public final static String GTASK_JSON_ACTION_ID = "action_id";
    public final static String GTASK_JSON_ACTION_LIST = "action_list";
    public final static String GTASK_JSON_ACTION_TYPE = "action_type";
    public final static String GTASK_JSON_ACTION_TYPE_CREATE = "create";
    public final static String GTASK_JSON_ACTION_TYPE_GETALL = "get_all";
    public final static String GTASK_JSON_ACTION_TYPE_MOVE = "move";
    public final static String GTASK_JSON_ACTION_TYPE_UPDATE = "update";
    public final static String GTASK_JSON_CREATOR_ID = "creator_id";
    public final static String GTASK_JSON_CHILD_ENTITY = "child_entity";
    public final static String GTASK_JSON_CLIENT_VERSION = "client_version";
    public final static String GTASK_JSON_COMPLETED = "completed";
    public final static String GTASK_JSON_CURRENT_LIST_ID = "current_list_id";
    public final static String GTASK_JSON_DEFAULT_LIST_ID = "default_list_id";
    public final static String GTASK_JSON_DELETED = "deleted";
    public final static String GTASK_JSON_DEST_LIST = "dest_list";
    public final static String GTASK_JSON_DEST_PARENT = "dest_parent";
    public final static String GTASK_JSON_DEST_PARENT_TYPE = "dest_parent_type";
    public final static String GTASK_JSON_ENTITY_DELTA = "entity_delta";
    public final static String GTASK_JSON_ENTITY_TYPE = "entity_type";
    public final static String GTASK_JSON_GET_DELETED = "get_deleted";
    public final static String GTASK_JSON_ID = "id";
    public final static String GTASK_JSON_INDEX = "index";
    public final static String GTASK_JSON_LAST_MODIFIED = "last_modified";
    public final static String GTASK_JSON_LATEST_SYNC_POINT = "latest_sync_point";
    public final static String GTASK_JSON_LIST_ID = "list_id";
    public final static String GTASK_JSON_LISTS = "lists";
    public final static String GTASK_JSON_NAME = "name";
    public final static String GTASK_JSON_NEW_ID = "new_id";
    public final static String GTASK_JSON_NOTES = "notes";
    public final static String GTASK_JSON_PARENT_ID = "parent_id";
    public final static String GTASK_JSON_PRIOR_SIBLING_ID = "prior_sibling_id";
    public final static String GTASK_JSON_RESULTS = "results";
    public final static String GTASK_JSON_SOURCE_LIST = "source_list";
    public final static String GTASK_JSON_TASKS = "tasks";
    public final static String GTASK_JSON_TYPE = "type";
    public final static String GTASK_JSON_TYPE_GROUP = "GROUP";
    public final static String GTASK_JSON_TYPE_TASK = "TASK";
    public final static String GTASK_JSON_USER = "user";
    public final static String MIUI_FOLDER_PREFFIX = "[MIUI_Notes]";
    public final static String FOLDER_DEFAULT = "Default";
    public final static String FOLDER_CALL_NOTE = "Call_Note";
    public final static String FOLDER_META = "METADATA";
    public final static String META_HEAD_GTASK_ID = "meta_gid";
    public final static String META_HEAD_NOTE = "meta_note";
    public final static String META_HEAD_DATA = "meta_data";
    public final static String META_NOTE_NAME = "[META INFO] DON'T UPDATE AND DELETE";
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/tool/ResourceParser.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/tool/ResourceParser.java
@ -0,0 +1,181 @@
 /*
 * 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.preference.PreferenceManager;
 import net.micode.notes.R;
 import net.micode.notes.ui.NotesPreferenceActivity;
 public class ResourceParser {
    public static final int YELLOW           = 0;
    public static final int BLUE             = 1;
    public static final int WHITE            = 2;
    public static final int GREEN            = 3;
    public static final int RED              = 4;
    public static final int BG_DEFAULT_COLOR = YELLOW;
    public static final int TEXT_SMALL       = 0;
    public static final int TEXT_MEDIUM      = 1;
    public static final int TEXT_LARGE       = 2;
    public static final int TEXT_SUPER       = 3;
    public static final int BG_DEFAULT_FONT_SIZE = TEXT_MEDIUM;
    public static class NoteBgResources {
        private final static int [] BG_EDIT_RESOURCES = new int [] {
            R.drawable.edit_yellow,
            R.drawable.edit_blue,
            R.drawable.edit_white,
            R.drawable.edit_green,
            R.drawable.edit_red
        };
        private final static int [] BG_EDIT_TITLE_RESOURCES = new int [] {
            R.drawable.edit_title_yellow,
            R.drawable.edit_title_blue,
            R.drawable.edit_title_white,
            R.drawable.edit_title_green,
            R.drawable.edit_title_red
        };
        public static int getNoteBgResource(int id) {
            return BG_EDIT_RESOURCES[id];
        }
        public static int getNoteTitleBgResource(int id) {
            return BG_EDIT_TITLE_RESOURCES[id];
        }
    }
    public static int getDefaultBgId(Context context) {
        if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean(
                NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) {
            return (int) (Math.random() * NoteBgResources.BG_EDIT_RESOURCES.length);
        } else {
            return BG_DEFAULT_COLOR;
        }
    }
    public static class NoteItemBgResources {
        private final static int [] BG_FIRST_RESOURCES = new int [] {
            R.drawable.list_yellow_up,
            R.drawable.list_blue_up,
            R.drawable.list_white_up,
            R.drawable.list_green_up,
            R.drawable.list_red_up
        };
        private final static int [] BG_NORMAL_RESOURCES = new int [] {
            R.drawable.list_yellow_middle,
            R.drawable.list_blue_middle,
            R.drawable.list_white_middle,
            R.drawable.list_green_middle,
            R.drawable.list_red_middle
        };
        private final static int [] BG_LAST_RESOURCES = new int [] {
            R.drawable.list_yellow_down,
            R.drawable.list_blue_down,
            R.drawable.list_white_down,
            R.drawable.list_green_down,
            R.drawable.list_red_down,
        };
        private final static int [] BG_SINGLE_RESOURCES = new int [] {
            R.drawable.list_yellow_single,
            R.drawable.list_blue_single,
            R.drawable.list_white_single,
            R.drawable.list_green_single,
            R.drawable.list_red_single
        };
        public static int getNoteBgFirstRes(int id) {
            return BG_FIRST_RESOURCES[id];
        }
        public static int getNoteBgLastRes(int id) {
            return BG_LAST_RESOURCES[id];
        }
        public static int getNoteBgSingleRes(int id) {
            return BG_SINGLE_RESOURCES[id];
        }
        public static int getNoteBgNormalRes(int id) {
            return BG_NORMAL_RESOURCES[id];
        }
        public static int getFolderBgRes() {
            return R.drawable.list_folder;
        }
    }
    public static class WidgetBgResources {
        private final static int [] BG_2X_RESOURCES = new int [] {
            R.drawable.widget_2x_yellow,
            R.drawable.widget_2x_blue,
            R.drawable.widget_2x_white,
            R.drawable.widget_2x_green,
            R.drawable.widget_2x_red,
        };
        public static int getWidget2xBgResource(int id) {
            return BG_2X_RESOURCES[id];
        }
        private final static int [] BG_4X_RESOURCES = new int [] {
            R.drawable.widget_4x_yellow,
            R.drawable.widget_4x_blue,
            R.drawable.widget_4x_white,
            R.drawable.widget_4x_green,
            R.drawable.widget_4x_red
        };
        public static int getWidget4xBgResource(int id) {
            return BG_4X_RESOURCES[id];
        }
    }
    public static class TextAppearanceResources {
        private final static int [] TEXTAPPEARANCE_RESOURCES = new int [] {
            R.style.TextAppearanceNormal,
            R.style.TextAppearanceMedium,
            R.style.TextAppearanceLarge,
            R.style.TextAppearanceSuper
        };
        public static int getTexAppearanceResource(int id) {
            /**
             * HACKME: Fix bug of store the resource id in shared preference.
             * The id may larger than the length of resources, in this case,
             * return the {@link ResourceParser#BG_DEFAULT_FONT_SIZE}
             */
            if (id >= TEXTAPPEARANCE_RESOURCES.length) {
                return BG_DEFAULT_FONT_SIZE;
            }
            return TEXTAPPEARANCE_RESOURCES[id];
        }
        public static int getResourcesSize() {
            return TEXTAPPEARANCE_RESOURCES.length;
        }
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/AlarmAlertActivity.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/AlarmAlertActivity.java
@ -0,0 +1,158 @@
 /*
 * 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.ui;
 import android.app.Activity;
 import android.app.AlertDialog;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.DialogInterface.OnClickListener;
 import android.content.DialogInterface.OnDismissListener;
 import android.content.Intent;
 import android.media.AudioManager;
 import android.media.MediaPlayer;
 import android.media.RingtoneManager;
 import android.net.Uri;
 import android.os.Bundle;
 import android.os.PowerManager;
 import android.provider.Settings;
 import android.view.Window;
 import android.view.WindowManager;
 import net.micode.notes.R;
 import net.micode.notes.data.Notes;
 import net.micode.notes.tool.DataUtils;
 import java.io.IOException;
 public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener {
    private long mNoteId;
    private String mSnippet;
    private static final int SNIPPET_PREW_MAX_LEN = 60;
    MediaPlayer mPlayer;
    @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();
        try {
            mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1));
            mSnippet = DataUtils.getSnippetById(this.getContentResolver(), mNoteId);
            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();
        if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) {
            showActionDialog();
            playAlarmSound();
        } else {
            finish();
        }
    }
    private boolean isScreenOn() {
        PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
        return pm.isScreenOn();
    }
    private void playAlarmSound() {
        Uri url = RingtoneManager.getActualDefaultRingtoneUri(this, RingtoneManager.TYPE_ALARM);
        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);
        }
        try {
            mPlayer.setDataSource(this, url);
            mPlayer.prepare();
            mPlayer.setLooping(true);
            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);
        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) {
        switch (which) {
            case DialogInterface.BUTTON_NEGATIVE:
                Intent intent = new Intent(this, NoteEditActivity.class);
                intent.setAction(Intent.ACTION_VIEW);
                intent.putExtra(Intent.EXTRA_UID, mNoteId);
                startActivity(intent);
                break;
            default:
                break;
        }
    }
    public void onDismiss(DialogInterface dialog) {
        stopAlarmSound();
        finish();
    }
    private void stopAlarmSound() {
        if (mPlayer != null) {
            mPlayer.stop();
            mPlayer.release();
            mPlayer = null;
        }
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/AlarmInitReceiver.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/AlarmInitReceiver.java
@ -0,0 +1,65 @@
 /*
 * 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.ui;
 import android.app.AlarmManager;
 import android.app.PendingIntent;
 import android.content.BroadcastReceiver;
 import android.content.ContentUris;
 import android.content.Context;
 import android.content.Intent;
 import android.database.Cursor;
 import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
 public class AlarmInitReceiver extends BroadcastReceiver {
    private static final String [] PROJECTION = new String [] {
        NoteColumns.ID,
        NoteColumns.ALERTED_DATE
    };
    private static final int COLUMN_ID                = 0;
    private static final int COLUMN_ALERTED_DATE      = 1;
    @Override
    public void onReceive(Context context, Intent intent) {
        long currentDate = System.currentTimeMillis();
        Cursor c = context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
                PROJECTION,
                NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE,
                new String[] { String.valueOf(currentDate) },
                null);
        if (c != null) {
            if (c.moveToFirst()) {
                do {
                    long alertDate = c.getLong(COLUMN_ALERTED_DATE);
                    Intent sender = new Intent(context, AlarmReceiver.class);
                    sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(COLUMN_ID)));
                    PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, 0);
                    AlarmManager alermManager = (AlarmManager) context
                            .getSystemService(Context.ALARM_SERVICE);
                    alermManager.set(AlarmManager.RTC_WAKEUP, alertDate, pendingIntent);
                } while (c.moveToNext());
            }
            c.close();
        }
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/AlarmReceiver.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/AlarmReceiver.java
@ -0,0 +1,30 @@
 /*
 * 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.ui;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 public class AlarmReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        intent.setClass(context, AlarmAlertActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        context.startActivity(intent);
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/DateTimePicker.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/DateTimePicker.java
@ -0,0 +1,485 @@
 /*
 * 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.ui;
 import java.text.DateFormatSymbols;
 import java.util.Calendar;
 import net.micode.notes.R;
 import android.content.Context;
 import android.text.format.DateFormat;
 import android.view.View;
 import android.widget.FrameLayout;
 import android.widget.NumberPicker;
 public class DateTimePicker extends FrameLayout {
    private static final boolean DEFAULT_ENABLE_STATE = true;
    private static final int HOURS_IN_HALF_DAY = 12;
    private static final int HOURS_IN_ALL_DAY = 24;
    private static final int DAYS_IN_ALL_WEEK = 7;
    private static final int DATE_SPINNER_MIN_VAL = 0;
    private static final int DATE_SPINNER_MAX_VAL = DAYS_IN_ALL_WEEK - 1;
    private static final int HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW = 0;
    private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23;
    private static final int HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW = 1;
    private static final int HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW = 12;
    private static final int MINUT_SPINNER_MIN_VAL = 0;
    private static final int MINUT_SPINNER_MAX_VAL = 59;
    private static final int AMPM_SPINNER_MIN_VAL = 0;
    private static final int AMPM_SPINNER_MAX_VAL = 1;
    private final NumberPicker mDateSpinner;
    private final NumberPicker mHourSpinner;
    private final NumberPicker mMinuteSpinner;
    private final NumberPicker mAmPmSpinner;
    private Calendar mDate;
    private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];
    private boolean mIsAm;
    private boolean mIs24HourView;
    private boolean mIsEnabled = DEFAULT_ENABLE_STATE;
    private boolean mInitialising;
    private OnDateTimeChangedListener mOnDateTimeChangedListener;
    private NumberPicker.OnValueChangeListener mOnDateChangedListener = new NumberPicker.OnValueChangeListener() {
        @Override
        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
            mDate.add(Calendar.DAY_OF_YEAR, newVal - oldVal);
            updateDateControl();
            onDateTimeChanged();
        }
    };
    private NumberPicker.OnValueChangeListener mOnHourChangedListener = new NumberPicker.OnValueChangeListener() {
        @Override
        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
            boolean isDateChanged = false;
            Calendar cal = Calendar.getInstance();
            if (!mIs24HourView) {
                if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) {
                    cal.setTimeInMillis(mDate.getTimeInMillis());
                    cal.add(Calendar.DAY_OF_YEAR, 1);
                    isDateChanged = true;
                } else if (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
                    cal.setTimeInMillis(mDate.getTimeInMillis());
                    cal.add(Calendar.DAY_OF_YEAR, -1);
                    isDateChanged = true;
                }
                if (oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY ||
                        oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
                    mIsAm = !mIsAm;
                    updateAmPmControl();
                }
            } else {
                if (oldVal == HOURS_IN_ALL_DAY - 1 && newVal == 0) {
                    cal.setTimeInMillis(mDate.getTimeInMillis());
                    cal.add(Calendar.DAY_OF_YEAR, 1);
                    isDateChanged = true;
                } else if (oldVal == 0 && newVal == HOURS_IN_ALL_DAY - 1) {
                    cal.setTimeInMillis(mDate.getTimeInMillis());
                    cal.add(Calendar.DAY_OF_YEAR, -1);
                    isDateChanged = true;
                }
            }
            int newHour = mHourSpinner.getValue() % HOURS_IN_HALF_DAY + (mIsAm ? 0 : HOURS_IN_HALF_DAY);
            mDate.set(Calendar.HOUR_OF_DAY, newHour);
            onDateTimeChanged();
            if (isDateChanged) {
                setCurrentYear(cal.get(Calendar.YEAR));
                setCurrentMonth(cal.get(Calendar.MONTH));
                setCurrentDay(cal.get(Calendar.DAY_OF_MONTH));
            }
        }
    };
    private NumberPicker.OnValueChangeListener mOnMinuteChangedListener = new NumberPicker.OnValueChangeListener() {
        @Override
        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
            int minValue = mMinuteSpinner.getMinValue();
            int maxValue = mMinuteSpinner.getMaxValue();
            int offset = 0;
            if (oldVal == maxValue && newVal == minValue) {
                offset += 1;
            } else if (oldVal == minValue && newVal == maxValue) {
                offset -= 1;
            }
            if (offset != 0) {
                mDate.add(Calendar.HOUR_OF_DAY, offset);
                mHourSpinner.setValue(getCurrentHour());
                updateDateControl();
                int newHour = getCurrentHourOfDay();
                if (newHour >= HOURS_IN_HALF_DAY) {
                    mIsAm = false;
                    updateAmPmControl();
                } else {
                    mIsAm = true;
                    updateAmPmControl();
                }
            }
            mDate.set(Calendar.MINUTE, newVal);
            onDateTimeChanged();
        }
    };
    private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() {
        @Override
        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
            mIsAm = !mIsAm;
            if (mIsAm) {
                mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY);
            } else {
                mDate.add(Calendar.HOUR_OF_DAY, HOURS_IN_HALF_DAY);
            }
            updateAmPmControl();
            onDateTimeChanged();
        }
    };
    public interface OnDateTimeChangedListener {
        void onDateTimeChanged(DateTimePicker view, int year, int month,
                int dayOfMonth, int hourOfDay, int minute);
    }
    public DateTimePicker(Context context) {
        this(context, System.currentTimeMillis());
    }
    public DateTimePicker(Context context, long date) {
        this(context, date, DateFormat.is24HourFormat(context));
    }
    public DateTimePicker(Context context, long date, boolean is24HourView) {
        super(context);
        mDate = Calendar.getInstance();
        mInitialising = true;
        mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY;
        inflate(context, R.layout.datetime_picker, this);
        mDateSpinner = (NumberPicker) findViewById(R.id.date);
        mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL);
        mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL);
        mDateSpinner.setOnValueChangedListener(mOnDateChangedListener);
        mHourSpinner = (NumberPicker) findViewById(R.id.hour);
        mHourSpinner.setOnValueChangedListener(mOnHourChangedListener);
        mMinuteSpinner =  (NumberPicker) findViewById(R.id.minute);
        mMinuteSpinner.setMinValue(MINUT_SPINNER_MIN_VAL);
        mMinuteSpinner.setMaxValue(MINUT_SPINNER_MAX_VAL);
        mMinuteSpinner.setOnLongPressUpdateInterval(100);
        mMinuteSpinner.setOnValueChangedListener(mOnMinuteChangedListener);
        String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings();
        mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm);
        mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL);
        mAmPmSpinner.setMaxValue(AMPM_SPINNER_MAX_VAL);
        mAmPmSpinner.setDisplayedValues(stringsForAmPm);
        mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener);
        // update controls to initial state
        updateDateControl();
        updateHourControl();
        updateAmPmControl();
        set24HourView(is24HourView);
        // set to current time
        setCurrentDate(date);
        setEnabled(isEnabled());
        // set the content descriptions
        mInitialising = false;
    }
    @Override
    public void setEnabled(boolean enabled) {
        if (mIsEnabled == enabled) {
            return;
        }
        super.setEnabled(enabled);
        mDateSpinner.setEnabled(enabled);
        mMinuteSpinner.setEnabled(enabled);
        mHourSpinner.setEnabled(enabled);
        mAmPmSpinner.setEnabled(enabled);
        mIsEnabled = enabled;
    }
    @Override
    public boolean isEnabled() {
        return mIsEnabled;
    }
    /**
     * Get the current date in millis
     *
     * @return the current date in millis
     */
    public long getCurrentDateInTimeMillis() {
        return mDate.getTimeInMillis();
    }
    /**
     * Set the current date
     *
     * @param date The current date in millis
     */
    public void setCurrentDate(long date) {
        Calendar cal = Calendar.getInstance();
        cal.setTimeInMillis(date);
        setCurrentDate(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH),
                cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE));
    }
    /**
     * Set the current date
     *
     * @param year The current year
     * @param month The current month
     * @param dayOfMonth The current dayOfMonth
     * @param hourOfDay The current hourOfDay
     * @param minute The current minute
     */
    public void setCurrentDate(int year, int month,
            int dayOfMonth, int hourOfDay, int minute) {
        setCurrentYear(year);
        setCurrentMonth(month);
        setCurrentDay(dayOfMonth);
        setCurrentHour(hourOfDay);
        setCurrentMinute(minute);
    }
    /**
     * Get current year
     *
     * @return The current year
     */
    public int getCurrentYear() {
        return mDate.get(Calendar.YEAR);
    }
    /**
     * Set current year
     *
     * @param year The current year
     */
    public void setCurrentYear(int year) {
        if (!mInitialising && year == getCurrentYear()) {
            return;
        }
        mDate.set(Calendar.YEAR, year);
        updateDateControl();
        onDateTimeChanged();
    }
    /**
     * Get current month in the year
     *
     * @return The current month in the year
     */
    public int getCurrentMonth() {
        return mDate.get(Calendar.MONTH);
    }
    /**
     * Set current month in the year
     *
     * @param month The month in the year
     */
    public void setCurrentMonth(int month) {
        if (!mInitialising && month == getCurrentMonth()) {
            return;
        }
        mDate.set(Calendar.MONTH, month);
        updateDateControl();
        onDateTimeChanged();
    }
    /**
     * Get current day of the month
     *
     * @return The day of the month
     */
    public int getCurrentDay() {
        return mDate.get(Calendar.DAY_OF_MONTH);
    }
    /**
     * Set current day of the month
     *
     * @param dayOfMonth The day of the month
     */
    public void setCurrentDay(int dayOfMonth) {
        if (!mInitialising && dayOfMonth == getCurrentDay()) {
            return;
        }
        mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
        updateDateControl();
        onDateTimeChanged();
    }
    /**
     * Get current hour in 24 hour mode, in the range (0~23)
     * @return The current hour in 24 hour mode
     */
    public int getCurrentHourOfDay() {
        return mDate.get(Calendar.HOUR_OF_DAY);
    }
    private int getCurrentHour() {
        if (mIs24HourView){
            return getCurrentHourOfDay();
        } else {
            int hour = getCurrentHourOfDay();
            if (hour > HOURS_IN_HALF_DAY) {
                return hour - HOURS_IN_HALF_DAY;
            } else {
                return hour == 0 ? HOURS_IN_HALF_DAY : hour;
            }
        }
    }
    /**
     * Set current hour in 24 hour mode, in the range (0~23)
     *
     * @param hourOfDay
     */
    public void setCurrentHour(int hourOfDay) {
        if (!mInitialising && hourOfDay == getCurrentHourOfDay()) {
            return;
        }
        mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
        if (!mIs24HourView) {
            if (hourOfDay >= HOURS_IN_HALF_DAY) {
                mIsAm = false;
                if (hourOfDay > HOURS_IN_HALF_DAY) {
                    hourOfDay -= HOURS_IN_HALF_DAY;
                }
            } else {
                mIsAm = true;
                if (hourOfDay == 0) {
                    hourOfDay = HOURS_IN_HALF_DAY;
                }
            }
            updateAmPmControl();
        }
        mHourSpinner.setValue(hourOfDay);
        onDateTimeChanged();
    }
    /**
     * Get currentMinute
     *
     * @return The Current Minute
     */
    public int getCurrentMinute() {
        return mDate.get(Calendar.MINUTE);
    }
    /**
     * Set current minute
     */
    public void setCurrentMinute(int minute) {
        if (!mInitialising && minute == getCurrentMinute()) {
            return;
        }
        mMinuteSpinner.setValue(minute);
        mDate.set(Calendar.MINUTE, minute);
        onDateTimeChanged();
    }
    /**
     * @return true if this is in 24 hour view else false.
     */
    public boolean is24HourView () {
        return mIs24HourView;
    }
    /**
     * Set whether in 24 hour or AM/PM mode.
     *
     * @param is24HourView True for 24 hour mode. False for AM/PM mode.
     */
    public void set24HourView(boolean is24HourView) {
        if (mIs24HourView == is24HourView) {
            return;
        }
        mIs24HourView = is24HourView;
        mAmPmSpinner.setVisibility(is24HourView ? View.GONE : View.VISIBLE);
        int hour = getCurrentHourOfDay();
        updateHourControl();
        setCurrentHour(hour);
        updateAmPmControl();
    }
    private void updateDateControl() {
        Calendar cal = Calendar.getInstance();
        cal.setTimeInMillis(mDate.getTimeInMillis());
        cal.add(Calendar.DAY_OF_YEAR, -DAYS_IN_ALL_WEEK / 2 - 1);
        mDateSpinner.setDisplayedValues(null);
        for (int i = 0; i < DAYS_IN_ALL_WEEK; ++i) {
            cal.add(Calendar.DAY_OF_YEAR, 1);
            mDateDisplayValues[i] = (String) DateFormat.format("MM.dd EEEE", cal);
        }
        mDateSpinner.setDisplayedValues(mDateDisplayValues);
        mDateSpinner.setValue(DAYS_IN_ALL_WEEK / 2);
        mDateSpinner.invalidate();
    }
    private void updateAmPmControl() {
        if (mIs24HourView) {
            mAmPmSpinner.setVisibility(View.GONE);
        } else {
            int index = mIsAm ? Calendar.AM : Calendar.PM;
            mAmPmSpinner.setValue(index);
            mAmPmSpinner.setVisibility(View.VISIBLE);
        }
    }
    private void updateHourControl() {
        if (mIs24HourView) {
            mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW);
            mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW);
        } else {
            mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW);
            mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW);
        }
    }
    /**
     * Set the callback that indicates the 'Set' button has been pressed.
     * @param callback the callback, if null will do nothing
     */
    public void setOnDateTimeChangedListener(OnDateTimeChangedListener callback) {
        mOnDateTimeChangedListener = callback;
    }
    private void onDateTimeChanged() {
        if (mOnDateTimeChangedListener != null) {
            mOnDateTimeChangedListener.onDateTimeChanged(this, getCurrentYear(),
                    getCurrentMonth(), getCurrentDay(), getCurrentHourOfDay(), getCurrentMinute());
        }
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/DateTimePickerDialog.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/DateTimePickerDialog.java
@ -0,0 +1,90 @@
 /*
 * 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.ui;
 import java.util.Calendar;
 import net.micode.notes.R;
 import net.micode.notes.ui.DateTimePicker;
 import net.micode.notes.ui.DateTimePicker.OnDateTimeChangedListener;
 import android.app.AlertDialog;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.DialogInterface.OnClickListener;
 import android.text.format.DateFormat;
 import android.text.format.DateUtils;
 public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
    private Calendar mDate = Calendar.getInstance();
    private boolean mIs24HourView;
    private OnDateTimeSetListener mOnDateTimeSetListener;
    private DateTimePicker mDateTimePicker;
    public interface OnDateTimeSetListener {
        void OnDateTimeSet(AlertDialog dialog, long date);
    }
    public DateTimePickerDialog(Context context, long date) {
        super(context);
        mDateTimePicker = new DateTimePicker(context);
        setView(mDateTimePicker);
        mDateTimePicker.setOnDateTimeChangedListener(new OnDateTimeChangedListener() {
            public void onDateTimeChanged(DateTimePicker view, int year, int month,
                    int dayOfMonth, int hourOfDay, int minute) {
                mDate.set(Calendar.YEAR, year);
                mDate.set(Calendar.MONTH, month);
                mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
                mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
                mDate.set(Calendar.MINUTE, minute);
                updateTitle(mDate.getTimeInMillis());
            }
        });
        mDate.setTimeInMillis(date);
        mDate.set(Calendar.SECOND, 0);
        mDateTimePicker.setCurrentDate(mDate.getTimeInMillis());
        setButton(context.getString(R.string.datetime_dialog_ok), this);
        setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener)null);
        set24HourView(DateFormat.is24HourFormat(this.getContext()));
        updateTitle(mDate.getTimeInMillis());
    }
    public void set24HourView(boolean is24HourView) {
        mIs24HourView = is24HourView;
    }
    public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) {
        mOnDateTimeSetListener = callBack;
    }
    private void updateTitle(long date) {
        int flag =
            DateUtils.FORMAT_SHOW_YEAR |
            DateUtils.FORMAT_SHOW_DATE |
            DateUtils.FORMAT_SHOW_TIME;
        flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_24HOUR;
        setTitle(DateUtils.formatDateTime(this.getContext(), date, flag));
    }
    public void onClick(DialogInterface arg0, int arg1) {
        if (mOnDateTimeSetListener != null) {
            mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis());
        }
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/DropdownMenu.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/DropdownMenu.java
@ -0,0 +1,61 @@
 /*
 * 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.ui;
 import android.content.Context;
 import android.view.Menu;
 import android.view.MenuItem;
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.widget.Button;
 import android.widget.PopupMenu;
 import android.widget.PopupMenu.OnMenuItemClickListener;
 import net.micode.notes.R;
 public class DropdownMenu {
    private Button mButton;
    private PopupMenu mPopupMenu;
    private Menu mMenu;
    public DropdownMenu(Context context, Button button, int menuId) {
        mButton = button;
        mButton.setBackgroundResource(R.drawable.dropdown_icon);
        mPopupMenu = new PopupMenu(context, mButton);
        mMenu = mPopupMenu.getMenu();
        mPopupMenu.getMenuInflater().inflate(menuId, mMenu);
        mButton.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                mPopupMenu.show();
            }
        });
    }
    public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {
        if (mPopupMenu != null) {
            mPopupMenu.setOnMenuItemClickListener(listener);
        }
    }
    public MenuItem findItem(int id) {
        return mMenu.findItem(id);
    }
    public void setTitle(CharSequence title) {
        mButton.setText(title);
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/FoldersListAdapter.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/FoldersListAdapter.java
@ -0,0 +1,80 @@
 /*
 * 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.ui;
 import android.content.Context;
 import android.database.Cursor;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.CursorAdapter;
 import android.widget.LinearLayout;
 import android.widget.TextView;
 import net.micode.notes.R;
 import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
 public class FoldersListAdapter extends CursorAdapter {
    public static final String [] PROJECTION = {
        NoteColumns.ID,
        NoteColumns.SNIPPET
    };
    public static final int ID_COLUMN   = 0;
    public static final int NAME_COLUMN = 1;
    public FoldersListAdapter(Context context, Cursor c) {
        super(context, c);
        // TODO Auto-generated constructor stub
    }
    @Override
    public View newView(Context context, Cursor cursor, ViewGroup parent) {
        return new FolderListItem(context);
    }
    @Override
    public void bindView(View view, Context context, Cursor cursor) {
        if (view instanceof FolderListItem) {
            String folderName = (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
                    .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
            ((FolderListItem) view).bind(folderName);
        }
    }
    public String getFolderName(Context context, int position) {
        Cursor cursor = (Cursor) getItem(position);
        return (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
                .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
    }
    private class FolderListItem extends LinearLayout {
        private TextView mName;
        public FolderListItem(Context context) {
            super(context);
            inflate(context, R.layout.folder_list_item, this);
            mName = (TextView) findViewById(R.id.tv_folder_name);
        }
        public void bind(String name) {
            mName.setText(name);
        }
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/NoteEditActivity.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/NoteEditActivity.java
@ -0,0 +1,873 @@
 /*
 * 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.ui;
 import android.app.Activity;
 import android.app.AlarmManager;
 import android.app.AlertDialog;
 import android.app.PendingIntent;
 import android.app.SearchManager;
 import android.appwidget.AppWidgetManager;
 import android.content.ContentUris;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.Intent;
 import android.content.SharedPreferences;
 import android.graphics.Paint;
 import android.os.Bundle;
 import android.preference.PreferenceManager;
 import android.text.Spannable;
 import android.text.SpannableString;
 import android.text.TextUtils;
 import android.text.format.DateUtils;
 import android.text.style.BackgroundColorSpan;
 import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.Menu;
 import android.view.MenuItem;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.view.WindowManager;
 import android.widget.CheckBox;
 import android.widget.CompoundButton;
 import android.widget.CompoundButton.OnCheckedChangeListener;
 import android.widget.EditText;
 import android.widget.ImageView;
 import android.widget.LinearLayout;
 import android.widget.TextView;
 import android.widget.Toast;
 import net.micode.notes.R;
 import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.TextNote;
 import net.micode.notes.model.WorkingNote;
 import net.micode.notes.model.WorkingNote.NoteSettingChangedListener;
 import net.micode.notes.tool.DataUtils;
 import net.micode.notes.tool.ResourceParser;
 import net.micode.notes.tool.ResourceParser.TextAppearanceResources;
 import net.micode.notes.ui.DateTimePickerDialog.OnDateTimeSetListener;
 import net.micode.notes.ui.NoteEditText.OnTextViewChangeListener;
 import net.micode.notes.widget.NoteWidgetProvider_2x;
 import net.micode.notes.widget.NoteWidgetProvider_4x;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 public class NoteEditActivity extends Activity implements OnClickListener,
        NoteSettingChangedListener, OnTextViewChangeListener {
    private class HeadViewHolder {
        public TextView tvModified;
        public ImageView ivAlertIcon;
        public TextView tvAlertDate;
        public ImageView ibSetBgColor;
    }
    private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<Integer, Integer>();
    static {
        sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW);
        sBgSelectorBtnsMap.put(R.id.iv_bg_red, ResourceParser.RED);
        sBgSelectorBtnsMap.put(R.id.iv_bg_blue, ResourceParser.BLUE);
        sBgSelectorBtnsMap.put(R.id.iv_bg_green, ResourceParser.GREEN);
        sBgSelectorBtnsMap.put(R.id.iv_bg_white, ResourceParser.WHITE);
    }
    private static final Map<Integer, Integer> sBgSelectorSelectionMap = new HashMap<Integer, Integer>();
    static {
        sBgSelectorSelectionMap.put(ResourceParser.YELLOW, R.id.iv_bg_yellow_select);
        sBgSelectorSelectionMap.put(ResourceParser.RED, R.id.iv_bg_red_select);
        sBgSelectorSelectionMap.put(ResourceParser.BLUE, R.id.iv_bg_blue_select);
        sBgSelectorSelectionMap.put(ResourceParser.GREEN, R.id.iv_bg_green_select);
        sBgSelectorSelectionMap.put(ResourceParser.WHITE, R.id.iv_bg_white_select);
    }
    private static final Map<Integer, Integer> sFontSizeBtnsMap = new HashMap<Integer, Integer>();
    static {
        sFontSizeBtnsMap.put(R.id.ll_font_large, ResourceParser.TEXT_LARGE);
        sFontSizeBtnsMap.put(R.id.ll_font_small, ResourceParser.TEXT_SMALL);
        sFontSizeBtnsMap.put(R.id.ll_font_normal, ResourceParser.TEXT_MEDIUM);
        sFontSizeBtnsMap.put(R.id.ll_font_super, ResourceParser.TEXT_SUPER);
    }
    private static final Map<Integer, Integer> sFontSelectorSelectionMap = new HashMap<Integer, Integer>();
    static {
        sFontSelectorSelectionMap.put(ResourceParser.TEXT_LARGE, R.id.iv_large_select);
        sFontSelectorSelectionMap.put(ResourceParser.TEXT_SMALL, R.id.iv_small_select);
        sFontSelectorSelectionMap.put(ResourceParser.TEXT_MEDIUM, R.id.iv_medium_select);
        sFontSelectorSelectionMap.put(ResourceParser.TEXT_SUPER, R.id.iv_super_select);
    }
    private static final String TAG = "NoteEditActivity";
    private HeadViewHolder mNoteHeaderHolder;
    private View mHeadViewPanel;
    private View mNoteBgColorSelector;
    private View mFontSizeSelector;
    private EditText mNoteEditor;
    private View mNoteEditorPanel;
    private WorkingNote mWorkingNote;
    private SharedPreferences mSharedPrefs;
    private int mFontSizeId;
    private static final String PREFERENCE_FONT_SIZE = "pref_font_size";
    private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10;
    public static final String TAG_CHECKED = String.valueOf('\u221A');
    public static final String TAG_UNCHECKED = String.valueOf('\u25A1');
    private LinearLayout mEditTextList;
    private String mUserQuery;
    private Pattern mPattern;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        this.setContentView(R.layout.note_edit);
        if (savedInstanceState == null && !initActivityState(getIntent())) {
            finish();
            return;
        }
        initResources();
    }
    /**
     * Current activity may be killed when the memory is low. Once it is killed, for another time
     * user load this activity, we should restore the former state
     */
    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
        if (savedInstanceState != null && savedInstanceState.containsKey(Intent.EXTRA_UID)) {
            Intent intent = new Intent(Intent.ACTION_VIEW);
            intent.putExtra(Intent.EXTRA_UID, savedInstanceState.getLong(Intent.EXTRA_UID));
            if (!initActivityState(intent)) {
                finish();
                return;
            }
            Log.d(TAG, "Restoring from killed activity");
        }
    }
    private boolean initActivityState(Intent intent) {
        /**
         * If the user specified the {@link Intent#ACTION_VIEW} but not provided with id,
         * then jump to the NotesListActivity
         */
        mWorkingNote = null;
        if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) {
            long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0);
            mUserQuery = "";
            /**
             * Starting from the searched result
             */
            if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) {
                noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY));
                mUserQuery = intent.getStringExtra(SearchManager.USER_QUERY);
            }
            if (!DataUtils.visibleInNoteDatabase(getContentResolver(), noteId, Notes.TYPE_NOTE)) {
                Intent jump = new Intent(this, NotesListActivity.class);
                startActivity(jump);
                showToast(R.string.error_note_not_exist);
                finish();
                return false;
            } else {
                mWorkingNote = WorkingNote.load(this, noteId);
                if (mWorkingNote == null) {
                    Log.e(TAG, "load note failed with note id" + noteId);
                    finish();
                    return false;
                }
            }
            getWindow().setSoftInputMode(
                    WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN
                            | WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
        } else if(TextUtils.equals(Intent.ACTION_INSERT_OR_EDIT, intent.getAction())) {
            // New note
            long folderId = intent.getLongExtra(Notes.INTENT_EXTRA_FOLDER_ID, 0);
            int widgetId = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_ID,
                    AppWidgetManager.INVALID_APPWIDGET_ID);
            int widgetType = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_TYPE,
                    Notes.TYPE_WIDGET_INVALIDE);
            int bgResId = intent.getIntExtra(Notes.INTENT_EXTRA_BACKGROUND_ID,
                    ResourceParser.getDefaultBgId(this));
            // Parse call-record note
            String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);
            long callDate = intent.getLongExtra(Notes.INTENT_EXTRA_CALL_DATE, 0);
            if (callDate != 0 && phoneNumber != null) {
                if (TextUtils.isEmpty(phoneNumber)) {
                    Log.w(TAG, "The call record number is null");
                }
                long noteId = 0;
                if ((noteId = DataUtils.getNoteIdByPhoneNumberAndCallDate(getContentResolver(),
                        phoneNumber, callDate)) > 0) {
                    mWorkingNote = WorkingNote.load(this, noteId);
                    if (mWorkingNote == null) {
                        Log.e(TAG, "load call note failed with note id" + noteId);
                        finish();
                        return false;
                    }
                } else {
                    mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId,
                            widgetType, bgResId);
                    mWorkingNote.convertToCallNote(phoneNumber, callDate);
                }
            } else {
                mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId, widgetType,
                        bgResId);
            }
            getWindow().setSoftInputMode(
                    WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE
                            | WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
        } else {
            Log.e(TAG, "Intent not specified action, should not support");
            finish();
            return false;
        }
        mWorkingNote.setOnSettingStatusChangedListener(this);
        return true;
    }
    @Override
    protected void onResume() {
        super.onResume();
        initNoteScreen();
    }
    private void initNoteScreen() {
        mNoteEditor.setTextAppearance(this, TextAppearanceResources
                .getTexAppearanceResource(mFontSizeId));
        if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
            switchToListMode(mWorkingNote.getContent());
        } else {
            mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));
            mNoteEditor.setSelection(mNoteEditor.getText().length());
        }
        for (Integer id : sBgSelectorSelectionMap.keySet()) {
            findViewById(sBgSelectorSelectionMap.get(id)).setVisibility(View.GONE);
        }
        mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
        mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());
        mNoteHeaderHolder.tvModified.setText(DateUtils.formatDateTime(this,
                mWorkingNote.getModifiedDate(), DateUtils.FORMAT_SHOW_DATE
                        | DateUtils.FORMAT_NUMERIC_DATE | DateUtils.FORMAT_SHOW_TIME
                        | DateUtils.FORMAT_SHOW_YEAR));
        /**
         * TODO: Add the menu for setting alert. Currently disable it because the DateTimePicker
         * is not ready
         */
        showAlertHeader();
    }
    private void showAlertHeader() {
        if (mWorkingNote.hasClockAlert()) {
            long time = System.currentTimeMillis();
            if (time > mWorkingNote.getAlertDate()) {
                mNoteHeaderHolder.tvAlertDate.setText(R.string.note_alert_expired);
            } else {
                mNoteHeaderHolder.tvAlertDate.setText(DateUtils.getRelativeTimeSpanString(
                        mWorkingNote.getAlertDate(), time, DateUtils.MINUTE_IN_MILLIS));
            }
            mNoteHeaderHolder.tvAlertDate.setVisibility(View.VISIBLE);
            mNoteHeaderHolder.ivAlertIcon.setVisibility(View.VISIBLE);
        } else {
            mNoteHeaderHolder.tvAlertDate.setVisibility(View.GONE);
            mNoteHeaderHolder.ivAlertIcon.setVisibility(View.GONE);
        };
    }
    @Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        initActivityState(intent);
    }
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        /**
         * For new note without note id, we should firstly save it to
         * generate a id. If the editing note is not worth saving, there
         * is no id which is equivalent to create new note
         */
        if (!mWorkingNote.existInDatabase()) {
            saveNote();
        }
        outState.putLong(Intent.EXTRA_UID, mWorkingNote.getNoteId());
        Log.d(TAG, "Save working note id: " + mWorkingNote.getNoteId() + " onSaveInstanceState");
    }
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        if (mNoteBgColorSelector.getVisibility() == View.VISIBLE
                && !inRangeOfView(mNoteBgColorSelector, ev)) {
            mNoteBgColorSelector.setVisibility(View.GONE);
            return true;
        }
        if (mFontSizeSelector.getVisibility() == View.VISIBLE
                && !inRangeOfView(mFontSizeSelector, ev)) {
            mFontSizeSelector.setVisibility(View.GONE);
            return true;
        }
        return super.dispatchTouchEvent(ev);
    }
    private boolean inRangeOfView(View view, MotionEvent ev) {
        int []location = new int[2];
        view.getLocationOnScreen(location);
        int x = location[0];
        int y = location[1];
        if (ev.getX() < x
                || ev.getX() > (x + view.getWidth())
                || ev.getY() < y
                || ev.getY() > (y + view.getHeight())) {
                    return false;
                }
        return true;
    }
    private void initResources() {
        mHeadViewPanel = findViewById(R.id.note_title);
        mNoteHeaderHolder = new HeadViewHolder();
        mNoteHeaderHolder.tvModified = (TextView) findViewById(R.id.tv_modified_date);
        mNoteHeaderHolder.ivAlertIcon = (ImageView) findViewById(R.id.iv_alert_icon);
        mNoteHeaderHolder.tvAlertDate = (TextView) findViewById(R.id.tv_alert_date);
        mNoteHeaderHolder.ibSetBgColor = (ImageView) findViewById(R.id.btn_set_bg_color);
        mNoteHeaderHolder.ibSetBgColor.setOnClickListener(this);
        mNoteEditor = (EditText) findViewById(R.id.note_edit_view);
        mNoteEditorPanel = findViewById(R.id.sv_note_edit);
        mNoteBgColorSelector = findViewById(R.id.note_bg_color_selector);
        for (int id : sBgSelectorBtnsMap.keySet()) {
            ImageView iv = (ImageView) findViewById(id);
            iv.setOnClickListener(this);
        }
        mFontSizeSelector = findViewById(R.id.font_size_selector);
        for (int id : sFontSizeBtnsMap.keySet()) {
            View view = findViewById(id);
            view.setOnClickListener(this);
        };
        mSharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);
        mFontSizeId = mSharedPrefs.getInt(PREFERENCE_FONT_SIZE, ResourceParser.BG_DEFAULT_FONT_SIZE);
        /**
         * HACKME: Fix bug of store the resource id in shared preference.
         * The id may larger than the length of resources, in this case,
         * return the {@link ResourceParser#BG_DEFAULT_FONT_SIZE}
         */
        if(mFontSizeId >= TextAppearanceResources.getResourcesSize()) {
            mFontSizeId = ResourceParser.BG_DEFAULT_FONT_SIZE;
        }
        mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list);
    }
    @Override
    protected void onPause() {
        super.onPause();
        if(saveNote()) {
            Log.d(TAG, "Note data was saved with length:" + mWorkingNote.getContent().length());
        }
        clearSettingState();
    }
    private void updateWidget() {
        Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
        if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_2X) {
            intent.setClass(this, NoteWidgetProvider_2x.class);
        } else if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_4X) {
            intent.setClass(this, NoteWidgetProvider_4x.class);
        } else {
            Log.e(TAG, "Unspported widget type");
            return;
        }
        intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] {
            mWorkingNote.getWidgetId()
        });
        sendBroadcast(intent);
        setResult(RESULT_OK, intent);
    }
    public void onClick(View v) {
        int id = v.getId();
        if (id == R.id.btn_set_bg_color) {
            mNoteBgColorSelector.setVisibility(View.VISIBLE);
            findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
                    -                    View.VISIBLE);
        } else if (sBgSelectorBtnsMap.containsKey(id)) {
            findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
                    View.GONE);
            mWorkingNote.setBgColorId(sBgSelectorBtnsMap.get(id));
            mNoteBgColorSelector.setVisibility(View.GONE);
        } else if (sFontSizeBtnsMap.containsKey(id)) {
            findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.GONE);
            mFontSizeId = sFontSizeBtnsMap.get(id);
            mSharedPrefs.edit().putInt(PREFERENCE_FONT_SIZE, mFontSizeId).commit();
            findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
            if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
                getWorkingText();
                switchToListMode(mWorkingNote.getContent());
            } else {
                mNoteEditor.setTextAppearance(this,
                        TextAppearanceResources.getTexAppearanceResource(mFontSizeId));
            }
            mFontSizeSelector.setVisibility(View.GONE);
        }
    }
    @Override
    public void onBackPressed() {
        if(clearSettingState()) {
            return;
        }
        saveNote();
        super.onBackPressed();
    }
    private boolean clearSettingState() {
        if (mNoteBgColorSelector.getVisibility() == View.VISIBLE) {
            mNoteBgColorSelector.setVisibility(View.GONE);
            return true;
        } else if (mFontSizeSelector.getVisibility() == View.VISIBLE) {
            mFontSizeSelector.setVisibility(View.GONE);
            return true;
        }
        return false;
    }
    public void onBackgroundColorChanged() {
        findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
                View.VISIBLE);
        mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());
        mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
    }
    @Override
    public boolean onPrepareOptionsMenu(Menu menu) {
        if (isFinishing()) {
            return true;
        }
        clearSettingState();
        menu.clear();
        if (mWorkingNote.getFolderId() == Notes.ID_CALL_RECORD_FOLDER) {
            getMenuInflater().inflate(R.menu.call_note_edit, menu);
        } else {
            getMenuInflater().inflate(R.menu.note_edit, menu);
        }
        if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
            menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_normal_mode);
        } else {
            menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_list_mode);
        }
        if (mWorkingNote.hasClockAlert()) {
            menu.findItem(R.id.menu_alert).setVisible(false);
        } else {
            menu.findItem(R.id.menu_delete_remind).setVisible(false);
        }
        return true;
    }
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case R.id.menu_new_note:
                createNewNote();
                break;
            case R.id.menu_delete:
                AlertDialog.Builder builder = new AlertDialog.Builder(this);
                builder.setTitle(getString(R.string.alert_title_delete));
                builder.setIcon(android.R.drawable.ic_dialog_alert);
                builder.setMessage(getString(R.string.alert_message_delete_note));
                builder.setPositiveButton(android.R.string.ok,
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog, int which) {
                                deleteCurrentNote();
                                finish();
                            }
                        });
                builder.setNegativeButton(android.R.string.cancel, null);
                builder.show();
                break;
            case R.id.menu_font_size:
                mFontSizeSelector.setVisibility(View.VISIBLE);
                findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
                break;
            case R.id.menu_list_mode:
                mWorkingNote.setCheckListMode(mWorkingNote.getCheckListMode() == 0 ?
                        TextNote.MODE_CHECK_LIST : 0);
                break;
            case R.id.menu_share:
                getWorkingText();
                sendTo(this, mWorkingNote.getContent());
                break;
            case R.id.menu_send_to_desktop:
                sendToDesktop();
                break;
            case R.id.menu_alert:
                setReminder();
                break;
            case R.id.menu_delete_remind:
                mWorkingNote.setAlertDate(0, false);
                break;
            default:
                break;
        }
        return true;
    }
    private void setReminder() {
        DateTimePickerDialog d = new DateTimePickerDialog(this, System.currentTimeMillis());
        d.setOnDateTimeSetListener(new OnDateTimeSetListener() {
            public void OnDateTimeSet(AlertDialog dialog, long date) {
                mWorkingNote.setAlertDate(date	, true);
            }
        });
        d.show();
    }
    /**
     * Share note to apps that support {@link Intent#ACTION_SEND} action
     * and {@text/plain} type
     */
    private void sendTo(Context context, String info) {
        Intent intent = new Intent(Intent.ACTION_SEND);
        intent.putExtra(Intent.EXTRA_TEXT, info);
        intent.setType("text/plain");
        context.startActivity(intent);
    }
    private void createNewNote() {
        // Firstly, save current editing notes
        saveNote();
        // For safety, start a new NoteEditActivity
        finish();
        Intent intent = new Intent(this, NoteEditActivity.class);
        intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
        intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mWorkingNote.getFolderId());
        startActivity(intent);
    }
    private void deleteCurrentNote() {
        if (mWorkingNote.existInDatabase()) {
            HashSet<Long> ids = new HashSet<Long>();
            long id = mWorkingNote.getNoteId();
            if (id != Notes.ID_ROOT_FOLDER) {
                ids.add(id);
            } else {
                Log.d(TAG, "Wrong note id, should not happen");
            }
            if (!isSyncMode()) {
                if (!DataUtils.batchDeleteNotes(getContentResolver(), ids)) {
                    Log.e(TAG, "Delete Note error");
                }
            } else {
                if (!DataUtils.batchMoveToFolder(getContentResolver(), ids, Notes.ID_TRASH_FOLER)) {
                    Log.e(TAG, "Move notes to trash folder error, should not happens");
                }
            }
        }
        mWorkingNote.markDeleted(true);
    }
    private boolean isSyncMode() {
        return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
    }
    public void onClockAlertChanged(long date, boolean set) {
        /**
         * User could set clock to an unsaved note, so before setting the
         * alert clock, we should save the note first
         */
        if (!mWorkingNote.existInDatabase()) {
            saveNote();
        }
        if (mWorkingNote.getNoteId() > 0) {
            Intent intent = new Intent(this, AlarmReceiver.class);
            intent.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mWorkingNote.getNoteId()));
            PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, intent, 0);
            AlarmManager alarmManager = ((AlarmManager) getSystemService(ALARM_SERVICE));
            showAlertHeader();
            if(!set) {
                alarmManager.cancel(pendingIntent);
            } else {
                alarmManager.set(AlarmManager.RTC_WAKEUP, date, pendingIntent);
            }
        } else {
            /**
             * There is the condition that user has input nothing (the note is
             * not worthy saving), we have no note id, remind the user that he
             * should input something
             */
            Log.e(TAG, "Clock alert setting error");
            showToast(R.string.error_note_empty_for_clock);
        }
    }
    public void onWidgetChanged() {
        updateWidget();
    }
    public void onEditTextDelete(int index, String text) {
        int childCount = mEditTextList.getChildCount();
        if (childCount == 1) {
            return;
        }
        for (int i = index + 1; i < childCount; i++) {
            ((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text))
                    .setIndex(i - 1);
        }
        mEditTextList.removeViewAt(index);
        NoteEditText edit = null;
        if(index == 0) {
            edit = (NoteEditText) mEditTextList.getChildAt(0).findViewById(
                    R.id.et_edit_text);
        } else {
            edit = (NoteEditText) mEditTextList.getChildAt(index - 1).findViewById(
                    R.id.et_edit_text);
        }
        int length = edit.length();
        edit.append(text);
        edit.requestFocus();
        edit.setSelection(length);
    }
    public void onEditTextEnter(int index, String text) {
        /**
         * Should not happen, check for debug
         */
        if(index > mEditTextList.getChildCount()) {
            Log.e(TAG, "Index out of mEditTextList boundrary, should not happen");
        }
        View view = getListItem(text, index);
        mEditTextList.addView(view, index);
        NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
        edit.requestFocus();
        edit.setSelection(0);
        for (int i = index + 1; i < mEditTextList.getChildCount(); i++) {
            ((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text))
                    .setIndex(i);
        }
    }
    private void switchToListMode(String text) {
        mEditTextList.removeAllViews();
        String[] items = text.split("\n");
        int index = 0;
        for (String item : items) {
            if(!TextUtils.isEmpty(item)) {
                mEditTextList.addView(getListItem(item, index));
                index++;
            }
        }
        mEditTextList.addView(getListItem("", index));
        mEditTextList.getChildAt(index).findViewById(R.id.et_edit_text).requestFocus();
        mNoteEditor.setVisibility(View.GONE);
        mEditTextList.setVisibility(View.VISIBLE);
    }
    private Spannable getHighlightQueryResult(String fullText, String userQuery) {
        SpannableString spannable = new SpannableString(fullText == null ? "" : fullText);
        if (!TextUtils.isEmpty(userQuery)) {
            mPattern = Pattern.compile(userQuery);
            Matcher m = mPattern.matcher(fullText);
            int start = 0;
            while (m.find(start)) {
                spannable.setSpan(
                        new BackgroundColorSpan(this.getResources().getColor(
                                R.color.user_query_highlight)), m.start(), m.end(),
                        Spannable.SPAN_INCLUSIVE_EXCLUSIVE);
                start = m.end();
            }
        }
        return spannable;
    }
    private View getListItem(String item, int index) {
        View view = LayoutInflater.from(this).inflate(R.layout.note_edit_list_item, null);
        final NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
        edit.setTextAppearance(this, TextAppearanceResources.getTexAppearanceResource(mFontSizeId));
        CheckBox cb = ((CheckBox) view.findViewById(R.id.cb_edit_item));
        cb.setOnCheckedChangeListener(new OnCheckedChangeListener() {
            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                if (isChecked) {
                    edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
                } else {
                    edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG);
                }
            }
        });
        if (item.startsWith(TAG_CHECKED)) {
            cb.setChecked(true);
            edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
            item = item.substring(TAG_CHECKED.length(), item.length()).trim();
        } else if (item.startsWith(TAG_UNCHECKED)) {
            cb.setChecked(false);
            edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG);
            item = item.substring(TAG_UNCHECKED.length(), item.length()).trim();
        }
        edit.setOnTextViewChangeListener(this);
        edit.setIndex(index);
        edit.setText(getHighlightQueryResult(item, mUserQuery));
        return view;
    }
    public void onTextChange(int index, boolean hasText) {
        if (index >= mEditTextList.getChildCount()) {
            Log.e(TAG, "Wrong index, should not happen");
            return;
        }
        if(hasText) {
            mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.VISIBLE);
        } else {
            mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.GONE);
        }
    }
    public void onCheckListModeChanged(int oldMode, int newMode) {
        if (newMode == TextNote.MODE_CHECK_LIST) {
            switchToListMode(mNoteEditor.getText().toString());
        } else {
            if (!getWorkingText()) {
                mWorkingNote.setWorkingText(mWorkingNote.getContent().replace(TAG_UNCHECKED + " ",
                        ""));
            }
            mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));
            mEditTextList.setVisibility(View.GONE);
            mNoteEditor.setVisibility(View.VISIBLE);
        }
    }
    private boolean getWorkingText() {
        boolean hasChecked = false;
        if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < mEditTextList.getChildCount(); i++) {
                View view = mEditTextList.getChildAt(i);
                NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
                if (!TextUtils.isEmpty(edit.getText())) {
                    if (((CheckBox) view.findViewById(R.id.cb_edit_item)).isChecked()) {
                        sb.append(TAG_CHECKED).append(" ").append(edit.getText()).append("\n");
                        hasChecked = true;
                    } else {
                        sb.append(TAG_UNCHECKED).append(" ").append(edit.getText()).append("\n");
                    }
                }
            }
            mWorkingNote.setWorkingText(sb.toString());
        } else {
            mWorkingNote.setWorkingText(mNoteEditor.getText().toString());
        }
        return hasChecked;
    }
    private boolean saveNote() {
        getWorkingText();
        boolean saved = mWorkingNote.saveNote();
        if (saved) {
            /**
             * There are two modes from List view to edit view, open one note,
             * create/edit a node. Opening node requires to the original
             * position in the list when back from edit view, while creating a
             * new node requires to the top of the list. This code
             * {@link #RESULT_OK} is used to identify the create/edit state
             */
            setResult(RESULT_OK);
        }
        return saved;
    }
    private void sendToDesktop() {
        /**
         * Before send message to home, we should make sure that current
         * editing note is exists in databases. So, for new note, firstly
         * save it
         */
        if (!mWorkingNote.existInDatabase()) {
            saveNote();
        }
        if (mWorkingNote.getNoteId() > 0) {
            Intent sender = new Intent();
            Intent shortcutIntent = new Intent(this, NoteEditActivity.class);
            shortcutIntent.setAction(Intent.ACTION_VIEW);
            shortcutIntent.putExtra(Intent.EXTRA_UID, mWorkingNote.getNoteId());
            sender.putExtra(Intent.EXTRA_SHORTCUT_INTENT, shortcutIntent);
            sender.putExtra(Intent.EXTRA_SHORTCUT_NAME,
                    makeShortcutIconTitle(mWorkingNote.getContent()));
            sender.putExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE,
                    Intent.ShortcutIconResource.fromContext(this, R.drawable.icon_app));
            sender.putExtra("duplicate", true);
            sender.setAction("com.android.launcher.action.INSTALL_SHORTCUT");
            showToast(R.string.info_note_enter_desktop);
            sendBroadcast(sender);
        } else {
            /**
             * There is the condition that user has input nothing (the note is
             * not worthy saving), we have no note id, remind the user that he
             * should input something
             */
            Log.e(TAG, "Send to desktop error");
            showToast(R.string.error_note_empty_for_send_to_desktop);
        }
    }
    private String makeShortcutIconTitle(String content) {
        content = content.replace(TAG_CHECKED, "");
        content = content.replace(TAG_UNCHECKED, "");
        return content.length() > SHORTCUT_ICON_TITLE_MAX_LEN ? content.substring(0,
                SHORTCUT_ICON_TITLE_MAX_LEN) : content;
    }
    private void showToast(int resId) {
        showToast(resId, Toast.LENGTH_SHORT);
    }
    private void showToast(int resId, int duration) {
        Toast.makeText(this, resId, duration).show();
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/NoteEditText.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/NoteEditText.java
@ -0,0 +1,217 @@
 /*
 * 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.ui;
 import android.content.Context;
 import android.graphics.Rect;
 import android.text.Layout;
 import android.text.Selection;
 import android.text.Spanned;
 import android.text.TextUtils;
 import android.text.style.URLSpan;
 import android.util.AttributeSet;
 import android.util.Log;
 import android.view.ContextMenu;
 import android.view.KeyEvent;
 import android.view.MenuItem;
 import android.view.MenuItem.OnMenuItemClickListener;
 import android.view.MotionEvent;
 import android.widget.EditText;
 import net.micode.notes.R;
 import java.util.HashMap;
 import java.util.Map;
 public class NoteEditText extends EditText {
    private static final String TAG = "NoteEditText";
    private int mIndex;
    private int mSelectionStartBeforeDelete;
    private static final String SCHEME_TEL = "tel:" ;
    private static final String SCHEME_HTTP = "http:" ;
    private static final String SCHEME_EMAIL = "mailto:" ;
    private static final Map<String, Integer> sSchemaActionResMap = new HashMap<String, Integer>();
    static {
        sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel);
        sSchemaActionResMap.put(SCHEME_HTTP, R.string.note_link_web);
        sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email);
    }
    /**
     * Call by the {@link NoteEditActivity} to delete or add edit text
     */
    public interface OnTextViewChangeListener {
        /**
         * Delete current edit text when {@link KeyEvent#KEYCODE_DEL} happens
         * and the text is null
         */
        void onEditTextDelete(int index, String text);
        /**
         * Add edit text after current edit text when {@link KeyEvent#KEYCODE_ENTER}
         * happen
         */
        void onEditTextEnter(int index, String text);
        /**
         * Hide or show item option when text change
         */
        void onTextChange(int index, boolean hasText);
    }
    private OnTextViewChangeListener mOnTextViewChangeListener;
    public NoteEditText(Context context) {
        super(context, null);
        mIndex = 0;
    }
    public void setIndex(int index) {
        mIndex = index;
    }
    public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
        mOnTextViewChangeListener = listener;
    }
    public NoteEditText(Context context, AttributeSet attrs) {
        super(context, attrs, android.R.attr.editTextStyle);
    }
    public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        // TODO Auto-generated constructor stub
    }
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                int x = (int) event.getX();
                int y = (int) event.getY();
                x -= getTotalPaddingLeft();
                y -= getTotalPaddingTop();
                x += getScrollX();
                y += getScrollY();
                Layout layout = getLayout();
                int line = layout.getLineForVertical(y);
                int off = layout.getOffsetForHorizontal(line, x);
                Selection.setSelection(getText(), off);
                break;
        }
        return super.onTouchEvent(event);
    }
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        switch (keyCode) {
            case KeyEvent.KEYCODE_ENTER:
                if (mOnTextViewChangeListener != null) {
                    return false;
                }
                break;
            case KeyEvent.KEYCODE_DEL:
                mSelectionStartBeforeDelete = getSelectionStart();
                break;
            default:
                break;
        }
        return super.onKeyDown(keyCode, event);
    }
    @Override
    public boolean onKeyUp(int keyCode, KeyEvent event) {
        switch(keyCode) {
            case KeyEvent.KEYCODE_DEL:
                if (mOnTextViewChangeListener != null) {
                    if (0 == mSelectionStartBeforeDelete && mIndex != 0) {
                        mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString());
                        return true;
                    }
                } else {
                    Log.d(TAG, "OnTextViewChangeListener was not seted");
                }
                break;
            case KeyEvent.KEYCODE_ENTER:
                if (mOnTextViewChangeListener != null) {
                    int selectionStart = getSelectionStart();
                    String text = getText().subSequence(selectionStart, length()).toString();
                    setText(getText().subSequence(0, selectionStart));
                    mOnTextViewChangeListener.onEditTextEnter(mIndex + 1, text);
                } else {
                    Log.d(TAG, "OnTextViewChangeListener was not seted");
                }
                break;
            default:
                break;
        }
        return super.onKeyUp(keyCode, event);
    }
    @Override
    protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
        if (mOnTextViewChangeListener != null) {
            if (!focused && TextUtils.isEmpty(getText())) {
                mOnTextViewChangeListener.onTextChange(mIndex, false);
            } else {
                mOnTextViewChangeListener.onTextChange(mIndex, true);
            }
        }
        super.onFocusChanged(focused, direction, previouslyFocusedRect);
    }
    @Override
    protected void onCreateContextMenu(ContextMenu menu) {
        if (getText() instanceof Spanned) {
            int selStart = getSelectionStart();
            int selEnd = getSelectionEnd();
            int min = Math.min(selStart, selEnd);
            int max = Math.max(selStart, selEnd);
            final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class);
            if (urls.length == 1) {
                int defaultResId = 0;
                for(String schema: sSchemaActionResMap.keySet()) {
                    if(urls[0].getURL().indexOf(schema) >= 0) {
                        defaultResId = sSchemaActionResMap.get(schema);
                        break;
                    }
                }
                if (defaultResId == 0) {
                    defaultResId = R.string.note_link_other;
                }
                menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener(
                        new OnMenuItemClickListener() {
                            public boolean onMenuItemClick(MenuItem item) {
                                // goto a new intent
                                urls[0].onClick(NoteEditText.this);
                                return true;
                            }
                        });
            }
        }
        super.onCreateContextMenu(menu);
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/NoteItemData.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/NoteItemData.java
@ -0,0 +1,224 @@
 /*
 * 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.ui;
 import android.content.Context;
 import android.database.Cursor;
 import android.text.TextUtils;
 import net.micode.notes.data.Contact;
 import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.tool.DataUtils;
 public class NoteItemData {
    static final String [] PROJECTION = 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,
    };
    private static final int ID_COLUMN                    = 0;
    private static final int ALERTED_DATE_COLUMN          = 1;
    private static final int BG_COLOR_ID_COLUMN           = 2;
    private static final int CREATED_DATE_COLUMN          = 3;
    private static final int HAS_ATTACHMENT_COLUMN        = 4;
    private static final int MODIFIED_DATE_COLUMN         = 5;
    private static final int NOTES_COUNT_COLUMN           = 6;
    private static final int PARENT_ID_COLUMN             = 7;
    private static final int SNIPPET_COLUMN               = 8;
    private static final int TYPE_COLUMN                  = 9;
    private static final int WIDGET_ID_COLUMN             = 10;
    private static final int WIDGET_TYPE_COLUMN           = 11;
    private long mId;
    private long mAlertDate;
    private int mBgColorId;
    private long mCreatedDate;
    private boolean mHasAttachment;
    private long mModifiedDate;
    private int mNotesCount;
    private long mParentId;
    private String mSnippet;
    private int mType;
    private int mWidgetId;
    private int mWidgetType;
    private String mName;
    private String mPhoneNumber;
    private boolean mIsLastItem;
    private boolean mIsFirstItem;
    private boolean mIsOnlyOneItem;
    private boolean mIsOneNoteFollowingFolder;
    private boolean mIsMultiNotesFollowingFolder;
    public NoteItemData(Context context, Cursor cursor) {
        mId = cursor.getLong(ID_COLUMN);
        mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN);
        mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN);
        mCreatedDate = cursor.getLong(CREATED_DATE_COLUMN);
        mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0) ? true : false;
        mModifiedDate = cursor.getLong(MODIFIED_DATE_COLUMN);
        mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN);
        mParentId = cursor.getLong(PARENT_ID_COLUMN);
        mSnippet = cursor.getString(SNIPPET_COLUMN);
        mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(
                NoteEditActivity.TAG_UNCHECKED, "");
        mType = cursor.getInt(TYPE_COLUMN);
        mWidgetId = cursor.getInt(WIDGET_ID_COLUMN);
        mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN);
        mPhoneNumber = "";
        if (mParentId == Notes.ID_CALL_RECORD_FOLDER) {
            mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId);
            if (!TextUtils.isEmpty(mPhoneNumber)) {
                mName = Contact.getContact(context, mPhoneNumber);
                if (mName == null) {
                    mName = mPhoneNumber;
                }
            }
        }
        if (mName == null) {
            mName = "";
        }
        checkPostion(cursor);
    }
    private void checkPostion(Cursor cursor) {
        mIsLastItem = cursor.isLast() ? true : false;
        mIsFirstItem = cursor.isFirst() ? true : false;
        mIsOnlyOneItem = (cursor.getCount() == 1);
        mIsMultiNotesFollowingFolder = false;
        mIsOneNoteFollowingFolder = false;
        if (mType == Notes.TYPE_NOTE && !mIsFirstItem) {
            int position = cursor.getPosition();
            if (cursor.moveToPrevious()) {
                if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER
                        || cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) {
                    if (cursor.getCount() > (position + 1)) {
                        mIsMultiNotesFollowingFolder = true;
                    } else {
                        mIsOneNoteFollowingFolder = true;
                    }
                }
                if (!cursor.moveToNext()) {
                    throw new IllegalStateException("cursor move to previous but can't move back");
                }
            }
        }
    }
    public boolean isOneFollowingFolder() {
        return mIsOneNoteFollowingFolder;
    }
    public boolean isMultiFollowingFolder() {
        return mIsMultiNotesFollowingFolder;
    }
    public boolean isLast() {
        return mIsLastItem;
    }
    public String getCallName() {
        return mName;
    }
    public boolean isFirst() {
        return mIsFirstItem;
    }
    public boolean isSingle() {
        return mIsOnlyOneItem;
    }
    public long getId() {
        return mId;
    }
    public long getAlertDate() {
        return mAlertDate;
    }
    public long getCreatedDate() {
        return mCreatedDate;
    }
    public boolean hasAttachment() {
        return mHasAttachment;
    }
    public long getModifiedDate() {
        return mModifiedDate;
    }
    public int getBgColorId() {
        return mBgColorId;
    }
    public long getParentId() {
        return mParentId;
    }
    public int getNotesCount() {
        return mNotesCount;
    }
    public long getFolderId () {
        return mParentId;
    }
    public int getType() {
        return mType;
    }
    public int getWidgetType() {
        return mWidgetType;
    }
    public int getWidgetId() {
        return mWidgetId;
    }
    public String getSnippet() {
        return mSnippet;
    }
    public boolean hasAlert() {
        return (mAlertDate > 0);
    }
    public boolean isCallRecord() {
        return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber));
    }
    public static int getNoteType(Cursor cursor) {
        return cursor.getInt(TYPE_COLUMN);
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/NotesListActivity.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/NotesListActivity.java
@ -0,0 +1,954 @@
 /*
 * 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.ui;
 import android.app.Activity;
 import android.app.AlertDialog;
 import android.app.Dialog;
 import android.appwidget.AppWidgetManager;
 import android.content.AsyncQueryHandler;
 import android.content.ContentResolver;
 import android.content.ContentValues;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.Intent;
 import android.content.SharedPreferences;
 import android.database.Cursor;
 import android.os.AsyncTask;
 import android.os.Bundle;
 import android.preference.PreferenceManager;
 import android.text.Editable;
 import android.text.TextUtils;
 import android.text.TextWatcher;
 import android.util.Log;
 import android.view.ActionMode;
 import android.view.ContextMenu;
 import android.view.ContextMenu.ContextMenuInfo;
 import android.view.Display;
 import android.view.HapticFeedbackConstants;
 import android.view.LayoutInflater;
 import android.view.Menu;
 import android.view.MenuItem;
 import android.view.MenuItem.OnMenuItemClickListener;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.view.View.OnCreateContextMenuListener;
 import android.view.View.OnTouchListener;
 import android.view.inputmethod.InputMethodManager;
 import android.widget.AdapterView;
 import android.widget.AdapterView.OnItemClickListener;
 import android.widget.AdapterView.OnItemLongClickListener;
 import android.widget.Button;
 import android.widget.EditText;
 import android.widget.ListView;
 import android.widget.PopupMenu;
 import android.widget.TextView;
 import android.widget.Toast;
 import net.micode.notes.R;
 import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.gtask.remote.GTaskSyncService;
 import net.micode.notes.model.WorkingNote;
 import net.micode.notes.tool.BackupUtils;
 import net.micode.notes.tool.DataUtils;
 import net.micode.notes.tool.ResourceParser;
 import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;
 import net.micode.notes.widget.NoteWidgetProvider_2x;
 import net.micode.notes.widget.NoteWidgetProvider_4x;
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.util.HashSet;
 public class NotesListActivity extends Activity implements OnClickListener, OnItemLongClickListener {
    private static final int FOLDER_NOTE_LIST_QUERY_TOKEN = 0;
    private static final int FOLDER_LIST_QUERY_TOKEN      = 1;
    private static final int MENU_FOLDER_DELETE = 0;
    private static final int MENU_FOLDER_VIEW = 1;
    private static final int MENU_FOLDER_CHANGE_NAME = 2;
    private static final String PREFERENCE_ADD_INTRODUCTION = "net.micode.notes.introduction";
    private enum ListEditState {
        NOTE_LIST, SUB_FOLDER, CALL_RECORD_FOLDER
    };
    private ListEditState mState;
    private BackgroundQueryHandler mBackgroundQueryHandler;
    private NotesListAdapter mNotesListAdapter;
    private ListView mNotesListView;
    private Button mAddNewNote;
    private boolean mDispatch;
    private int mOriginY;
    private int mDispatchY;
    private TextView mTitleBar;
    private long mCurrentFolderId;
    private ContentResolver mContentResolver;
    private ModeCallback mModeCallBack;
    private static final String TAG = "NotesListActivity";
    public static final int NOTES_LISTVIEW_SCROLL_RATE = 30;
    private NoteItemData mFocusNoteDataItem;
    private static final String NORMAL_SELECTION = NoteColumns.PARENT_ID + "=?";
    private static final String ROOT_FOLDER_SELECTION = "(" + NoteColumns.TYPE + "<>"
            + Notes.TYPE_SYSTEM + " AND " + NoteColumns.PARENT_ID + "=?)" + " OR ("
            + NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER + " AND "
            + NoteColumns.NOTES_COUNT + ">0)";
    private final static int REQUEST_CODE_OPEN_NODE = 102;
    private final static int REQUEST_CODE_NEW_NODE  = 103;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.note_list);
        initResources();
        /**
         * Insert an introduction when user firstly use this application
         */
        setAppInfoFromRawRes();
    }
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (resultCode == RESULT_OK
                && (requestCode == REQUEST_CODE_OPEN_NODE || requestCode == REQUEST_CODE_NEW_NODE)) {
            mNotesListAdapter.changeCursor(null);
        } else {
            super.onActivityResult(requestCode, resultCode, data);
        }
    }
    private void setAppInfoFromRawRes() {
        SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
        if (!sp.getBoolean(PREFERENCE_ADD_INTRODUCTION, false)) {
            StringBuilder sb = new StringBuilder();
            InputStream in = null;
            try {
                 in = getResources().openRawResource(R.raw.introduction);
                if (in != null) {
                    InputStreamReader isr = new InputStreamReader(in);
                    BufferedReader br = new BufferedReader(isr);
                    char [] buf = new char[1024];
                    int len = 0;
                    while ((len = br.read(buf)) > 0) {
                        sb.append(buf, 0, len);
                    }
                } else {
                    Log.e(TAG, "Read introduction file error");
                    return;
                }
            } catch (IOException e) {
                e.printStackTrace();
                return;
            } finally {
                if(in != null) {
                    try {
                        in.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
            WorkingNote note = WorkingNote.createEmptyNote(this, Notes.ID_ROOT_FOLDER,
                    AppWidgetManager.INVALID_APPWIDGET_ID, Notes.TYPE_WIDGET_INVALIDE,
                    ResourceParser.RED);
            note.setWorkingText(sb.toString());
            if (note.saveNote()) {
                sp.edit().putBoolean(PREFERENCE_ADD_INTRODUCTION, true).commit();
            } else {
                Log.e(TAG, "Save introduction note error");
                return;
            }
        }
    }
    @Override
    protected void onStart() {
        super.onStart();
        startAsyncNotesListQuery();
    }
    private void initResources() {
        mContentResolver = this.getContentResolver();
        mBackgroundQueryHandler = new BackgroundQueryHandler(this.getContentResolver());
        mCurrentFolderId = Notes.ID_ROOT_FOLDER;
        mNotesListView = (ListView) findViewById(R.id.notes_list);
        mNotesListView.addFooterView(LayoutInflater.from(this).inflate(R.layout.note_list_footer, null),
                null, false);
        mNotesListView.setOnItemClickListener(new OnListItemClickListener());
        mNotesListView.setOnItemLongClickListener(this);
        mNotesListAdapter = new NotesListAdapter(this);
        mNotesListView.setAdapter(mNotesListAdapter);
        mAddNewNote = (Button) findViewById(R.id.btn_new_note);
        mAddNewNote.setOnClickListener(this);
        mAddNewNote.setOnTouchListener(new NewNoteOnTouchListener());
        mDispatch = false;
        mDispatchY = 0;
        mOriginY = 0;
        mTitleBar = (TextView) findViewById(R.id.tv_title_bar);
        mState = ListEditState.NOTE_LIST;
        mModeCallBack = new ModeCallback();
    }
    private class ModeCallback implements ListView.MultiChoiceModeListener, OnMenuItemClickListener {
        private DropdownMenu mDropDownMenu;
        private ActionMode mActionMode;
        private MenuItem mMoveMenu;
        public boolean onCreateActionMode(ActionMode mode, Menu menu) {
            getMenuInflater().inflate(R.menu.note_list_options, menu);
            menu.findItem(R.id.delete).setOnMenuItemClickListener(this);
            mMoveMenu = menu.findItem(R.id.move);
            if (mFocusNoteDataItem.getParentId() == Notes.ID_CALL_RECORD_FOLDER
                    || DataUtils.getUserFolderCount(mContentResolver) == 0) {
                mMoveMenu.setVisible(false);
            } else {
                mMoveMenu.setVisible(true);
                mMoveMenu.setOnMenuItemClickListener(this);
            }
            mActionMode = mode;
            mNotesListAdapter.setChoiceMode(true);
            mNotesListView.setLongClickable(false);
            mAddNewNote.setVisibility(View.GONE);
            View customView = LayoutInflater.from(NotesListActivity.this).inflate(
                    R.layout.note_list_dropdown_menu, null);
            mode.setCustomView(customView);
            mDropDownMenu = new DropdownMenu(NotesListActivity.this,
                    (Button) customView.findViewById(R.id.selection_menu),
                    R.menu.note_list_dropdown);
            mDropDownMenu.setOnDropdownMenuItemClickListener(new PopupMenu.OnMenuItemClickListener(){
                public boolean onMenuItemClick(MenuItem item) {
                    mNotesListAdapter.selectAll(!mNotesListAdapter.isAllSelected());
                    updateMenu();
                    return true;
                }
            });
            return true;
        }
        private void updateMenu() {
            int selectedCount = mNotesListAdapter.getSelectedCount();
            // Update dropdown menu
            String format = getResources().getString(R.string.menu_select_title, selectedCount);
            mDropDownMenu.setTitle(format);
            MenuItem item = mDropDownMenu.findItem(R.id.action_select_all);
            if (item != null) {
                if (mNotesListAdapter.isAllSelected()) {
                    item.setChecked(true);
                    item.setTitle(R.string.menu_deselect_all);
                } else {
                    item.setChecked(false);
                    item.setTitle(R.string.menu_select_all);
                }
            }
        }
        public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
            // TODO Auto-generated method stub
            return false;
        }
        public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
            // TODO Auto-generated method stub
            return false;
        }
        public void onDestroyActionMode(ActionMode mode) {
            mNotesListAdapter.setChoiceMode(false);
            mNotesListView.setLongClickable(true);
            mAddNewNote.setVisibility(View.VISIBLE);
        }
        public void finishActionMode() {
            mActionMode.finish();
        }
        public void onItemCheckedStateChanged(ActionMode mode, int position, long id,
                boolean checked) {
            mNotesListAdapter.setCheckedItem(position, checked);
            updateMenu();
        }
        public boolean onMenuItemClick(MenuItem item) {
            if (mNotesListAdapter.getSelectedCount() == 0) {
                Toast.makeText(NotesListActivity.this, getString(R.string.menu_select_none),
                        Toast.LENGTH_SHORT).show();
                return true;
            }
            switch (item.getItemId()) {
                case R.id.delete:
                    AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
                    builder.setTitle(getString(R.string.alert_title_delete));
                    builder.setIcon(android.R.drawable.ic_dialog_alert);
                    builder.setMessage(getString(R.string.alert_message_delete_notes,
                                             mNotesListAdapter.getSelectedCount()));
                    builder.setPositiveButton(android.R.string.ok,
                                             new DialogInterface.OnClickListener() {
                                                 public void onClick(DialogInterface dialog,
                                                         int which) {
                                                     batchDelete();
                                                 }
                                             });
                    builder.setNegativeButton(android.R.string.cancel, null);
                    builder.show();
                    break;
                case R.id.move:
                    startQueryDestinationFolders();
                    break;
                default:
                    return false;
            }
            return true;
        }
    }
    private class NewNoteOnTouchListener implements OnTouchListener {
        public boolean onTouch(View v, MotionEvent event) {
            switch (event.getAction()) {
                case MotionEvent.ACTION_DOWN: {
                    Display display = getWindowManager().getDefaultDisplay();
                    int screenHeight = display.getHeight();
                    int newNoteViewHeight = mAddNewNote.getHeight();
                    int start = screenHeight - newNoteViewHeight;
                    int eventY = start + (int) event.getY();
                    /**
                     * Minus TitleBar's height
                     */
                    if (mState == ListEditState.SUB_FOLDER) {
                        eventY -= mTitleBar.getHeight();
                        start -= mTitleBar.getHeight();
                    }
                    /**
                     * HACKME:When click the transparent part of "New Note" button, dispatch
                     * the event to the list view behind this button. The transparent part of
                     * "New Note" button could be expressed by formula y=-0.12x+94（Unit:pixel）
                     * and the line top of the button. The coordinate based on left of the "New
                     * Note" button. The 94 represents maximum height of the transparent part.
                     * Notice that, if the background of the button changes, the formula should
                     * also change. This is very bad, just for the UI designer's strong requirement.
                     */
                    if (event.getY() < (event.getX() * (-0.12) + 94)) {
                        View view = mNotesListView.getChildAt(mNotesListView.getChildCount() - 1
                                - mNotesListView.getFooterViewsCount());
                        if (view != null && view.getBottom() > start
                                && (view.getTop() < (start + 94))) {
                            mOriginY = (int) event.getY();
                            mDispatchY = eventY;
                            event.setLocation(event.getX(), mDispatchY);
                            mDispatch = true;
                            return mNotesListView.dispatchTouchEvent(event);
                        }
                    }
                    break;
                }
                case MotionEvent.ACTION_MOVE: {
                    if (mDispatch) {
                        mDispatchY += (int) event.getY() - mOriginY;
                        event.setLocation(event.getX(), mDispatchY);
                        return mNotesListView.dispatchTouchEvent(event);
                    }
                    break;
                }
                default: {
                    if (mDispatch) {
                        event.setLocation(event.getX(), mDispatchY);
                        mDispatch = false;
                        return mNotesListView.dispatchTouchEvent(event);
                    }
                    break;
                }
            }
            return false;
        }
    };
    private void startAsyncNotesListQuery() {
        String selection = (mCurrentFolderId == Notes.ID_ROOT_FOLDER) ? ROOT_FOLDER_SELECTION
                : NORMAL_SELECTION;
        mBackgroundQueryHandler.startQuery(FOLDER_NOTE_LIST_QUERY_TOKEN, null,
                Notes.CONTENT_NOTE_URI, NoteItemData.PROJECTION, selection, new String[] {
                    String.valueOf(mCurrentFolderId)
                }, NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC");
    }
    private final class BackgroundQueryHandler extends AsyncQueryHandler {
        public BackgroundQueryHandler(ContentResolver contentResolver) {
            super(contentResolver);
        }
        @Override
        protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
            switch (token) {
                case FOLDER_NOTE_LIST_QUERY_TOKEN:
                    mNotesListAdapter.changeCursor(cursor);
                    break;
                case FOLDER_LIST_QUERY_TOKEN:
                    if (cursor != null && cursor.getCount() > 0) {
                        showFolderListMenu(cursor);
                    } else {
                        Log.e(TAG, "Query folder failed");
                    }
                    break;
                default:
                    return;
            }
        }
    }
    private void showFolderListMenu(Cursor cursor) {
        AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
        builder.setTitle(R.string.menu_title_select_folder);
        final FoldersListAdapter adapter = new FoldersListAdapter(this, cursor);
        builder.setAdapter(adapter, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                DataUtils.batchMoveToFolder(mContentResolver,
                        mNotesListAdapter.getSelectedItemIds(), adapter.getItemId(which));
                Toast.makeText(
                        NotesListActivity.this,
                        getString(R.string.format_move_notes_to_folder,
                                mNotesListAdapter.getSelectedCount(),
                                adapter.getFolderName(NotesListActivity.this, which)),
                        Toast.LENGTH_SHORT).show();
                mModeCallBack.finishActionMode();
            }
        });
        builder.show();
    }
    private void createNewNote() {
        Intent intent = new Intent(this, NoteEditActivity.class);
        intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
        intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mCurrentFolderId);
        this.startActivityForResult(intent, REQUEST_CODE_NEW_NODE);
    }
    private void batchDelete() {
        new AsyncTask<Void, Void, HashSet<AppWidgetAttribute>>() {
            protected HashSet<AppWidgetAttribute> doInBackground(Void... unused) {
                HashSet<AppWidgetAttribute> widgets = mNotesListAdapter.getSelectedWidget();
                if (!isSyncMode()) {
                    // if not synced, delete notes directly
                    if (DataUtils.batchDeleteNotes(mContentResolver, mNotesListAdapter
                            .getSelectedItemIds())) {
                    } else {
                        Log.e(TAG, "Delete notes error, should not happens");
                    }
                } else {
                    // in sync mode, we'll move the deleted note into the trash
                    // folder
                    if (!DataUtils.batchMoveToFolder(mContentResolver, mNotesListAdapter
                            .getSelectedItemIds(), Notes.ID_TRASH_FOLER)) {
                        Log.e(TAG, "Move notes to trash folder error, should not happens");
                    }
                }
                return widgets;
            }
            @Override
            protected void onPostExecute(HashSet<AppWidgetAttribute> widgets) {
                if (widgets != null) {
                    for (AppWidgetAttribute widget : widgets) {
                        if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID
                                && widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) {
                            updateWidget(widget.widgetId, widget.widgetType);
                        }
                    }
                }
                mModeCallBack.finishActionMode();
            }
        }.execute();
    }
    private void deleteFolder(long folderId) {
        if (folderId == Notes.ID_ROOT_FOLDER) {
            Log.e(TAG, "Wrong folder id, should not happen " + folderId);
            return;
        }
        HashSet<Long> ids = new HashSet<Long>();
        ids.add(folderId);
        HashSet<AppWidgetAttribute> widgets = DataUtils.getFolderNoteWidget(mContentResolver,
                folderId);
        if (!isSyncMode()) {
            // if not synced, delete folder directly
            DataUtils.batchDeleteNotes(mContentResolver, ids);
        } else {
            // in sync mode, we'll move the deleted folder into the trash folder
            DataUtils.batchMoveToFolder(mContentResolver, ids, Notes.ID_TRASH_FOLER);
        }
        if (widgets != null) {
            for (AppWidgetAttribute widget : widgets) {
                if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID
                        && widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) {
                    updateWidget(widget.widgetId, widget.widgetType);
                }
            }
        }
    }
    private void openNode(NoteItemData data) {
        Intent intent = new Intent(this, NoteEditActivity.class);
        intent.setAction(Intent.ACTION_VIEW);
        intent.putExtra(Intent.EXTRA_UID, data.getId());
        this.startActivityForResult(intent, REQUEST_CODE_OPEN_NODE);
    }
    private void openFolder(NoteItemData data) {
        mCurrentFolderId = data.getId();
        startAsyncNotesListQuery();
        if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
            mState = ListEditState.CALL_RECORD_FOLDER;
            mAddNewNote.setVisibility(View.GONE);
        } else {
            mState = ListEditState.SUB_FOLDER;
        }
        if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
            mTitleBar.setText(R.string.call_record_folder_name);
        } else {
            mTitleBar.setText(data.getSnippet());
        }
        mTitleBar.setVisibility(View.VISIBLE);
    }
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_new_note:
                createNewNote();
                break;
            default:
                break;
        }
    }
    private void showSoftInput() {
        InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        if (inputMethodManager != null) {
            inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
        }
    }
    private void hideSoftInput(View view) {
        InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
    }
    private void showCreateOrModifyFolderDialog(final boolean create) {
        final AlertDialog.Builder builder = new AlertDialog.Builder(this);
        View view = LayoutInflater.from(this).inflate(R.layout.dialog_edit_text, null);
        final EditText etName = (EditText) view.findViewById(R.id.et_foler_name);
        showSoftInput();
        if (!create) {
            if (mFocusNoteDataItem != null) {
                etName.setText(mFocusNoteDataItem.getSnippet());
                builder.setTitle(getString(R.string.menu_folder_change_name));
            } else {
                Log.e(TAG, "The long click data item is null");
                return;
            }
        } else {
            etName.setText("");
            builder.setTitle(this.getString(R.string.menu_create_folder));
        }
        builder.setPositiveButton(android.R.string.ok, null);
        builder.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                hideSoftInput(etName);
            }
        });
        final Dialog dialog = builder.setView(view).show();
        final Button positive = (Button)dialog.findViewById(android.R.id.button1);
        positive.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                hideSoftInput(etName);
                String name = etName.getText().toString();
                if (DataUtils.checkVisibleFolderName(mContentResolver, name)) {
                    Toast.makeText(NotesListActivity.this, getString(R.string.folder_exist, name),
                            Toast.LENGTH_LONG).show();
                    etName.setSelection(0, etName.length());
                    return;
                }
                if (!create) {
                    if (!TextUtils.isEmpty(name)) {
                        ContentValues values = new ContentValues();
                        values.put(NoteColumns.SNIPPET, name);
                        values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
                        values.put(NoteColumns.LOCAL_MODIFIED, 1);
                        mContentResolver.update(Notes.CONTENT_NOTE_URI, values, NoteColumns.ID
                                + "=?", new String[] {
                            String.valueOf(mFocusNoteDataItem.getId())
                        });
                    }
                } else if (!TextUtils.isEmpty(name)) {
                    ContentValues values = new ContentValues();
                    values.put(NoteColumns.SNIPPET, name);
                    values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
                    mContentResolver.insert(Notes.CONTENT_NOTE_URI, values);
                }
                dialog.dismiss();
            }
        });
        if (TextUtils.isEmpty(etName.getText())) {
            positive.setEnabled(false);
        }
        /**
         * When the name edit text is null, disable the positive button
         */
        etName.addTextChangedListener(new TextWatcher() {
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                // TODO Auto-generated method stub
            }
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                if (TextUtils.isEmpty(etName.getText())) {
                    positive.setEnabled(false);
                } else {
                    positive.setEnabled(true);
                }
            }
            public void afterTextChanged(Editable s) {
                // TODO Auto-generated method stub
            }
        });
    }
    @Override
    public void onBackPressed() {
        switch (mState) {
            case SUB_FOLDER:
                mCurrentFolderId = Notes.ID_ROOT_FOLDER;
                mState = ListEditState.NOTE_LIST;
                startAsyncNotesListQuery();
                mTitleBar.setVisibility(View.GONE);
                break;
            case CALL_RECORD_FOLDER:
                mCurrentFolderId = Notes.ID_ROOT_FOLDER;
                mState = ListEditState.NOTE_LIST;
                mAddNewNote.setVisibility(View.VISIBLE);
                mTitleBar.setVisibility(View.GONE);
                startAsyncNotesListQuery();
                break;
            case NOTE_LIST:
                super.onBackPressed();
                break;
            default:
                break;
        }
    }
    private void updateWidget(int appWidgetId, int appWidgetType) {
        Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
        if (appWidgetType == Notes.TYPE_WIDGET_2X) {
            intent.setClass(this, NoteWidgetProvider_2x.class);
        } else if (appWidgetType == Notes.TYPE_WIDGET_4X) {
            intent.setClass(this, NoteWidgetProvider_4x.class);
        } else {
            Log.e(TAG, "Unspported widget type");
            return;
        }
        intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] {
            appWidgetId
        });
        sendBroadcast(intent);
        setResult(RESULT_OK, intent);
    }
    private final OnCreateContextMenuListener mFolderOnCreateContextMenuListener = new OnCreateContextMenuListener() {
        public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
            if (mFocusNoteDataItem != null) {
                menu.setHeaderTitle(mFocusNoteDataItem.getSnippet());
                menu.add(0, MENU_FOLDER_VIEW, 0, R.string.menu_folder_view);
                menu.add(0, MENU_FOLDER_DELETE, 0, R.string.menu_folder_delete);
                menu.add(0, MENU_FOLDER_CHANGE_NAME, 0, R.string.menu_folder_change_name);
            }
        }
    };
    @Override
    public void onContextMenuClosed(Menu menu) {
        if (mNotesListView != null) {
            mNotesListView.setOnCreateContextMenuListener(null);
        }
        super.onContextMenuClosed(menu);
    }
    @Override
    public boolean onContextItemSelected(MenuItem item) {
        if (mFocusNoteDataItem == null) {
            Log.e(TAG, "The long click data item is null");
            return false;
        }
        switch (item.getItemId()) {
            case MENU_FOLDER_VIEW:
                openFolder(mFocusNoteDataItem);
                break;
            case MENU_FOLDER_DELETE:
                AlertDialog.Builder builder = new AlertDialog.Builder(this);
                builder.setTitle(getString(R.string.alert_title_delete));
                builder.setIcon(android.R.drawable.ic_dialog_alert);
                builder.setMessage(getString(R.string.alert_message_delete_folder));
                builder.setPositiveButton(android.R.string.ok,
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog, int which) {
                                deleteFolder(mFocusNoteDataItem.getId());
                            }
                        });
                builder.setNegativeButton(android.R.string.cancel, null);
                builder.show();
                break;
            case MENU_FOLDER_CHANGE_NAME:
                showCreateOrModifyFolderDialog(false);
                break;
            default:
                break;
        }
        return true;
    }
    @Override
    public boolean onPrepareOptionsMenu(Menu menu) {
        menu.clear();
        if (mState == ListEditState.NOTE_LIST) {
            getMenuInflater().inflate(R.menu.note_list, menu);
            // set sync or sync_cancel
            menu.findItem(R.id.menu_sync).setTitle(
                    GTaskSyncService.isSyncing() ? R.string.menu_sync_cancel : R.string.menu_sync);
        } else if (mState == ListEditState.SUB_FOLDER) {
            getMenuInflater().inflate(R.menu.sub_folder, menu);
        } else if (mState == ListEditState.CALL_RECORD_FOLDER) {
            getMenuInflater().inflate(R.menu.call_record_folder, menu);
        } else {
            Log.e(TAG, "Wrong state:" + mState);
        }
        return true;
    }
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case R.id.menu_new_folder: {
                showCreateOrModifyFolderDialog(true);
                break;
            }
            case R.id.menu_export_text: {
                exportNoteToText();
                break;
            }
            case R.id.menu_sync: {
                if (isSyncMode()) {
                    if (TextUtils.equals(item.getTitle(), getString(R.string.menu_sync))) {
                        GTaskSyncService.startSync(this);
                    } else {
                        GTaskSyncService.cancelSync(this);
                    }
                } else {
                    startPreferenceActivity();
                }
                break;
            }
            case R.id.menu_setting: {
                startPreferenceActivity();
                break;
            }
            case R.id.menu_new_note: {
                createNewNote();
                break;
            }
            case R.id.menu_search:
                onSearchRequested();
                break;
            default:
                break;
        }
        return true;
    }
    @Override
    public boolean onSearchRequested() {
        startSearch(null, false, null /* appData */, false);
        return true;
    }
    private void exportNoteToText() {
        final BackupUtils backup = BackupUtils.getInstance(NotesListActivity.this);
        new AsyncTask<Void, Void, Integer>() {
            @Override
            protected Integer doInBackground(Void... unused) {
                return backup.exportToText();
            }
            @Override
            protected void onPostExecute(Integer result) {
                if (result == BackupUtils.STATE_SD_CARD_UNMOUONTED) {
                    AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
                    builder.setTitle(NotesListActivity.this
                            .getString(R.string.failed_sdcard_export));
                    builder.setMessage(NotesListActivity.this
                            .getString(R.string.error_sdcard_unmounted));
                    builder.setPositiveButton(android.R.string.ok, null);
                    builder.show();
                } else if (result == BackupUtils.STATE_SUCCESS) {
                    AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
                    builder.setTitle(NotesListActivity.this
                            .getString(R.string.success_sdcard_export));
                    builder.setMessage(NotesListActivity.this.getString(
                            R.string.format_exported_file_location, backup
                                    .getExportedTextFileName(), backup.getExportedTextFileDir()));
                    builder.setPositiveButton(android.R.string.ok, null);
                    builder.show();
                } else if (result == BackupUtils.STATE_SYSTEM_ERROR) {
                    AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
                    builder.setTitle(NotesListActivity.this
                            .getString(R.string.failed_sdcard_export));
                    builder.setMessage(NotesListActivity.this
                            .getString(R.string.error_sdcard_export));
                    builder.setPositiveButton(android.R.string.ok, null);
                    builder.show();
                }
            }
        }.execute();
    }
    private boolean isSyncMode() {
        return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
    }
    private void startPreferenceActivity() {
        Activity from = getParent() != null ? getParent() : this;
        Intent intent = new Intent(from, NotesPreferenceActivity.class);
        from.startActivityIfNeeded(intent, -1);
    }
    private class OnListItemClickListener implements OnItemClickListener {
        public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
            if (view instanceof NotesListItem) {
                NoteItemData item = ((NotesListItem) view).getItemData();
                if (mNotesListAdapter.isInChoiceMode()) {
                    if (item.getType() == Notes.TYPE_NOTE) {
                        position = position - mNotesListView.getHeaderViewsCount();
                        mModeCallBack.onItemCheckedStateChanged(null, position, id,
                                !mNotesListAdapter.isSelectedItem(position));
                    }
                    return;
                }
                switch (mState) {
                    case NOTE_LIST:
                        if (item.getType() == Notes.TYPE_FOLDER
                                || item.getType() == Notes.TYPE_SYSTEM) {
                            openFolder(item);
                        } else if (item.getType() == Notes.TYPE_NOTE) {
                            openNode(item);
                        } else {
                            Log.e(TAG, "Wrong note type in NOTE_LIST");
                        }
                        break;
                    case SUB_FOLDER:
                    case CALL_RECORD_FOLDER:
                        if (item.getType() == Notes.TYPE_NOTE) {
                            openNode(item);
                        } else {
                            Log.e(TAG, "Wrong note type in SUB_FOLDER");
                        }
                        break;
                    default:
                        break;
                }
            }
        }
    }
    private void startQueryDestinationFolders() {
        String selection = NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>? AND " + NoteColumns.ID + "<>?";
        selection = (mState == ListEditState.NOTE_LIST) ? selection:
            "(" + selection + ") OR (" + NoteColumns.ID + "=" + Notes.ID_ROOT_FOLDER + ")";
        mBackgroundQueryHandler.startQuery(FOLDER_LIST_QUERY_TOKEN,
                null,
                Notes.CONTENT_NOTE_URI,
                FoldersListAdapter.PROJECTION,
                selection,
                new String[] {
                        String.valueOf(Notes.TYPE_FOLDER),
                        String.valueOf(Notes.ID_TRASH_FOLER),
                        String.valueOf(mCurrentFolderId)
                },
                NoteColumns.MODIFIED_DATE + " DESC");
    }
    public boolean onItemLongClick(AdapterView<?> parent, View view, int position, long id) {
        if (view instanceof NotesListItem) {
            mFocusNoteDataItem = ((NotesListItem) view).getItemData();
            if (mFocusNoteDataItem.getType() == Notes.TYPE_NOTE && !mNotesListAdapter.isInChoiceMode()) {
                if (mNotesListView.startActionMode(mModeCallBack) != null) {
                    mModeCallBack.onItemCheckedStateChanged(null, position, id, true);
                    mNotesListView.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
                } else {
                    Log.e(TAG, "startActionMode fails");
                }
            } else if (mFocusNoteDataItem.getType() == Notes.TYPE_FOLDER) {
                mNotesListView.setOnCreateContextMenuListener(mFolderOnCreateContextMenuListener);
            }
        }
        return false;
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/NotesListAdapter.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/NotesListAdapter.java
@ -0,0 +1,184 @@
 /*
 * 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.ui;
 import android.content.Context;
 import android.database.Cursor;
 import android.util.Log;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.CursorAdapter;
 import net.micode.notes.data.Notes;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 public class NotesListAdapter extends CursorAdapter {
    private static final String TAG = "NotesListAdapter";
    private Context mContext;
    private HashMap<Integer, Boolean> mSelectedIndex;
    private int mNotesCount;
    private boolean mChoiceMode;
    public static class AppWidgetAttribute {
        public int widgetId;
        public int widgetType;
    };
    public NotesListAdapter(Context context) {
        super(context, null);
        mSelectedIndex = new HashMap<Integer, Boolean>();
        mContext = context;
        mNotesCount = 0;
    }
    @Override
    public View newView(Context context, Cursor cursor, ViewGroup parent) {
        return new NotesListItem(context);
    }
    @Override
    public void bindView(View view, Context context, Cursor cursor) {
        if (view instanceof NotesListItem) {
            NoteItemData itemData = new NoteItemData(context, cursor);
            ((NotesListItem) view).bind(context, itemData, mChoiceMode,
                    isSelectedItem(cursor.getPosition()));
        }
    }
    public void setCheckedItem(final int position, final boolean checked) {
        mSelectedIndex.put(position, checked);
        notifyDataSetChanged();
    }
    public boolean isInChoiceMode() {
        return mChoiceMode;
    }
    public void setChoiceMode(boolean mode) {
        mSelectedIndex.clear();
        mChoiceMode = mode;
    }
    public void selectAll(boolean checked) {
        Cursor cursor = getCursor();
        for (int i = 0; i < getCount(); i++) {
            if (cursor.moveToPosition(i)) {
                if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) {
                    setCheckedItem(i, checked);
                }
            }
        }
    }
    public HashSet<Long> getSelectedItemIds() {
        HashSet<Long> itemSet = new HashSet<Long>();
        for (Integer position : mSelectedIndex.keySet()) {
            if (mSelectedIndex.get(position) == true) {
                Long id = getItemId(position);
                if (id == Notes.ID_ROOT_FOLDER) {
                    Log.d(TAG, "Wrong item id, should not happen");
                } else {
                    itemSet.add(id);
                }
            }
        }
        return itemSet;
    }
    public HashSet<AppWidgetAttribute> getSelectedWidget() {
        HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>();
        for (Integer position : mSelectedIndex.keySet()) {
            if (mSelectedIndex.get(position) == true) {
                Cursor c = (Cursor) getItem(position);
                if (c != null) {
                    AppWidgetAttribute widget = new AppWidgetAttribute();
                    NoteItemData item = new NoteItemData(mContext, c);
                    widget.widgetId = item.getWidgetId();
                    widget.widgetType = item.getWidgetType();
                    itemSet.add(widget);
                    /**
                     * Don't close cursor here, only the adapter could close it
                     */
                } else {
                    Log.e(TAG, "Invalid cursor");
                    return null;
                }
            }
        }
        return itemSet;
    }
    public int getSelectedCount() {
        Collection<Boolean> values = mSelectedIndex.values();
        if (null == values) {
            return 0;
        }
        Iterator<Boolean> iter = values.iterator();
        int count = 0;
        while (iter.hasNext()) {
            if (true == iter.next()) {
                count++;
            }
        }
        return count;
    }
    public boolean isAllSelected() {
        int checkedCount = getSelectedCount();
        return (checkedCount != 0 && checkedCount == mNotesCount);
    }
    public boolean isSelectedItem(final int position) {
        if (null == mSelectedIndex.get(position)) {
            return false;
        }
        return mSelectedIndex.get(position);
    }
    @Override
    protected void onContentChanged() {
        super.onContentChanged();
        calcNotesCount();
    }
    @Override
    public void changeCursor(Cursor cursor) {
        super.changeCursor(cursor);
        calcNotesCount();
    }
    private void calcNotesCount() {
        mNotesCount = 0;
        for (int i = 0; i < getCount(); i++) {
            Cursor c = (Cursor) getItem(i);
            if (c != null) {
                if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) {
                    mNotesCount++;
                }
            } else {
                Log.e(TAG, "Invalid cursor");
                return;
            }
        }
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/NotesListItem.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/NotesListItem.java
@ -0,0 +1,122 @@
 /*
 * 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.ui;
 import android.content.Context;
 import android.text.format.DateUtils;
 import android.view.View;
 import android.widget.CheckBox;
 import android.widget.ImageView;
 import android.widget.LinearLayout;
 import android.widget.TextView;
 import net.micode.notes.R;
 import net.micode.notes.data.Notes;
 import net.micode.notes.tool.DataUtils;
 import net.micode.notes.tool.ResourceParser.NoteItemBgResources;
 public class NotesListItem extends LinearLayout {
    private ImageView mAlert;
    private TextView mTitle;
    private TextView mTime;
    private TextView mCallName;
    private NoteItemData mItemData;
    private CheckBox mCheckBox;
    public NotesListItem(Context context) {
        super(context);
        inflate(context, R.layout.note_item, this);
        mAlert = (ImageView) findViewById(R.id.iv_alert_icon);
        mTitle = (TextView) findViewById(R.id.tv_title);
        mTime = (TextView) findViewById(R.id.tv_time);
        mCallName = (TextView) findViewById(R.id.tv_name);
        mCheckBox = (CheckBox) findViewById(android.R.id.checkbox);
    }
    public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
        if (choiceMode && data.getType() == Notes.TYPE_NOTE) {
            mCheckBox.setVisibility(View.VISIBLE);
            mCheckBox.setChecked(checked);
        } else {
            mCheckBox.setVisibility(View.GONE);
        }
        mItemData = data;
        if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
            mCallName.setVisibility(View.GONE);
            mAlert.setVisibility(View.VISIBLE);
            mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
            mTitle.setText(context.getString(R.string.call_record_folder_name)
                    + context.getString(R.string.format_folder_files_count, data.getNotesCount()));
            mAlert.setImageResource(R.drawable.call_record);
        } else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
            mCallName.setVisibility(View.VISIBLE);
            mCallName.setText(data.getCallName());
            mTitle.setTextAppearance(context,R.style.TextAppearanceSecondaryItem);
            mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
            if (data.hasAlert()) {
                mAlert.setImageResource(R.drawable.clock);
                mAlert.setVisibility(View.VISIBLE);
            } else {
                mAlert.setVisibility(View.GONE);
            }
        } else {
            mCallName.setVisibility(View.GONE);
            mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
            if (data.getType() == Notes.TYPE_FOLDER) {
                mTitle.setText(data.getSnippet()
                        + context.getString(R.string.format_folder_files_count,
                                data.getNotesCount()));
                mAlert.setVisibility(View.GONE);
            } else {
                mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
                if (data.hasAlert()) {
                    mAlert.setImageResource(R.drawable.clock);
                    mAlert.setVisibility(View.VISIBLE);
                } else {
                    mAlert.setVisibility(View.GONE);
                }
            }
        }
        mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));
        setBackground(data);
    }
    private void setBackground(NoteItemData data) {
        int id = data.getBgColorId();
        if (data.getType() == Notes.TYPE_NOTE) {
            if (data.isSingle() || data.isOneFollowingFolder()) {
                setBackgroundResource(NoteItemBgResources.getNoteBgSingleRes(id));
            } else if (data.isLast()) {
                setBackgroundResource(NoteItemBgResources.getNoteBgLastRes(id));
            } else if (data.isFirst() || data.isMultiFollowingFolder()) {
                setBackgroundResource(NoteItemBgResources.getNoteBgFirstRes(id));
            } else {
                setBackgroundResource(NoteItemBgResources.getNoteBgNormalRes(id));
            }
        } else {
            setBackgroundResource(NoteItemBgResources.getFolderBgRes());
        }
    }
    public NoteItemData getItemData() {
        return mItemData;
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/NotesPreferenceActivity.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/ui/NotesPreferenceActivity.java
@ -14,162 +14,88 @@
 * limitations under the License.
 */
 // NotesPreferenceActivity.java - 便签设置Activity
 // 主要功能：管理应用的偏好设置，特别是Google Tasks同步账户管理
 package net.micode.notes.ui;
-// ======================= 导入区域 =======================
+import android.accounts.Account;
-// Android账户管理
+import android.accounts.AccountManager;
-import android.accounts.Account;         // 账户对象
+import android.app.ActionBar;
-import android.accounts.AccountManager;  // 账户管理器
+import android.app.AlertDialog;
-// Android界面
+import android.content.BroadcastReceiver;
-import android.app.ActionBar;            // 操作栏
+import android.content.ContentValues;
-import android.app.AlertDialog;          // 警告对话框
+import android.content.Context;
-// Android广播
+import android.content.DialogInterface;
-import android.content.BroadcastReceiver;  // 广播接收器
+import android.content.Intent;
-// Android数据
+import android.content.IntentFilter;
-import android.content.ContentValues;    // 内容值
+import android.content.SharedPreferences;
-// Android基础
+import android.os.Bundle;
-import android.content.Context;          // 上下文
+import android.preference.Preference;
-import android.content.DialogInterface;  // 对话框接口
+import android.preference.Preference.OnPreferenceClickListener;
-import android.content.Intent;           // 意图
+import android.preference.PreferenceActivity;
-import android.content.IntentFilter;     // 意图过滤器
+import android.preference.PreferenceCategory;
-import android.content.SharedPreferences;  // 偏好设置
+import android.text.TextUtils;
-import android.os.Bundle;                // 状态保存
+import android.text.format.DateFormat;
-// Android偏好设置
+import android.view.LayoutInflater;
-import android.preference.Preference;    // 偏好设置项
+import android.view.Menu;
-import android.preference.Preference.OnPreferenceClickListener;  // 偏好设置点击监听
+import android.view.MenuItem;
-import android.preference.PreferenceActivity;  // 偏好设置Activity基类
+import android.view.View;
-import android.preference.PreferenceCategory;  // 偏好设置分类
+import android.widget.Button;
-import android.preference.PreferenceManager;  // 偏好设置管理器
+import android.widget.TextView;
-// Android工具
+import android.widget.Toast;
-import android.text.TextUtils;           // 文本工具
+
-import android.text.format.DateFormat;   // 日期格式化
+import net.micode.notes.R;
-// Android视图
+import net.micode.notes.data.Notes;
-import android.view.LayoutInflater;      // 布局加载器
+import net.micode.notes.data.Notes.NoteColumns;
-import android.view.Menu;                // 菜单
+import net.micode.notes.gtask.remote.GTaskSyncService;
 import android.view.MenuItem;            // 菜单项
 import android.view.View;                // 视图基类
 import android.widget.ListView;          // 列表视图
 // Android控件
 import android.widget.Button;            // 按钮
 import android.widget.TextView;          // 文本视图
 import android.widget.Toast;             // 提示信息
 // 应用内部资源
 import net.micode.notes.R;               // 资源文件R类
 // 应用数据模型
 import net.micode.notes.data.Notes;      // Notes主类
 import net.micode.notes.data.Notes.NoteColumns;  // 便签表列定义
 // 应用同步服务
 import net.micode.notes.gtask.remote.GTaskSyncService;  // Google任务同步服务
 // 应用工具
 import net.micode.notes.tool.SearchHistoryManager; // 搜索历史管理器
 // ======================= 便签设置Activity =======================
 /**
 * NotesPreferenceActivity - 便签设置Activity
 * 继承自PreferenceActivity，管理应用的所有偏好设置
 * 核心功能：Google Tasks同步账户管理、同步控制、设置管理
 */
 public class NotesPreferenceActivity extends PreferenceActivity {
    // ======================= 偏好设置常量 =======================
-    /** 偏好设置文件名 */
+public class NotesPreferenceActivity extends PreferenceActivity {
    public static final String PREFERENCE_NAME = "notes_preferences";
    /** 同步账户名称偏好键 - 存储当前设置的同步账户名 */
    public static final String PREFERENCE_SYNC_ACCOUNT_NAME = "pref_key_account_name";
    /** 最后同步时间偏好键 - 存储上次成功同步的时间戳 */
    public static final String PREFERENCE_LAST_SYNC_TIME = "pref_last_sync_time";
    /** 背景颜色随机显示偏好键 - 控制是否随机显示背景颜色 */
    public static final String PREFERENCE_SET_BG_COLOR_KEY = "pref_key_bg_random_appear";
    /** 同步账户偏好键 - 用于XML中定义账户设置分类 */
    private static final String PREFERENCE_SYNC_ACCOUNT_KEY = "pref_sync_account_key";
    /** 权限过滤器键 - 用于添加账户时过滤账户类型 */
    private static final String AUTHORITIES_FILTER_KEY = "authorities";
    // ======================= 成员变量 =======================
    /** 账户设置分类 - 显示账户相关设置 */
    private PreferenceCategory mAccountCategory;
    /** Google Tasks同步广播接收器 - 监听同步状态变化 */
    private GTaskReceiver mReceiver;
    /** 原始账户列表 - 用于检测新添加的账户 */
    private Account[] mOriAccounts;
    /** 是否添加了新账户标志 - 标记用户是否添加了新账户 */
    private boolean mHasAddedAccount;
    // ======================= 生命周期方法 =======================
    /**
     * onCreate - Activity创建
     * 初始化设置界面
     * @param icicle 保存的状态
     */
    @Override
    protected void onCreate(Bundle icicle) {
        super.onCreate(icicle);
        // 从XML加载偏好设置
        addPreferencesFromResource(R.xml.preferences);
-        // 获取账户设置分类
+        /* using the app icon for navigation */
-        mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);
+        getActionBar().setDisplayHomeAsUpEnabled(true);
-        // 设置清除搜索历史按钮的点击事件
+        addPreferencesFromResource(R.xml.preferences);
-        Preference clearSearchHistoryPref = findPreference("pref_key_clear_search_history");
+        mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);
        if (clearSearchHistoryPref != null) {
            clearSearchHistoryPref.setOnPreferenceClickListener(new OnPreferenceClickListener() {
                public boolean onPreferenceClick(Preference preference) {
                    // 清除搜索历史
                    SearchHistoryManager.getInstance(NotesPreferenceActivity.this).clearSearchHistory();
                    Toast.makeText(NotesPreferenceActivity.this,
                            "Search history cleared", Toast.LENGTH_SHORT).show();
                    return true;
                }
            });
        }
        // 创建并注册同步广播接收器
        mReceiver = new GTaskReceiver();
        IntentFilter filter = new IntentFilter();
        filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME);
        registerReceiver(mReceiver, filter);
-        mOriAccounts = null;  // 初始化原始账户列表
+        mOriAccounts = null;
        // 添加设置界面头部
        View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null);
-        ListView listView = getListView();
+        getListView().addHeaderView(header, null, true);
        if (listView != null) {
            listView.addHeaderView(header, null, true);
        }
        /* 使用应用图标作为导航按钮 */
        ActionBar actionBar = getActionBar();
        if (actionBar != null) {
            actionBar.setDisplayHomeAsUpEnabled(true);
        }
    }
    /**
     * onResume - Activity恢复可见
     * 检测新添加的账户并自动设置
     */
    @Override
    protected void onResume() {
        super.onResume();
-        // 如果用户添加了新账户，需要自动设置为同步账户
+        // need to set sync account automatically if user has added a new
        // account
        if (mHasAddedAccount) {
            Account[] accounts = getGoogleAccounts();
            // 比较新旧账户数量，检测新账户
            if (mOriAccounts != null && accounts.length > mOriAccounts.length) {
                for (Account accountNew : accounts) {
                    boolean found = false;
@ -180,7 +106,6 @@ public class NotesPreferenceActivity extends PreferenceActivity {
                        }
                    }
                    if (!found) {
                        // 找到新账户，设置为同步账户
                        setSyncAccount(accountNew.name);
                        break;
                    }
@ -188,13 +113,9 @@ public class NotesPreferenceActivity extends PreferenceActivity {
            }
        }
-        refreshUI();  // 刷新界面
+        refreshUI();
    }
    /**
     * onDestroy - Activity销毁
     * 注销广播接收器
     */
    @Override
    protected void onDestroy() {
        if (mReceiver != null) {
@ -203,16 +124,9 @@ public class NotesPreferenceActivity extends PreferenceActivity {
        super.onDestroy();
    }
    // ======================= 账户偏好设置加载 =======================
    /**
     * 加载账户偏好设置
     * 动态创建账户设置项
     */
    private void loadAccountPreference() {
-        mAccountCategory.removeAll();  // 清空现有设置项
+        mAccountCategory.removeAll();
        // 创建账户设置项
        Preference accountPref = new Preference(this);
        final String defaultAccount = getSyncAccountName(this);
        accountPref.setTitle(getString(R.string.preferences_account_title));
@ -221,16 +135,16 @@ public class NotesPreferenceActivity extends PreferenceActivity {
            public boolean onPreferenceClick(Preference preference) {
                if (!GTaskSyncService.isSyncing()) {
                    if (TextUtils.isEmpty(defaultAccount)) {
-                        // 首次设置账户：显示选择账户对话框
+                        // the first time to set account
                        showSelectAccountAlertDialog();
                    } else {
-                        // 已设置账户：显示更改账户确认对话框
+                        // if the account has already been set, we need to promp
                        // user about the risk
                        showChangeAccountConfirmAlertDialog();
                    }
                } else {
                    // 同步进行中，不能更改账户
                    Toast.makeText(NotesPreferenceActivity.this,
-                                    R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
+                            R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
                            .show();
                }
                return true;
@ -240,19 +154,12 @@ public class NotesPreferenceActivity extends PreferenceActivity {
        mAccountCategory.addPreference(accountPref);
    }
    // ======================= 同步按钮加载 =======================
    /**
     * 加载同步按钮
     * 根据同步状态设置按钮文本和点击事件
     */
    private void loadSyncButton() {
        Button syncButton = (Button) findViewById(R.id.preference_sync_button);
        TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
-        // 设置按钮状态
+        // set button state
        if (GTaskSyncService.isSyncing()) {
            // 同步中：显示取消按钮
            syncButton.setText(getString(R.string.preferences_button_sync_cancel));
            syncButton.setOnClickListener(new View.OnClickListener() {
                public void onClick(View v) {
@ -260,7 +167,6 @@ public class NotesPreferenceActivity extends PreferenceActivity {
                }
            });
        } else {
            // 未同步：显示立即同步按钮
            syncButton.setText(getString(R.string.preferences_button_sync_immediately));
            syncButton.setOnClickListener(new View.OnClickListener() {
                public void onClick(View v) {
@ -268,16 +174,13 @@ public class NotesPreferenceActivity extends PreferenceActivity {
                }
            });
        }
        // 有账户时启用按钮，无账户时禁用
        syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this)));
-        // 设置最后同步时间
+        // set last sync time
        if (GTaskSyncService.isSyncing()) {
            // 同步中：显示同步进度
            lastSyncTimeView.setText(GTaskSyncService.getProgressString());
            lastSyncTimeView.setVisibility(View.VISIBLE);
        } else {
            // 未同步：显示最后同步时间
            long lastSyncTime = getLastSyncTime(this);
            if (lastSyncTime != 0) {
                lastSyncTimeView.setText(getString(R.string.preferences_last_sync_time,
@ -285,33 +188,19 @@ public class NotesPreferenceActivity extends PreferenceActivity {
                                lastSyncTime)));
                lastSyncTimeView.setVisibility(View.VISIBLE);
            } else {
                // 从未同步：隐藏时间显示
                lastSyncTimeView.setVisibility(View.GONE);
            }
        }
    }
    // ======================= 界面刷新 =======================
    /**
     * 刷新界面
     * 重新加载账户设置和同步按钮
     */
    private void refreshUI() {
        loadAccountPreference();
        loadSyncButton();
    }
    // ======================= 选择账户对话框 =======================
    /**
     * 显示选择账户对话框
     * 首次设置账户时调用
     */
    private void showSelectAccountAlertDialog() {
        AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
        // 自定义标题视图
        View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
        TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
        titleTextView.setText(getString(R.string.preferences_dialog_select_account_title));
@ -319,57 +208,45 @@ public class NotesPreferenceActivity extends PreferenceActivity {
        subtitleTextView.setText(getString(R.string.preferences_dialog_select_account_tips));
        dialogBuilder.setCustomTitle(titleView);
-        dialogBuilder.setPositiveButton(null, null);  // 不显示确定按钮
+        dialogBuilder.setPositiveButton(null, null);
        // 获取Google账户列表
        Account[] accounts = getGoogleAccounts();
        String defAccount = getSyncAccountName(this);
        // 保存原始账户列表，用于检测新账户
        mOriAccounts = accounts;
        mHasAddedAccount = false;
        if (accounts.length > 0) {
            // 创建账户列表项
            CharSequence[] items = new CharSequence[accounts.length];
-            final CharSequence[] itemMapping = items;  // 用于内部类访问
+            final CharSequence[] itemMapping = items;
-            int checkedItem = -1;  // 默认未选中
+            int checkedItem = -1;
            // 填充账户列表
            int index = 0;
            for (Account account : accounts) {
                if (TextUtils.equals(account.name, defAccount)) {
-                    checkedItem = index;  // 选中已设置的账户
+                    checkedItem = index;
                }
                items[index++] = account.name;
            }
            // 设置单选列表
            dialogBuilder.setSingleChoiceItems(items, checkedItem,
                    new DialogInterface.OnClickListener() {
                        public void onClick(DialogInterface dialog, int which) {
                            // 选择账户
                            setSyncAccount(itemMapping[which].toString());
                            dialog.dismiss();
-                            refreshUI();  // 刷新界面
+                            refreshUI();
                        }
                    });
        }
        // 添加"添加账户"视图
        View addAccountView = LayoutInflater.from(this).inflate(R.layout.add_account_text, null);
        dialogBuilder.setView(addAccountView);
        // 显示对话框
        final AlertDialog dialog = dialogBuilder.show();
        addAccountView.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {
-                mHasAddedAccount = true;  // 标记为添加账户
+                mHasAddedAccount = true;
                // 启动系统添加账户界面
                Intent intent = new Intent("android.settings.ADD_ACCOUNT_SETTINGS");
                // 只显示Gmail账户类型
                intent.putExtra(AUTHORITIES_FILTER_KEY, new String[] {
-                        "gmail-ls"
+                    "gmail-ls"
                });
                startActivityForResult(intent, -1);
                dialog.dismiss();
@ -377,69 +254,42 @@ public class NotesPreferenceActivity extends PreferenceActivity {
        });
    }
    // ======================= 更改账户确认对话框 =======================
    /**
     * 显示更改账户确认对话框
     * 已设置账户时点击账户项调用
     */
    private void showChangeAccountConfirmAlertDialog() {
        AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
        // 自定义标题视图
        View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
        TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
        // 标题包含当前账户名
        titleTextView.setText(getString(R.string.preferences_dialog_change_account_title,
                getSyncAccountName(this)));
        TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
        subtitleTextView.setText(getString(R.string.preferences_dialog_change_account_warn_msg));
        dialogBuilder.setCustomTitle(titleView);
        // 设置菜单项
        CharSequence[] menuItemArray = new CharSequence[] {
-                getString(R.string.preferences_menu_change_account),  // 更改账户
+                getString(R.string.preferences_menu_change_account),
-                getString(R.string.preferences_menu_remove_account),  // 移除账户
+                getString(R.string.preferences_menu_remove_account),
-                getString(R.string.preferences_menu_cancel)           // 取消
+                getString(R.string.preferences_menu_cancel)
        };
        dialogBuilder.setItems(menuItemArray, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                if (which == 0) {
                    // 更改账户：显示选择账户对话框
                    showSelectAccountAlertDialog();
                } else if (which == 1) {
                    // 移除账户：清除账户设置
                    removeSyncAccount();
                    refreshUI();
                }
                // 取消：不执行任何操作
            }
        });
        dialogBuilder.show();
    }
    // ======================= 获取Google账户 =======================
    /**
     * 获取设备上的Google账户
     * @return Google账户数组
     */
    private Account[] getGoogleAccounts() {
        AccountManager accountManager = AccountManager.get(this);
        // 获取类型为"com.google"的账户（Google账户）
        return accountManager.getAccountsByType("com.google");
    }
    // ======================= 设置同步账户 =======================
    /**
     * 设置同步账户
     * 保存账户名到偏好设置，并清理同步相关数据
     * @param account 账户名
     */
    private void setSyncAccount(String account) {
        if (!getSyncAccountName(this).equals(account)) {
            // 保存到偏好设置
            SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
            SharedPreferences.Editor editor = settings.edit();
            if (account != null) {
@ -449,76 +299,53 @@ public class NotesPreferenceActivity extends PreferenceActivity {
            }
            editor.commit();
-            // 清理最后同步时间
+            // clean up last sync time
            setLastSyncTime(this, 0);
-            // 清理本地同步相关数据（在后台线程执行）
+            // clean up local gtask related info
            new Thread(new Runnable() {
                public void run() {
                    ContentValues values = new ContentValues();
-                    values.put(NoteColumns.GTASK_ID, "");  // 清空GTASK ID
+                    values.put(NoteColumns.GTASK_ID, "");
-                    values.put(NoteColumns.SYNC_ID, 0);    // 清空同步ID
+                    values.put(NoteColumns.SYNC_ID, 0);
                    getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
                }
            }).start();
            // 显示成功提示
            Toast.makeText(NotesPreferenceActivity.this,
                    getString(R.string.preferences_toast_success_set_accout, account),
                    Toast.LENGTH_SHORT).show();
        }
    }
    // ======================= 移除同步账户 =======================
    /**
     * 移除同步账户
     * 清除账户设置和同步数据
     */
    private void removeSyncAccount() {
        SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
        SharedPreferences.Editor editor = settings.edit();
        // 移除账户名
        if (settings.contains(PREFERENCE_SYNC_ACCOUNT_NAME)) {
            editor.remove(PREFERENCE_SYNC_ACCOUNT_NAME);
        }
        // 移除最后同步时间
        if (settings.contains(PREFERENCE_LAST_SYNC_TIME)) {
            editor.remove(PREFERENCE_LAST_SYNC_TIME);
        }
        editor.commit();
-        // 清理本地同步相关数据（在后台线程执行）
+        // clean up local gtask related info
        new Thread(new Runnable() {
            public void run() {
                ContentValues values = new ContentValues();
-                values.put(NoteColumns.GTASK_ID, "");  // 清空GTASK ID
+                values.put(NoteColumns.GTASK_ID, "");
-                values.put(NoteColumns.SYNC_ID, 0);    // 清空同步ID
+                values.put(NoteColumns.SYNC_ID, 0);
                getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
            }
        }).start();
    }
    // ======================= 静态工具方法 =======================
    /**
     * 获取同步账户名
     * 静态方法，供其他类调用
     * @param context 上下文
     * @return 同步账户名，无账户时返回空字符串
     */
    public static String getSyncAccountName(Context context) {
        SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
                Context.MODE_PRIVATE);
        return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
    }
    /**
     * 设置最后同步时间
     * 静态方法，供其他类调用
     * @param context 上下文
     * @param time 最后同步时间戳
     */
    public static void setLastSyncTime(Context context, long time) {
        SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
                Context.MODE_PRIVATE);
@ -527,52 +354,29 @@ public class NotesPreferenceActivity extends PreferenceActivity {
        editor.commit();
    }
    /**
     * 获取最后同步时间
     * 静态方法，供其他类调用
     * @param context 上下文
     * @return 最后同步时间戳，从未同步返回0
     */
    public static long getLastSyncTime(Context context) {
        SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
                Context.MODE_PRIVATE);
        return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);
    }
    // ======================= 同步广播接收器 =======================
    /**
     * GTaskReceiver - Google Tasks同步广播接收器
     * 监听同步状态变化
     */
    private class GTaskReceiver extends BroadcastReceiver {
-        /**
+
         * 接收广播
         * 处理同步状态变化
         */
        @Override
        public void onReceive(Context context, Intent intent) {
-            refreshUI();  // 刷新界面
+            refreshUI();
            // 如果正在同步，更新进度信息
            if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {
                TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
                syncStatus.setText(intent
                        .getStringExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_PROGRESS_MSG));
            }
        }
    }
    // ======================= 菜单项处理 =======================
    /**
     * 选项菜单项选择处理
     * 处理返回按钮点击
     */
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case android.R.id.home:
                // 返回按钮：回到主界面
                Intent intent = new Intent(this, NotesListActivity.class);
                intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
                startActivity(intent);
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/widget/NoteWidgetProvider.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/widget/NoteWidgetProvider.java
@ -0,0 +1,132 @@
 /*
 * 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.widget;
 import android.app.PendingIntent;
 import android.appwidget.AppWidgetManager;
 import android.appwidget.AppWidgetProvider;
 import android.content.ContentValues;
 import android.content.Context;
 import android.content.Intent;
 import android.database.Cursor;
 import android.util.Log;
 import android.widget.RemoteViews;
 import net.micode.notes.R;
 import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.tool.ResourceParser;
 import net.micode.notes.ui.NoteEditActivity;
 import net.micode.notes.ui.NotesListActivity;
 public abstract class NoteWidgetProvider extends AppWidgetProvider {
    public static final String [] PROJECTION = new String [] {
        NoteColumns.ID,
        NoteColumns.BG_COLOR_ID,
        NoteColumns.SNIPPET
    };
    public static final int COLUMN_ID           = 0;
    public static final int COLUMN_BG_COLOR_ID  = 1;
    public static final int COLUMN_SNIPPET      = 2;
    private static final String TAG = "NoteWidgetProvider";
    @Override
    public void onDeleted(Context context, int[] appWidgetIds) {
        ContentValues values = new ContentValues();
        values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
        for (int i = 0; i < appWidgetIds.length; i++) {
            context.getContentResolver().update(Notes.CONTENT_NOTE_URI,
                    values,
                    NoteColumns.WIDGET_ID + "=?",
                    new String[] { String.valueOf(appWidgetIds[i])});
        }
    }
    private Cursor getNoteWidgetInfo(Context context, int widgetId) {
        return context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
                PROJECTION,
                NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?",
                new String[] { String.valueOf(widgetId), String.valueOf(Notes.ID_TRASH_FOLER) },
                null);
    }
    protected void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
        update(context, appWidgetManager, appWidgetIds, false);
    }
    private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds,
            boolean privacyMode) {
        for (int i = 0; i < appWidgetIds.length; i++) {
            if (appWidgetIds[i] != AppWidgetManager.INVALID_APPWIDGET_ID) {
                int bgId = ResourceParser.getDefaultBgId(context);
                String snippet = "";
                Intent intent = new Intent(context, NoteEditActivity.class);
                intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
                intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]);
                intent.putExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, getWidgetType());
                Cursor c = getNoteWidgetInfo(context, appWidgetIds[i]);
                if (c != null && c.moveToFirst()) {
                    if (c.getCount() > 1) {
                        Log.e(TAG, "Multiple message with same widget id:" + appWidgetIds[i]);
                        c.close();
                        return;
                    }
                    snippet = c.getString(COLUMN_SNIPPET);
                    bgId = c.getInt(COLUMN_BG_COLOR_ID);
                    intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID));
                    intent.setAction(Intent.ACTION_VIEW);
                } else {
                    snippet = context.getResources().getString(R.string.widget_havenot_content);
                    intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
                }
                if (c != null) {
                    c.close();
                }
                RemoteViews rv = new RemoteViews(context.getPackageName(), getLayoutId());
                rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId));
                intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId);
                /**
                 * Generate the pending intent to start host for the widget
                 */
                PendingIntent pendingIntent = null;
                if (privacyMode) {
                    rv.setTextViewText(R.id.widget_text,
                            context.getString(R.string.widget_under_visit_mode));
                    pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], new Intent(
                            context, NotesListActivity.class), PendingIntent.FLAG_UPDATE_CURRENT);
                } else {
                    rv.setTextViewText(R.id.widget_text, snippet);
                    pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], intent,
                            PendingIntent.FLAG_UPDATE_CURRENT);
                }
                rv.setOnClickPendingIntent(R.id.widget_text, pendingIntent);
                appWidgetManager.updateAppWidget(appWidgetIds[i], rv);
            }
        }
    }
    protected abstract int getBgResourceId(int bgId);
    protected abstract int getLayoutId();
    protected abstract int getWidgetType();
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/widget/NoteWidgetProvider_2x.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/widget/NoteWidgetProvider_2x.java
@ -0,0 +1,47 @@
 /*
 * 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.widget;
 import android.appwidget.AppWidgetManager;
 import android.content.Context;
 import net.micode.notes.R;
 import net.micode.notes.data.Notes;
 import net.micode.notes.tool.ResourceParser;
 public class NoteWidgetProvider_2x extends NoteWidgetProvider {
    @Override
    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
        super.update(context, appWidgetManager, appWidgetIds);
    }
    @Override
    protected int getLayoutId() {
        return R.layout.widget_2x;
    }
    @Override
    protected int getBgResourceId(int bgId) {
        return ResourceParser.WidgetBgResources.getWidget2xBgResource(bgId);
    }
    @Override
    protected int getWidgetType() {
        return Notes.TYPE_WIDGET_2X;
    }
 }
--- a/src/Notes-master/app/src/main/java/src/net/micode/notes/widget/NoteWidgetProvider_4x.java
+++ b/src/Notes-master/app/src/main/java/src/net/micode/notes/widget/NoteWidgetProvider_4x.java
@ -0,0 +1,46 @@
 /*
 * 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.widget;
 import android.appwidget.AppWidgetManager;
 import android.content.Context;
 import net.micode.notes.R;
 import net.micode.notes.data.Notes;
 import net.micode.notes.tool.ResourceParser;
 public class NoteWidgetProvider_4x extends NoteWidgetProvider {
    @Override
    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
        super.update(context, appWidgetManager, appWidgetIds);
    }
    protected int getLayoutId() {
        return R.layout.widget_4x;
    }
    @Override
    protected int getBgResourceId(int bgId) {
        return ResourceParser.WidgetBgResources.getWidget4xBgResource(bgId);
    }
    @Override
    protected int getWidgetType() {
        return Notes.TYPE_WIDGET_4X;
    }
 }
--- a/src/Notes-master/app/src/main/res/color/primary_text_dark.xml
+++ b/src/Notes-master/app/src/main/res/color/primary_text_dark.xml
@ -0,0 +1,22 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!-- 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.
 -->
 <selector xmlns:android="http://schemas.android.com/apk/res/android">
  <item android:state_pressed="true" android:color="#88555555" />
  <item android:state_selected="true" android:color="#ff999999" />
  <item android:color="#ff000000" />
 </selector>
--- a/src/Notes-master/app/src/main/res/color/secondary_text_dark.xml
+++ b/src/Notes-master/app/src/main/res/color/secondary_text_dark.xml
@ -0,0 +1,20 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!-- 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.
 -->
 <selector xmlns:android="http://schemas.android.com/apk/res/android">
  <item android:color="#50000000" />
 </selector>
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
玛卡巴卡	3971242683	1	1 month ago
玛卡巴卡	9433a62168	1	2 months ago
		`@ -0,0 +1,2 @@`
							`#Thu Nov 13 20:58:02 CST 2025`
							`gradle.version=8.5`