报告

src/AlarmAlertActivity.java

@@ -0,0 +1,196 @@
+java
+/*
+ * 版权所有 (c) 2010-2011, MiCode 开源社区 (www.micode.net)
+ *
+ * 本文件根据 Apache License, Version 2.0 (以下简称“许可证”) 授权使用。
+ * 除非符合许可证的要求，否则您不得使用本文件。
+ * 您可以在以下网址获取许可证副本：
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 除非适用法律要求或以书面形式同意，根据许可证分发的软件
+ * 将在“按现状”的基础上分发，
+ * 不提供任何明示或暗示的保证或条件。
+ * 请参阅许可证以了解控制权限和
+ * 许可证下的限制。
+ */
+ 
+// 声明当前类所在的包名，这是组织代码和资源的一种方式。
+package net.micode.notes.ui;
+ 
+// 导入Activity类，它是Android应用中的一个组件，用于提供用户界面。
+import android.app.Activity;
+ 
+// 导入AlertDialog类，它是一个对话框，可以包含标题、消息、按钮等，用于向用户显示信息或接收用户输入。
+import android.app.AlertDialog;
+ 
+// 导入Context类，它提供了关于应用环境的全局信息，是许多Android API调用的必需参数。
+import android.content.Context;
+ 
+// 导入DialogInterface接口，它是AlertDialog和Dialog类的父接口，用于处理对话框事件（如按钮点击）。
+import android.content.DialogInterface;
+ 
+// 导入Intent类，它是Android中用于不同组件（如Activity、Service、BroadcastReceiver）之间通信的主要机制。
+import android.content.Intent;
+ 
+// 导入AudioManager类，它用于管理音频输出，如调整音量、设置铃声模式等。
+import android.media.AudioManager;
+ 
+// 导入MediaPlayer类，它用于播放音频和视频文件。
+import android.media.MediaPlayer;
+ 
+// 导入RingtoneManager类，它用于访问和播放设备上的铃声。
+import android.media.RingtoneManager;
+ 
+// 导入Uri类，它表示一个统一资源标识符（URI），用于标识一个资源的位置。
+import android.net.Uri;
+ 
+// 导入Bundle类，它用于传递数据，通常用于Activity之间的数据传递。
+import android.os.Bundle;
+ 
+// 导入PowerManager类，它用于控制设备的电源状态，如唤醒设备或保持屏幕常亮。
+import android.os.PowerManager;
+ 
+// 导入Settings类，它包含了访问系统级设置的API，如音量、屏幕亮度等。
+import android.provider.Settings;
+ 
+// 导入Window类，它表示一个窗口，通常用于设置Activity的窗口属性，如全屏模式、无标题栏等。
+import android.view.Window;
+ 
+// 导入WindowManager类，它用于管理窗口的布局和属性，如设置窗口的尺寸、位置、透明度等。
+import android.view.WindowManager;
+ 
+// 导入R类，它是一个自动生成的类，包含了应用中所有的资源ID，如布局、字符串、图片等。
+import net.micode.notes.R;
+ 
+// 导入Notes类，这可能是自定义的，用于封装与笔记相关的数据访问逻辑（如数据库操作）。
+import net.micode.notes.data.Notes;
+ 
+// 导入DataUtils类，这可能是自定义的工具类，用于执行一些与数据相关的实用功能。
+import net.micode.notes.tool.DataUtils;
+ 
+// 导入IOException类，它是Java中的一个异常类，表示输入输出操作失败或中断。
+import java.io.IOException;
+ 
+// 闹钟提醒活动类，用于显示提醒对话框并播放提醒声音
+public class AlarmAlertActivity extends Activity implements DialogInterface.OnClickListener, DialogInterface.OnDismissListener {
+    // 笔记ID
+    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中获取笔记ID和摘要
+        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 (Exception e) {
+            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;
+        }
+    }
+}
+//这段代码是一个Android应用程序的一部分，用于实现闹钟提醒功能。当触发提醒时，它会显示一个对话框，显示笔记的摘要，并播放提醒声音。用户可以选择点击确定按钮关闭对话框和声音，或者如果屏幕已点亮，还可以选择点击取消按钮进入笔记编辑界面。

src/AlarmInitReceiver.java

@@ -0,0 +1,110 @@
+/*
+ * 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.
+ */
+
+// 声明当前类所在的包名，这是Android项目结构的一部分，用于组织代码和资源。
+package net.micode.notes.ui;
+ 
+// 导入Android框架中的AlarmManager类，用于设置闹钟（提醒）在特定时间触发。
+import android.app.AlarmManager;
+ 
+// 导入PendingIntent类，它代表一个将要执行的动作的引用，通常与AlarmManager或NotificationManager一起使用。
+import android.app.PendingIntent;
+ 
+// 导入BroadcastReceiver类，它是一个可以接收并响应来自其他应用或系统的广播消息的组件。
+import android.content.BroadcastReceiver;
+ 
+// 导入ContentUris类，它提供了一些静态方法，用于操作URI，特别是与内容提供者交互时生成或解析特定记录的URI。
+import android.content.ContentUris;
+ 
+// 导入Context类，它提供了关于应用环境的全局信息，是许多Android API调用的必需参数。
+import android.content.Context;
+ 
+// 导入Intent类，它是Android中用于不同组件（如Activity、Service、BroadcastReceiver）之间通信的主要机制。
+import android.content.Intent;
+ 
+// 导入Cursor类，它用于遍历查询数据库返回的结果集。
+import android.database.Cursor;
+ 
+// 导入Notes类，这可能是自定义的，用于封装与笔记相关的数据访问逻辑（如数据库操作）。
+import net.micode.notes.data.Notes;
+ 
+// 导入NoteColumns类，这通常是Notes类的一个内部类，用于定义笔记数据表中的列名。
+import net.micode.notes.data.Notes.NoteColumns;
+
+
+/**
+ * AlarmInitReceiver 类：一个 BroadcastReceiver，用于初始化闹钟。
+ * 
+ * 当接收到广播时，此接收器会查询数据库中所有设置了提醒日期且提醒日期在当前时间之后的笔记。
+ * 对于每个符合条件的笔记，它会设置一个 AlarmManager 闹钟，该闹钟会在笔记的提醒日期触发 AlarmReceiver。
+ * 
+ * 具体步骤如下：
+ * 1. 获取当前时间。
+ * 2. 查询数据库中所有提醒日期在当前时间之后且类型为普通笔记的条目。
+ * 3. 遍历查询结果，为每个符合条件的笔记设置闹钟。
+ *    - 创建一个指向 AlarmReceiver 的 Intent，并设置其数据为笔记的 URI。
+ *    - 创建一个 PendingIntent，以便在闹钟触发时广播该 Intent。
+ *    - 使用 AlarmManager 设置一个闹钟，在笔记的提醒日期触发 PendingIntent。
+ */
+public class AlarmInitReceiver extends BroadcastReceiver {
+ 
+    // 定义查询投影，只选择 ID 和 提醒日期 字段
+    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);
+                    
+                    // 创建一个指向 AlarmReceiver 的 Intent，并设置其数据为笔记的 URI
+                    Intent sender = new Intent(context, AlarmReceiver.class);
+                    sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(COLUMN_ID)));
+                    
+                    // 创建一个 PendingIntent，以便在闹钟触发时广播该 Intent
+                    PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, 0);
+                    
+                    // 获取 AlarmManager 实例，并设置闹钟
+                    AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
+                    alarmManager.set(AlarmManager.RTC_WAKEUP, alertDate, pendingIntent);
+                } while (c.moveToNext());
+            }
+            // 关闭游标
+            c.close();
+        }
+    }
+}
+//AlarmInitReceiver 是一个 BroadcastReceiver，用于根据数据库中笔记的提醒日期设置闹钟。

src/AlarmReceiver.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.ui;
+ 
+// 导入BroadcastReceiver类，它是一个可以接收并响应来自其他应用或系统的广播消息的组件。
+// 在Android中，广播是一种在组件之间传递信息的机制。
+import android.content.BroadcastReceiver;
+ 
+// 导入Context类，它提供了关于应用环境的全局信息。
+// Context是一个抽象类，它的实现类（如Activity、Service等）允许访问特定资源和类，
+// 以及调用应用级别的操作，如启动活动、广播和接收意图等。
+import android.content.Context;
+ 
+// 导入Intent类，它是Android中用于不同组件（如Activity、Service、BroadcastReceiver）
+// 之间通信以及请求动作的主要机制。Intent可以携带数据，并指定要执行的动作。
+import android.content.Intent;
+
+// 定义一个名为AlarmReceiver的类，继承自BroadcastReceiver
+public class AlarmReceiver extends BroadcastReceiver {
+    // 重写onReceive方法，用于接收广播并处理
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        // 设置Intent的目标Activity为AlarmAlertActivity
+        intent.setClass(context, AlarmAlertActivity.class);
+        // 为Intent添加FLAG_ACTIVITY_NEW_TASK标志，表示在新的任务栈中启动Activity
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        // 使用context启动目标Activity
+        context.startActivity(intent);
+    }
+}
+ 
+// AlarmReceiver是一个BroadcastReceiver子类，用于接收广播并在接收到广播时启动AlarmAlertActivity。

src/DateTimePicker.java

@@ -0,0 +1,526 @@
+/*
+ * 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; // Android的上下文对象，用于访问应用程序的资源和类
+import android.text.format.DateFormat; // 用于格式化日期和时间
+import android.view.View; // 用于定义和操作视图的类
+import android.widget.FrameLayout; // 用于布局的类，可以包含其他视图
+import android.widget.NumberPicker; // 用于数字选择的控件
+
+// DateTimePicker类继承自FrameLayout，用于选择日期和时间
+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; // 24小时制下小时选择器的最小值
+    private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23; // 24小时制下小时选择器的最大值
+    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; // 分钟选择器的最大值
+    private static final int AMPM_SPINNER_MIN_VAL = 0; // AM/PM选择器的最小值
+    private static final int AMPM_SPINNER_MAX_VAL = 1; // AM/PM选择器的最大值
+
+    // 定义NumberPicker控件
+    private final NumberPicker mDateSpinner; // 日期选择器
+    private final NumberPicker mHourSpinner; // 小时选择器
+    private final NumberPicker mMinuteSpinner; // 分钟选择器
+    private final NumberPicker mAmPmSpinner; // AM/PM选择器
+    private Calendar mDate; // 用于存储日期和时间的Calendar对象
+
+    // 用于显示日期的字符串数组
+    private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];
+
+    // 一些状态标志
+    private boolean mIsAm; // 是否为上午
+    private boolean mIs24HourView; // 是否为24小时视图
+    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();
+        }
+    };
+
+    // 当小时改变时的监听器
+    private NumberPicker.OnValueChangeListener mOnHourChangedListener = new NumberPicker.OnValueChangeListener() {
+        @Override
+        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+            // 当小时改变时，更新Calendar对象和小时选择器
+            boolean isDateChanged = false;
+            Calendar cal = Calendar.getInstance();
+            // 处理12小时制的情况
+            if (!mIs24HourView) {
+                // 如果从PM切换到AM，日期减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;
+                } 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
+                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 {
+                // 处理24小时制的情况
+                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) {
+            // 当分钟改变时，更新Calendar对象和分钟选择器
+            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();
+        }
+    };
+
+    // 当AM/PM改变时的监听器
+    private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() {
+        @Override
+        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+            // 当AM/PM改变时，更新Calendar对象和AM/PM选择器
+            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);
+}
+
+// DateTimePicker类的构造函数，接收一个Context对象
+public DateTimePicker(Context context) {
+    this(context, System.currentTimeMillis()); // 调用另一个构造函数，传入当前时间
+}
+
+// DateTimePicker类的构造函数，接收一个Context对象和一个时间戳
+public DateTimePicker(Context context, long date) {
+    this(context, date, DateFormat.is24HourFormat(context)); // 调用另一个构造函数，传入是否为24小时制
+}
+
+// DateTimePicker类的构造函数，接收一个Context对象、一个时间戳和一个布尔值表示是否为24小时制
+public DateTimePicker(Context context, long date, boolean is24HourView) {
+    super(context); // 调用父类的构造函数
+    mDate = Calendar.getInstance(); // 获取当前日期和时间
+    mInitialising = true; // 设置初始化标志为true
+    mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY; // 判断当前时间是否为AM
+
+    // inflate布局，将XML布局文件转换成View对象
+    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);
+
+    // 初始化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);
+
+    // 更新控件到初始状态
+    updateDateControl();
+    updateHourControl();
+    updateAmPmControl();
+
+    // 设置是否为24小时制
+    set24HourView(is24HourView);
+
+    // 设置当前时间
+    setCurrentDate(date);
+
+    // 设置控件的启用状态
+    setEnabled(isEnabled());
+
+    // 设置内容描述
+    mInitialising = false; // 设置初始化标志为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); // 设置AM/PM选择器的启用状态
+    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 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); // 从mDate中获取年份
+}
+
+/**
+ * Set current year
+ *
+ * @param year The current year
+ */
+public void setCurrentYear(int year) {
+    // 设置当前年份
+    if (!mInitialising && year == getCurrentYear()) {
+        return; // 如果不是初始化状态且年份未改变，则返回
+    }
+    mDate.set(Calendar.YEAR, year); // 更新mDate中的年份
+    updateDateControl(); // 更新日期控件的显示
+    onDateTimeChanged(); // 通知日期时间已改变
+}
+
+/**
+ * Get current month in the year
+ *
+ * @return The current month in the year
+ */
+public int getCurrentMonth() {
+    // 获取当前月份
+    return mDate.get(Calendar.MONTH); // 从mDate中获取月份
+}
+
+/**
+ * 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); // 更新mDate中的月份
+    updateDateControl(); // 更新日期控件的显示
+    onDateTimeChanged(); // 通知日期时间已改变
+}
+
+/**
+ * Get current day of the month
+ *
+ * @return The day of the month
+ */
+public int getCurrentDay() {
+    // 获取当前日期
+    return mDate.get(Calendar.DAY_OF_MONTH); // 从mDate中获取日期
+}
+
+/**
+ * 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); // 更新mDate中的日期
+    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() {
+    // 获取当前小时（24小时制），范围为0到23
+    return mDate.get(Calendar.HOUR_OF_DAY); // 从mDate中获取小时
+}
+
+private int getCurrentHour() {
+    // 获取当前小时，根据是否为24小时制返回不同的值
+    if (mIs24HourView) {
+        return getCurrentHourOfDay(); // 如果是24小时制，直接返回当前小时
+    } else {
+        int hour = getCurrentHourOfDay(); // 获取当前小时
+        // 如果小时大于12，返回小时减去12（转换为12小时制）
+        if (hour > HOURS_IN_HALF_DAY) {
+            return hour - HOURS_IN_HALF_DAY;
+        } else {
+            // 如果小时为0，返回12；否则返回当前小时
+            return hour == 0 ? HOURS_IN_HALF_DAY : hour;
+        }
+    }
+}
+
+/**
+ * Set current hour in 24 hour mode, in the range (0~23)
+ *
+ * @param hourOfDay 当前小时（24小时制）
+ */
+public void setCurrentHour(int hourOfDay) {
+    // 设置当前小时
+    if (!mInitialising && hourOfDay == getCurrentHourOfDay()) {
+        return; // 如果不是初始化状态且小时未改变，则返回
+    }
+    mDate.set(Calendar.HOUR_OF_DAY, hourOfDay); // 更新mDate中的小时
+    if (!mIs24HourView) {
+        // 如果不是24小时制，更新AM/PM状态
+        if (hourOfDay >= HOURS_IN_HALF_DAY) {
+            mIsAm = false; // 设置为PM
+            if (hourOfDay > HOURS_IN_HALF_DAY) {
+                hourOfDay -= HOURS_IN_HALF_DAY; // 转换为12小时制
+            }
+        } else {
+            mIsAm = true; // 设置为AM
+            if (hourOfDay == 0) {
+                hourOfDay = HOURS_IN_HALF_DAY; // 如果小时为0，设置为12
+            }
+        }
+        updateAmPmControl(); // 更新AM/PM控件
+    }
+    mHourSpinner.setValue(hourOfDay); // 更新小时选择器的值
+    onDateTimeChanged(); // 通知日期时间已改变
+}
+
+/**
+ * Get currentMinute
+ *
+ * @return The Current Minute
+ */
+public int getCurrentMinute() {
+    // 获取当前分钟
+    return mDate.get(Calendar.MINUTE); // 从mDate中获取分钟
+}
+
+/**
+ * Set current minute
+ */
+public void setCurrentMinute(int minute) {
+    // 设置当前分钟
+    if (!mInitialising && minute == getCurrentMinute()) {
+        return; // 如果不是初始化状态且分钟未改变，则返回
+    }
+    mMinuteSpinner.setValue(minute); // 更新分钟选择器的值
+    mDate.set(Calendar.MINUTE, minute); // 更新mDate中的分钟
+    onDateTimeChanged(); // 通知日期时间已改变
+}
+
+/**
+ * @return true if this is in 24 hour view else false.
+ */
+public boolean is24HourView() {
+    // 返回当前是否为24小时制
+    return mIs24HourView; // 返回24小时制状态
+}
+
+/**
+ * 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) {
+    // 设置是否为24小时制或AM/PM模式
+    if (mIs24HourView == is24HourView) {
+        return; // 如果当前状态与传入状态相同，则返回
+    }
+    mIs24HourView = is24HourView; // 更新24小时制状态
+    mAmPmSpinner.setVisibility(is24HourView ? View.GONE : View.VISIBLE); // 根据模式设置AM/PM选择器的可见性
+    int hour = getCurrentHourOfDay(); // 获取当前小时
+    updateHourControl(); // 更新小时控件
+    setCurrentHour(hour); // 设置当前小时
+    updateAmPmControl(); // 更新AM/PM控件
+}
+
+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() {
+    // 更新AM/PM选择器的显示
+    if (mIs24HourView) {
+        mAmPmSpinner.setVisibility(View.GONE); // 隐藏AM/PM选择器
+    } else {
+        int index = mIsAm ? Calendar.AM : Calendar.PM; // 根据当前状态设置索引
+        mAmPmSpinner.setValue(index); // 设置AM/PM选择器的值
+        mAmPmSpinner.setVisibility(View.VISIBLE); // 显示AM/PM选择器
+    }
+}
+
+private void updateHourControl() {
+    // 更新小时选择器的范围
+    if (mIs24HourView) {
+        mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW); // 设置24小时制下的最小值
+        mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW); // 设置24小时制下的最大值
+    } else {
+        mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW); // 设置12小时制下的最小值
+        mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW); // 设置12小时制下的最大值
+    }
+}
+
+/**
+ * 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());
+    }
+}

src/DateTimePickerDialog.java

@@ -0,0 +1,98 @@
+/*
+ * 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; // 导入DateTimePicker类
+import net.micode.notes.ui.DateTimePicker.OnDateTimeChangedListener; // 导入日期时间变化监听器接口
+
+import android.app.AlertDialog; // 导入AlertDialog类
+import android.content.Context; // 导入上下文类
+import android.content.DialogInterface; // 导入对话框接口
+import android.content.DialogInterface.OnClickListener; // 导入对话框点击监听器接口
+import android.text.format.DateFormat; // 导入日期格式化类
+import android.text.format.DateUtils; // 导入日期工具类
+
+// 自定义的日期时间选择对话框类，继承自AlertDialog并实现OnClickListener接口
+public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
+
+    private Calendar mDate = Calendar.getInstance(); // 用于存储当前日期和时间
+    private boolean mIs24HourView; // 是否为24小时制
+    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对象
+                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为传入的时间戳
+        mDate.set(Calendar.SECOND, 0); // 将秒数设置为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())); // 设置24小时制
+        updateTitle(mDate.getTimeInMillis()); // 更新对话框标题
+    }
+
+    // 设置是否为24小时制
+    public void set24HourView(boolean is24HourView) {
+        mIs24HourView = is24HourView; // 更新24小时制状态
+    }
+
+    // 设置日期时间设置监听器
+    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_12HOUR; // 根据模式设置24小时或12小时格式
+        setTitle(DateUtils.formatDateTime(this.getContext(), date, flag)); // 格式化并设置对话框标题
+    }
+
+    // 处理按钮点击事件
+    public void onClick(DialogInterface arg0, int arg1) {
+        if (mOnDateTimeSetListener != null) {
+            // 如果监听器不为空，调用其方法
+            mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis());
+        }
+    }
+}

src/DropdownMenu.java

@@ -0,0 +1,67 @@
+/*
+ * 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; // 菜单实例
+
+    // 构造函数，接收上下文、按钮和菜单资源ID
+    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); // 从资源ID加载菜单项
+        // 设置按钮的点击事件，显示弹出菜单
+        mButton.setOnClickListener(new OnClickListener() {
+            public void onClick(View v) {
+                mPopupMenu.show(); // 显示弹出菜单
+            }
+        });
+    }
+
+    // 设置下拉菜单项点击监听器
+    public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {
+        if (mPopupMenu != null) {
+            mPopupMenu.setOnMenuItemClickListener(listener); // 设置菜单项点击监听器
+        }
+    }
+
+    // 根据菜单项ID查找菜单项
+    public MenuItem findItem(int id) {
+        return mMenu.findItem(id); // 返回对应ID的菜单项
+    }
+
+    // 设置按钮的标题
+    public void setTitle(CharSequence title) {
+        mButton.setText(title); // 更新按钮文本为指定标题
+    }
+}

src/FoldersListAdapter.java

@@ -0,0 +1,88 @@
+/*
+ * 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; // 导入Notes类，包含笔记数据模型
+import net.micode.notes.data.Notes.NoteColumns; // 导入笔记列定义
+
+// 自定义的文件夹列表适配器类，继承自CursorAdapter
+public class FoldersListAdapter extends CursorAdapter {
+    // 定义查询笔记数据库时需要的列
+    public static final String [] PROJECTION = {
+        NoteColumns.ID, // 笔记ID
+        NoteColumns.SNIPPET // 笔记摘要
+    };
+
+    // 定义列索引常量
+    public static final int ID_COLUMN   = 0; // ID列索引
+    public static final int NAME_COLUMN = 1; // 名称列索引
+
+    // 构造函数，接收上下文和游标
+    public FoldersListAdapter(Context context, Cursor c) {
+        super(context, c); // 调用父类构造函数
+    }
+
+    // 创建新的列表项视图
+    @Override
+    public View newView(Context context, Cursor cursor, ViewGroup parent) {
+        return new FolderListItem(context); // 返回一个新的FolderListItem视图
+    }
+
+    // 绑定数据到列表项视图
+    @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); // 返回文件夹名称
+    }
+
+    // 自定义的文件夹列表项视图类，继承自LinearLayout
+    private class FolderListItem extends LinearLayout {
+        private TextView mName; // 用于显示文件夹名称的文本视图
+
+        // 构造函数，接收上下文
+        public FolderListItem(Context context) {
+            super(context);
+            inflate(context, R.layout.folder_list_item, this); // 从XML布局文件中加载视图
+            mName = (TextView) findViewById(R.id.tv_folder_name); // 获取文件夹名称文本视图
+        }
+
+        // 绑定文件夹名称到视图
+        public void bind(String name) {
+            mName.setText(name); // 设置文本视图的文本
+        }
+    }
+}

src/MetaData.java

@@ -0,0 +1,188 @@
+/*
+ * 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.
+ */
+
+java
+	// 导入所需的包和类  
+
+	package net.micode.notes.gtask.data;  
+
+	  
+
+	import android.database.Cursor; // 用于数据库查询结果的游标  
+
+	import android.util.Log; // 用于记录日志  
+
+	  
+
+	import net.micode.notes.tool.GTaskStringUtils; // 自定义的工具类，可能包含一些字符串处理的静态方法  
+
+	  
+
+	import org.json.JSONException; // JSON处理时可能抛出的异常  
+
+	import org.json.JSONObject; // JSON对象类  
+
+	  
+
+	// MetaData类，继承自Task类  
+
+	public class MetaData extends Task {  
+
+	    // 定义日志标签，用于记录日志时区分来源  
+
+	    private final static String TAG = MetaData.class.getSimpleName();  
+
+	  
+
+	    // 定义一个私有成员变量，用于存储与元数据相关的GID  
+
+	    private String mRelatedGid = null;  
+
+	  
+
+	    // 设置元数据的方法，接收GID和包含元数据的JSONObject  
+
+	    public void setMeta(String gid, JSONObject metaInfo) {  
+
+	        try {  
+
+	            // 将GID添加到metaInfo中，作为元数据的一部分  
+
+	            metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);  
+
+	        } catch (JSONException e) {  
+
+	            // 如果添加GID时发生JSON异常，则记录错误日志  
+
+	            Log.e(TAG, "failed to put related gid");  
+
+	        }  
+
+	        // 将metaInfo转换为字符串，并设置为任务的笔记内容  
+
+	        setNotes(metaInfo.toString());  
+
+	        // 设置任务的名称为一个特定的字符串，表示这是一个元数据任务  
+
+	        setName(GTaskStringUtils.META_NOTE_NAME);  
+
+	    }  
+
+	  
+
+	    // 获取与元数据相关的GID的方法  
+
+	    public String getRelatedGid() {  
+
+	        return mRelatedGid;  
+
+	    }  
+
+	  
+
+	    // 重写isWorthSaving方法，判断该元数据是否值得保存  
+
+	    // 在这里，如果笔记内容不为空，则认为值得保存  
+
+	    @Override  
+
+	    public boolean isWorthSaving() {  
+
+	        return getNotes() != null;  
+
+	    }  
+
+	  
+
+	    // 重写setContentByRemoteJSON方法，用于从远程JSON对象设置内容  
+
+	    // 在这里，首先从远程JSON中恢复元数据，并尝试从中提取GID  
+
+	    @Override  
+
+	    public void setContentByRemoteJSON(JSONObject js) {  
+
+	        super.setContentByRemoteJSON(js); // 调用父类的方法处理其他内容  
+
+	        if (getNotes() != null) {  
+
+	            try {  
+
+	                // 将笔记内容（JSON字符串）转换为JSONObject  
+
+	                JSONObject metaInfo = new JSONObject(getNotes().trim());  
+
+	                // 从metaInfo中提取GID  
+
+	                mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);  
+
+	            } catch (JSONException e) {  
+
+	                // 如果提取GID时发生JSON异常，则记录警告日志，并将GID设置为null  
+
+	                Log.w(TAG, "failed to get related gid");  
+
+	                mRelatedGid = null;  
+
+	            }  
+
+	        }  
+
+	    }  
+
+	  
+
+	    // 重写setContentByLocalJSON方法，但在这里抛出异常，表示该方法不应被调用  
+
+	    // 因为元数据通常是从远程获取的，而不是从本地JSON设置的  
+
+	    @Override  
+
+	    public void setContentByLocalJSON(JSONObject js) {  
+
+	        throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");  
+
+	    }  
+
+	  
+
+	    // 重写getLocalJSONFromContent方法，但在这里抛出异常，表示该方法不应被调用  
+
+	    // 因为元数据通常不需要转换为本地JSON表示  
+
+	    @Override  
+
+	    public JSONObject getLocalJSONFromContent() {  
+
+	        throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");  
+
+	    }  
+
+	  
+
+	    // 重写getSyncAction方法，但在这里抛出异常，表示该方法不应被调用  
+
+	    // 因为元数据的同步逻辑可能与其他任务类型不同，或者根本不需要同步  
+
+	    @Override  
+
+	    public int getSyncAction(Cursor c) {  
+
+	        throw new IllegalAccessError("MetaData:getSyncAction should not be called");  
+
+	    }  
+
+	}

src/Node.java

@@ -0,0 +1,198 @@
+/*
+ * 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.
+ */
+
+java
+	// 导入所需的包  
+
+	package net.micode.notes.gtask.data;  
+
+	  
+
+	import android.database.Cursor; // 用于数据库查询结果的游标  
+
+	import org.json.JSONObject; // JSON对象类  
+
+	  
+
+	// 定义一个抽象类Node，它代表了一个节点（如任务、笔记等）的基本属性和行为  
+
+	public abstract class Node {  
+
+	    // 定义同步操作的常量，用于指示节点的同步状态或要执行的同步动作  
+
+	    public static final int SYNC_ACTION_NONE = 0; // 无操作  
+
+	    public static final int SYNC_ACTION_ADD_REMOTE = 1; // 在远程添加  
+
+	    public static final int SYNC_ACTION_ADD_LOCAL = 2; // 在本地添加  
+
+	    public static final int SYNC_ACTION_DEL_REMOTE = 3; // 在远程删除  
+
+	    public static final int SYNC_ACTION_DEL_LOCAL = 4; // 在本地删除  
+
+	    public static final int SYNC_ACTION_UPDATE_REMOTE = 5; // 更新远程节点  
+
+	    public static final int SYNC_ACTION_UPDATE_LOCAL = 6; // 更新本地节点  
+
+	    public static final int SYNC_ACTION_UPDATE_CONFLICT = 7; // 更新冲突  
+
+	    public static final int SYNC_ACTION_ERROR = 8; // 同步错误  
+
+	  
+
+	    // 定义节点的私有属性  
+
+	    private String mGid; // 节点的全局唯一标识符  
+
+	    private String mName; // 节点的名称  
+
+	    private long mLastModified; // 节点最后修改的时间戳  
+
+	    private boolean mDeleted; // 节点是否被删除的标志  
+
+	  
+
+	    // 构造方法，初始化节点的属性  
+
+	    public Node() {  
+
+	        mGid = null; // GID初始化为null，表示新创建的节点还没有GID  
+
+	        mName = ""; // 名称初始化为空字符串  
+
+	        mLastModified = 0; // 最后修改时间初始化为0，表示节点还没有被修改过  
+
+	        mDeleted = false; // 删除标志初始化为false，表示节点没有被删除  
+
+	    }  
+
+	  
+
+	    // 抽象方法，用于获取创建节点的动作JSON对象，具体实现由子类提供  
+
+	    public abstract JSONObject getCreateAction(int actionId);  
+
+	  
+
+	    // 抽象方法，用于获取更新节点的动作JSON对象，具体实现由子类提供  
+
+	    public abstract JSONObject getUpdateAction(int actionId);  
+
+	  
+
+	    // 抽象方法，用于从远程JSON对象设置节点的内容，具体实现由子类提供  
+
+	    public abstract void setContentByRemoteJSON(JSONObject js);  
+
+	  
+
+	    // 抽象方法，用于从本地JSON对象设置节点的内容，具体实现由子类提供  
+
+	    public abstract void setContentByLocalJSON(JSONObject js);  
+
+	  
+
+	    // 抽象方法，用于将节点的内容转换为本地JSON对象，具体实现由子类提供  
+
+	    public abstract JSONObject getLocalJSONFromContent();  
+
+	  
+
+	    // 抽象方法，用于根据数据库游标获取节点的同步动作，具体实现由子类提供  
+
+	    public abstract int getSyncAction(Cursor c);  
+
+	  
+
+	    // 设置节点的GID  
+
+	    public void setGid(String gid) {  
+
+	        this.mGid = gid;  
+
+	    }  
+
+	  
+
+	    // 获取节点的GID  
+
+	    public String getGid() {  
+
+	        return this.mGid;  
+
+	    }  
+
+	  
+
+	    // 设置节点的名称  
+
+	    public void setName(String name) {  
+
+	        this.mName = name;  
+
+	    }  
+
+	  
+
+	    // 获取节点的名称  
+
+	    public String getName() {  
+
+	        return this.mName;  
+
+	    }  
+
+	  
+
+	    // 设置节点最后修改的时间戳  
+
+	    public void setLastModified(long lastModified) {  
+
+	        this.mLastModified = lastModified;  
+
+	    }  
+
+	  
+
+	    // 获取节点最后修改的时间戳  
+
+	    public long getLastModified() {  
+
+	        return this.mLastModified;  
+
+	    }  
+
+	  
+
+	    // 设置节点是否被删除的标志  
+
+	    public void setDeleted(boolean deleted) {  
+
+	        this.mDeleted = deleted;  
+
+	    }  
+
+	  
+
+	    // 获取节点是否被删除的标志  
+
+	    public boolean getDeleted() {  
+
+	        return this.mDeleted;  
+
+	    }  
+
+	}

src/NoteEditActivity.java

@@ -0,0 +1,936 @@
+/*
+ * 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; // 导入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; // 导入内容URI工具类
+import android.content.Context; // 导入上下文类
+import android.content.DialogInterface; // 导入对话框接口
+import android.content.Intent; // 导入意图类
+import android.content.SharedPreferences; // 导入共享偏好设置类
+import android.graphics.Paint; // 导入画笔类
+import android.os.Bundle; // 导入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; // 导入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; // 导入2x小部件提供者类
+import net.micode.notes.widget.NoteWidgetProvider_4x; // 导入4x小部件提供者类
+
+import java.util.HashMap; // 导入哈希映射类
+import java.util.HashSet; // 导入哈希集合类
+import java.util.Map; // 导入映射类
+import java.util.regex.Matcher; // 导入正则表达式匹配器类
+import java.util.regex.Pattern; // 导入正则表达式类
+
+// 笔记编辑活动类，继承自Activity
+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; // 字体大小ID
+
+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); // 调用父类的onCreate方法
+    this.setContentView(R.layout.note_edit); // 设置内容视图为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); // 调用父类的onRestoreInstanceState方法
+    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)); // 添加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; // 初始化工作笔记为null
+    if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) { // 如果意图动作是查看
+        long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0); // 获取笔记ID
+        mUserQuery = "";
+
+        /**
+         * Starting from the searched result
+         */
+        if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) { // 如果有搜索结果
+            noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY)); // 获取搜索结果中的笔记ID
+            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); // 获取文件夹ID
+        int widgetId = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID); // 获取小部件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)); // 获取背景资源ID
+
+        // 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) { // 如果根据电话号码和通话日期获取到笔记ID
+                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(); // 调用父类的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));
+
+    // 显示提醒头部
+    showAlertHeader();
+}
+
+private void showAlertHeader() {
+    // 如果工作笔记有闹钟提醒
+    if (mWorkingNote.hasClockAlert()) {
+        long time = System.currentTimeMillis(); // 获取当前时间
+        // 如果当前时间超过了提醒时间
+        if (time > mWorkingNote.getAlertDate()) {
+            mNoteHeaderHolder.tvAlertDate.setText(R.string.note_alert_expired); // 设置提醒时间为“已过期”
+        } else {
+            // 显示相对时间，例如“3小时前”
+            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); // 调用父类的onNewIntent方法
+    initActivityState(intent); // 重新初始化活动状态
+}
+
+@Override
+protected void onSaveInstanceState(Bundle outState) {
+    super.onSaveInstanceState(outState); // 调用父类的onSaveInstanceState方法
+    /**
+     * 对于没有笔记ID的新笔记，我们应该先保存它以生成ID。
+     * 如果正在编辑的笔记不值得保存，那么没有ID，这等同于创建新笔记。
+     */
+    if (!mWorkingNote.existInDatabase()) { // 如果笔记不在数据库中
+        saveNote(); // 保存笔记
+    }
+    outState.putLong(Intent.EXTRA_UID, mWorkingNote.getNoteId()); // 将笔记ID保存到Bundle
+    Log.d(TAG, "Save working note id: " + mWorkingNote.getNoteId() + " onSaveInstanceState"); // 日志记录保存的笔记ID
+}
+
+@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); // 调用父类的dispatchTouchEvent方法
+}
+
+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);
+    // 获取字体大小ID
+    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(); // 调用父类的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;
+    }
+
+    // 添加小部件ID到意图
+    intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] {
+        mWorkingNote.getWidgetId()
+    });
+
+    // 发送广播更新小部件
+    sendBroadcast(intent);
+    setResult(RESULT_OK, intent); // 设置结果码和意图
+}
+
+public void onClick(View v) {
+    // 获取点击视图的ID
+    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)); // 更新工作笔记的背景颜色ID
+        mNoteBgColorSelector.setVisibility(View.GONE); // 隐藏背景颜色选择器
+    } else if (sFontSizeBtnsMap.containsKey(id)) { // 如果点击的是字体大小选择器按钮
+        findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.GONE); // 隐藏当前选中的字体大小
+        mFontSizeId = sFontSizeBtnsMap.get(id); // 更新字体大小ID
+        mSharedPrefs.edit().putInt(PREFERENCE_FONT_SIZE, mFontSizeId).commit(); // 保存字体大小ID到共享偏好设置
+        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(); // 调用父类的onBackPressed方法
+}
+
+private boolean clearSettingState() {
+    // 如果背景颜色选择器可见，隐藏它并返回true
+    if (mNoteBgColorSelector.getVisibility() == View.VISIBLE) {
+        mNoteBgColorSelector.setVisibility(View.GONE);
+        return true;
+    } else if (mFontSizeSelector.getVisibility() == View.VISIBLE) { // 如果字体大小选择器可见，隐藏它并返回true
+        mFontSizeSelector.setVisibility(View.GONE);
+        return true;
+    }
+    return false; // 没有设置状态被清除，返回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; // 返回true表示菜单已准备好
+}
+
+@Override
+public boolean onOptionsItemSelected(MenuItem item) {
+    // 根据点击的菜单项ID，执行相应的操作
+    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; // 返回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() {
+    // 保存当前编辑的笔记
+    saveNote();
+    // 结束当前活动，以确保新的笔记编辑活动可以启动
+    finish();
+    // 创建新的笔记编辑意图
+    Intent intent = new Intent(this, NoteEditActivity.class);
+    intent.setAction(Intent.ACTION_INSERT_OR_EDIT); // 设置动作为插入或编辑
+    intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mWorkingNote.getFolderId()); // 添加文件夹ID
+    startActivity(intent); // 启动新的笔记编辑活动
+}
+private void deleteCurrentNote() {
+    // 如果笔记存在于数据库中
+    if (mWorkingNote.existInDatabase()) {
+        HashSet<Long> ids = new HashSet<Long>(); // 创建一个ID集合
+        long id = mWorkingNote.getNoteId(); // 获取笔记ID
+        // 如果笔记ID不是根文件夹ID（一个特殊的ID）
+        if (id != Notes.ID_ROOT_FOLDER) {
+            ids.add(id); // 将笔记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) {
+    /**
+     * 用户可能为未保存的笔记设置闹钟，因此在设置闹钟之前，我们应该先保存笔记
+     */
+    if (!mWorkingNote.existInDatabase()) { // 如果笔记不在数据库中
+        saveNote(); // 保存笔记
+    }
+    if (mWorkingNote.getNoteId() > 0) { // 如果笔记有ID
+        Intent intent = new Intent(this, AlarmReceiver.class); // 创建闹钟接收器的意图
+        intent.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mWorkingNote.getNoteId())); // 设置数据URI
+        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 {
+        /**
+         * 用户输入为空（笔记不值得保存），我们没有笔记ID，提醒用户输入内容
+         */
+        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) {
+    /**
+     * 检查索引是否超出列表边界，不应该发生
+     */
+    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) {
+        /**
+         * 有两种模式从列表视图切换到编辑视图，打开一个笔记或创建/编辑一个笔记。
+         * 打开笔记需要在返回编辑视图时恢复原来的列表位置，而创建新笔记则需要在列表顶部。
+         * 这段代码中的{@link #RESULT_OK}用于标识创建/编辑状态
+         */
+        setResult(RESULT_OK); // 设置结果为OK，表示笔记已成功保存
+    }
+    return saved; // 返回保存结果
+}
+
+private void sendToDesktop() {
+    /**
+     * 在发送消息到主屏幕之前，我们需要确保当前编辑的笔记存在于数据库中。
+     * 因此，对于新笔记，首先保存它
+     */
+    if (!mWorkingNote.existInDatabase()) { // 如果笔记不在数据库中
+        saveNote(); // 保存笔记
+    }
+
+    if (mWorkingNote.getNoteId() > 0) { // 如果笔记ID有效
+        Intent sender = new Intent(); // 创建意图
+        Intent shortcutIntent = new Intent(this, NoteEditActivity.class); // 创建快捷方式意图
+        shortcutIntent.setAction(Intent.ACTION_VIEW); // 设置意图动作为查看
+        shortcutIntent.putExtra(Intent.EXTRA_UID, mWorkingNote.getNoteId()); // 添加笔记ID到意图
+        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 {
+        /**
+         * 用户输入为空（笔记不值得保存），我们没有笔记ID，提醒用户输入内容
+         */
+        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(); // 创建并显示吐司
+}

src/NoteEditText.java

@@ -0,0 +1,228 @@
+/*
+ * 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; // 导入URL样式类
+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; // 导入映射类
+
+// 自定义的编辑文本类，继承自EditText
+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:"; // 邮件协议
+
+    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); // HTTP协议动作
+        sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email); // 邮件协议动作
+    }
+
+    /**
+     * 由{@link NoteEditActivity}调用以删除或添加编辑文本
+     */
+    public interface OnTextViewChangeListener {
+        /**
+         * 当{@link KeyEvent#KEYCODE_DEL}发生且文本为空时删除当前编辑文本
+         */
+        void onEditTextDelete(int index, String text);
+
+        /**
+         * 当{@link KeyEvent#KEYCODE_ENTER}发生时在当前编辑文本后添加编辑文本
+         */
+        void onEditTextEnter(int index, String text);
+
+        /**
+         * 当文本变化时隐藏或显示项选项
+         */
+        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:
+                // 获取触摸事件的X和Y坐标
+                int x = (int) event.getX();
+                int y = (int) event.getY();
+                // 调整坐标以适应总内边距和滚动
+                x -= getTotalPaddingLeft();
+                y -= getTotalPaddingTop();
+                x += getScrollX();
+                y += getScrollY();
+
+                // 获取文本布局
+                Layout layout = getLayout();
+                // 获取Y坐标对应的行
+                int line = layout.getLineForVertical(y);
+                // 获取X坐标在行中的偏移量
+                int off = layout.getOffsetForHorizontal(line, x);
+                // 设置选择位置
+                Selection.setSelection(getText(), off);
+                break;
+        }
+
+        return super.onTouchEvent(event); // 调用父类的onTouchEvent方法
+    }
+
+    @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); // 调用父类的onKeyDown方法
+    }
+}
+
+@Override
+public boolean onKeyUp(int keyCode, KeyEvent event) {
+    // 处理按键释放事件
+    switch(keyCode) {
+        case KeyEvent.KEYCODE_DEL: // 如果是删除键
+            if (mOnTextViewChangeListener != null) { // 如果设置了文本变化监听器
+                if (0 == mSelectionStartBeforeDelete && mIndex != 0) { // 如果删除前的选择起始位置为0且索引不为0
+                    mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString()); // 调用监听器的删除方法
+                    return true; // 消费事件
+                } else {
+                    Log.d(TAG, "OnTextViewChangeListener was not seted"); // 日志记录未设置监听器
+                }
+            } 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); // 调用父类的onKeyUp方法
+}
+
+@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); // 调用父类的onFocusChanged方法
+}
+
+@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); // 获取URL样式
+        if (urls.length == 1) { // 如果有一个URL样式
+            int defaultResId = 0; // 默认资源ID
+            for(String schema: sSchemaActionResMap.keySet()) { // 遍历协议动作资源映射
+                if(urls[0].getURL().indexOf(schema) >= 0) { // 如果URL包含协议
+                    defaultResId = sSchemaActionResMap.get(schema); // 获取对应的资源ID
+                    break;
+                }
+            }
+
+            if (defaultResId == 0) { // 如果未找到对应的资源ID
+                defaultResId = R.string.note_link_other; // 使用其他链接的资源ID
+            }
+
+            // 添加菜单项
+            menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener(
+                    new OnMenuItemClickListener() {
+                        public boolean onMenuItemClick(MenuItem item) {
+                            // 点击菜单项时的处理
+                            urls[0].onClick(NoteEditText.this); // 调用URL样式的点击事件
+                            return true; // 消费事件
+                        }
+                    });
+        }
+    }
+    super.onCreateContextMenu(menu); // 调用父类的onCreateContextMenu方法
+}

src/NoteItemData.java

@@ -0,0 +1,259 @@
+/*
+ * 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; // 初始化多笔记标志为false
+        mIsOneNoteFollowingFolder = false; // 初始化单笔记标志为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; // 设置多笔记标志为true
+                    } else {
+                        mIsOneNoteFollowingFolder = true; // 设置单笔记标志为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() {
+    // 返回笔记ID
+    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() {
+    // 返回背景颜色ID
+    return mBgColorId;
+}
+
+public long getParentId() {
+    // 返回父ID，通常指文件夹ID
+    return mParentId;
+}
+
+public int getNotesCount() {
+    // 返回笔记计数
+    return mNotesCount;
+}
+
+public long getFolderId () {
+    // 返回文件夹ID，与getParentId方法相同
+    return mParentId;
+}
+
+public int getType() {
+    // 返回笔记类型
+    return mType;
+}
+
+public int getWidgetType() {
+    // 返回小部件类型
+    return mWidgetType;
+}
+
+public int getWidgetId() {
+    // 返回小部件ID
+    return mWidgetId;
+}
+
+public String getSnippet() {
+    // 返回笔记摘要
+    return mSnippet;
+}
+
+public boolean hasAlert() {
+    // 返回是否有提醒，即提醒日期是否大于0
+    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);
+}

src/NoteWidgetProvider.java

@@ -0,0 +1,168 @@
+/*
+ * 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;
+
+// 导入所需的Android类和接口
+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;
+
+// 定义一个抽象类NoteWidgetProvider，继承自AppWidgetProvider，用于管理便签Widget
+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";
+
+    // 当Widget被删除时调用的方法
+    @Override
+    public void onDeleted(Context context, int[] appWidgetIds) {
+        // 为数据库更新准备ContentValues对象
+        ContentValues values = new ContentValues();
+        // 设置WIDGET_ID为无效值
+        values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
+        // 遍历所有被删除的Widget ID
+        for (int i = 0; i < appWidgetIds.length; i++) {
+            // 更新数据库中对应的Widget ID为无效
+            context.getContentResolver().update(Notes.CONTENT_NOTE_URI,
+                    values,
+                    NoteColumns.WIDGET_ID + "=?",
+                    new String[] { String.valueOf(appWidgetIds[i])});
+        }
+    }
+
+    // 获取与特定Widget ID相关的便签信息
+    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);
+    }
+
+    // 更新Widget的方法，可以被外部调用
+    protected void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
+        // 调用内部的update方法，不启用隐私模式
+        update(context, appWidgetManager, appWidgetIds, false);
+    }
+
+    // 更新Widget的内部方法，根据是否启用隐私模式来更新Widget
+    private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds,
+            boolean privacyMode) {
+        // 遍历所有Widget ID
+        for (int i = 0; i < appWidgetIds.length; i++) {
+            // 如果Widget ID有效
+            if (appWidgetIds[i] != AppWidgetManager.INVALID_APPWIDGET_ID) {
+                // 获取默认背景ID
+                int bgId = ResourceParser.getDefaultBgId(context);
+                // 初始化摘要字符串
+                String snippet = "";
+                // 创建Intent，用于编辑便签
+                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
+                Cursor c = getNoteWidgetInfo(context, appWidgetIds[i]);
+                // 如果Cursor不为空且第一条数据有效
+                if (c != null && c.moveToFirst()) {
+                    // 如果有多条数据与Widget ID匹配，记录错误日志并返回
+                    if (c.getCount() > 1) {
+                        Log.e(TAG, "Multiple message with same widget id:" + appWidgetIds[i]);
+                        c.close();
+                        return;
+                    }
+                    // 从Cursor中获取摘要和背景ID
+                    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);
+                }
+
+                // 关闭Cursor
+                if (c != null) {
+                    c.close();
+                }
+
+                // 创建RemoteViews对象，用于更新Widget视图
+                RemoteViews rv = new RemoteViews(context.getPackageName(), getLayoutId());
+                // 设置背景图片资源ID
+                rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId));
+                intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId);
+                // 生成PendingIntent，用于启动宿主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);
+                }
+
+                // 设置RemoteViews的PendingIntent
+                rv.setOnClickPendingIntent(R.id.widget_text, pendingIntent);
+                // 更新Widget
+                appWidgetManager.updateAppWidget(appWidgetIds[i], rv);
+            }
+        }
+    }
+
+    // 抽象方法，用于获取背景资源ID
+    protected abstract int getBgResourceId(int bgId);
+
+    // 抽象方法，用于获取布局ID
+    protected abstract int getLayoutId();
+
+    // 抽象方法，用于获取Widget类型
+    protected abstract int getWidgetType();
+}

src/NoteWidgetProvider_2x.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.
+ */
+
+// 定义了一个名为NoteWidgetProvider_2x的类，它继承自NoteWidgetProvider类
+public class NoteWidgetProvider_2x extends NoteWidgetProvider {
+    // 覆盖了onUpdate方法，该方法是AppWidgetProvider的一个回调方法，用于当小部件需要更新时被调用
+    @Override
+    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
+        // 调用父类的update方法，传入context、appWidgetManager和appWidgetIds参数
+        super.update(context, appWidgetManager, appWidgetIds);
+    }
+
+    // 覆盖了getLayoutId方法，该方法用于返回小部件的布局资源ID
+    @Override
+    protected int getLayoutId() {
+        // 返回名为widget_2x的布局资源ID，这个布局资源定义了小部件的外观
+        return R.layout.widget_2x;
+    }
+
+    // 覆盖了getBgResourceId方法，该方法用于根据传入的背景ID返回对应的背景资源ID
+    @Override
+    protected int getBgResourceId(int bgId) {
+        // 调用ResourceParser.WidgetBgResources类的getWidget2xBgResource方法，传入bgId参数，返回对应的背景资源ID
+        return ResourceParser.WidgetBgResources.getWidget2xBgResource(bgId);
+    }
+
+    // 覆盖了getWidgetType方法，该方法用于返回小部件的类型
+    @Override
+    protected int getWidgetType() {
+        // 返回Notes.TYPE_WIDGET_2X，这是一个常量，表示这是一个2x2大小的小部件
+        return Notes.TYPE_WIDGET_2X;
+    }
+}

src/NoteWidgetProvider_4x.java

@@ -0,0 +1,55 @@
+/*
+ * 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的类，它继承自NoteWidgetProvider类
+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 {
+    // 覆盖了onUpdate方法，该方法是AppWidgetProvider的一个回调方法，用于当小部件需要更新时被调用
+    @Override
+    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
+        // 调用父类的update方法，传入context、appWidgetManager和appWidgetIds参数
+        super.update(context, appWidgetManager, appWidgetIds);
+    }
+
+    // getLayoutId方法用于返回小部件的布局资源ID
+    // 注意：这个方法没有被标记为@Override，这意味着它不是覆盖父类的方法，而是NoteWidgetProvider_4x类中新增的方法
+    protected int getLayoutId() {
+        // 返回名为widget_4x的布局资源ID，这个布局资源定义了小部件的外观
+        return R.layout.widget_4x;
+    }
+
+    // 覆盖了getBgResourceId方法，该方法用于根据传入的背景ID返回对应的背景资源ID
+    @Override
+    protected int getBgResourceId(int bgId) {
+        // 调用ResourceParser.WidgetBgResources类的getWidget4xBgResource方法，传入bgId参数，返回对应的背景资源ID
+        return ResourceParser.WidgetBgResources.getWidget4xBgResource(bgId);
+    }
+
+    // 覆盖了getWidgetType方法，该方法用于返回小部件的类型
+    @Override
+    protected int getWidgetType() {
+        // 返回Notes.TYPE_WIDGET_4X，这是一个常量，表示这是一个4x4大小的小部件
+        return Notes.TYPE_WIDGET_4X;
+    }
+}

src/NotesListActivity.java

@@ -0,0 +1,962 @@
+/*
+ * 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; // 导入Activity类
+import android.app.AlertDialog; // 导入AlertDialog类
+import android.app.Dialog; // 导入Dialog类
+import android.appwidget.AppWidgetManager; // 导入AppWidgetManager类
+import android.content.AsyncQueryHandler; // 导入AsyncQueryHandler类
+import android.content.ContentResolver; // 导入ContentResolver类
+import android.content.ContentValues; // 导入ContentValues类
+import android.content.Context; // 导入Context类
+import android.content.DialogInterface; // 导入DialogInterface类
+import android.content.Intent; // 导入Intent类
+import android.content.SharedPreferences; // 导入SharedPreferences类
+import android.content.res.Resources; // 导入Resources类
+import android.database.Cursor; // 导入Cursor类
+import android.os.AsyncTask; // 导入AsyncTask类
+import android.os.Bundle; // 导入Bundle类
+import android.preference.PreferenceManager; // 导入PreferenceManager类
+import android.text.Editable; // 导入Editable类
+import android.text.TextUtils; // 导入TextUtils类
+import android.text.TextWatcher; // 导入TextWatcher类
+import android.util.Log; // 导入Log类
+import android.view.ActionMode; // 导入ActionMode类
+import android.view.ContextMenu; // 导入ContextMenu类
+import android.view.Display; // 导入Display类
+import android.view.HapticFeedbackConstants; // 导入HapticFeedbackConstants类
+import android.view.LayoutInflater; // 导入LayoutInflater类
+import android.view.Menu; // 导入Menu类
+import android.view.MenuItem; // 导入MenuItem类
+import android.view.MotionEvent; // 导入MotionEvent类
+import android.view.View; // 导入View类
+import android.view.inputmethod.InputMethodManager; // 导入InputMethodManager类
+import android.widget.AdapterView; // 导入AdapterView类
+import android.widget.Button; // 导入Button类
+import android.widget.EditText; // 导入EditText类
+import android.widget.ListView; // 导入ListView类
+import android.widget.PopupMenu; // 导入PopupMenu类
+import android.widget.TextView; // 导入TextView类
+import android.widget.Toast; // 导入Toast类
+
+import net.micode.notes.R; // 导入项目的资源文件
+import net.micode.notes.data.Notes; // 导入Notes类
+import net.micode.notes.data.Notes.NoteColumns; // 导入笔记列定义
+import net.micode.notes.gtask.remote.GTaskSyncService; // 导入GTaskSyncService类
+import net.micode.notes.model.WorkingNote; // 导入WorkingNote类
+import net.micode.notes.tool.BackupUtils; // 导入BackupUtils类
+import net.micode.notes.tool.DataUtils; // 导入DataUtils类
+import net.micode.notes.tool.ResourceParser; // 导入ResourceParser类
+import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute; // 导入AppWidgetAttribute类
+import net.micode.notes.widget.NoteWidgetProvider_2x; // 导入NoteWidgetProvider_2x类
+import net.micode.notes.widget.NoteWidgetProvider_4x; // 导入NoteWidgetProvider_4x类
+
+import java.io.BufferedReader; // 导入BufferedReader类
+import java.io.IOException; // 导入IOException类
+import java.io.InputStream; // 导入InputStream类
+import java.io.InputStreamReader; // 导入InputStreamReader类
+import java.util.HashSet; // 导入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; // 原始Y坐标
+    private int mDispatchY; // 分发Y坐标
+    private TextView mTitleBar; // 标题栏
+    private long mCurrentFolderId; // 当前文件夹ID
+    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); // 调用父类的onCreate方法
+        setContentView(R.layout.note_list); // 设置内容视图为note_list布局
+        initResources(); // 初始化资源
+
+        /**
+         * 当用户首次使用此应用程序时插入介绍
+         */
+        setAppInfoFromRawRes(); // 从raw资源文件中设置应用信息
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        if (resultCode == RESULT_OK // 如果结果码为OK
+                && (requestCode == REQUEST_CODE_OPEN_NODE || requestCode == REQUEST_CODE_NEW_NODE)) { // 如果请求码为打开节点或新建节点
+            mNotesListAdapter.changeCursor(null); // 更改适配器的游标
+        } else {
+            super.onActivityResult(requestCode, resultCode, data); // 调用父类的onActivityResult方法
+        }
+    }
+
+    private void setAppInfoFromRawRes() {
+        SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this); // 获取默认的SharedPreferences
+        if (!sp.getBoolean(PREFERENCE_ADD_INTRODUCTION, false)) { // 如果没有添加过介绍
+            StringBuilder sb = new StringBuilder(); // 创建字符串构建器
+            InputStream in = null; // 创建输入流
+            try {
+                 in = getResources().openRawResource(R.raw.introduction); // 打开raw资源文件
+                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(); // 调用父类的onStart方法
+    startAsyncNotesListQuery(); // 启动异步笔记列表查询
+}
+
+private void initResources() {
+    mContentResolver = this.getContentResolver(); // 获取内容解析器
+    mBackgroundQueryHandler = new BackgroundQueryHandler(this.getContentResolver()); // 创建后台查询处理器
+    mCurrentFolderId = Notes.ID_ROOT_FOLDER; // 设置当前文件夹ID为根文件夹ID
+    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; // 初始化分发标志为false
+    mDispatchY = 0; // 初始化分发Y坐标为0
+    mOriginY = 0; // 初始化原始Y坐标为0
+    mTitleBar = (TextView) findViewById(R.id.tv_title_bar); // 获取标题栏
+    mState = ListEditState.NOTE_LIST; // 初始化列表编辑状态为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); // 设置列表选择模式为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();
+        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); // 设置列表选择模式为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;
+                
+                // 计算触摸事件的Y坐标
+                int eventY = start + (int) event.getY();
+                
+                // 如果处于子文件夹状态，则减去标题栏的高度
+                if (mState == ListEditState.SUB_FOLDER) {
+                    eventY -= mTitleBar.getHeight();
+                    start -= mTitleBar.getHeight();
+                }
+                
+                // 如果触摸事件在“添加新笔记”按钮的透明部分，则将事件分发到列表视图
+                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: {
+                // 在移动事件中，更新分发的Y坐标
+                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; // 返回false，表示未处理事件
+    }
+}
+
+private void startAsyncNotesListQuery() {
+    // 根据当前文件夹ID选择查询条件
+    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) // 添加当前文件夹ID作为查询参数
+            }, 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); // 添加当前文件夹ID
+    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 (DataUtils.batchDeleteNotes(mContentResolver, mNotesListAdapter
+                        .getSelectedItemIds())) {
+                    // 删除成功
+                } else {
+                    Log.e(TAG, "Delete notes error, should not happens"); // 日志记录删除错误
+                }
+            } else {
+                // 在同步模式下，将删除的笔记移动到垃圾文件夹
+                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) {
+    // 如果文件夹ID是根文件夹ID，记录错误并返回
+    if (folderId == Notes.ID_ROOT_FOLDER) {
+        Log.e(TAG, "Wrong folder id, should not happen " + folderId);
+        return;
+    }
+
+    HashSet<Long> ids = new HashSet<Long>(); // 创建文件夹ID集合
+    ids.add(folderId); // 添加文件夹ID
+    HashSet<AppWidgetAttribute> widgets = DataUtils.getFolderNoteWidget(mContentResolver,
+            folderId); // 获取与文件夹相关的小部件
+    if (!isSyncMode()) { // 如果不是同步模式
+        // 直接删除文件夹
+        DataUtils.batchDeleteNotes(mContentResolver, ids);
+    } else {
+        // 在同步模式下，将删除的文件夹移动到垃圾文件夹
+        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()); // 添加笔记ID到意图
+    this.startActivityForResult(intent, REQUEST_CODE_OPEN_NODE); // 启动笔记编辑活动
+}
+
+private void openFolder(NoteItemData data) {
+    mCurrentFolderId = data.getId(); // 更新当前文件夹ID
+    startAsyncNotesListQuery(); // 启动异步笔记列表查询
+    // 根据文件夹ID设置状态
+    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(); // 创建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(); // 创建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); // 禁用“确定”按钮
+    }
+    // 当编辑框文本变化时，启用或禁用“确定”按钮
+    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; // 设置当前文件夹ID为根文件夹ID
+            mState = ListEditState.NOTE_LIST; // 设置状态为NOTE_LIST
+            startAsyncNotesListQuery(); // 启动异步笔记列表查询
+            mTitleBar.setVisibility(View.GONE); // 隐藏标题栏
+            break;
+        case CALL_RECORD_FOLDER:
+            mCurrentFolderId = Notes.ID_ROOT_FOLDER; // 设置当前文件夹ID为根文件夹ID
+            mState = ListEditState.NOTE_LIST; // 设置状态为NOTE_LIST
+            mAddNewNote.setVisibility(View.VISIBLE); // 显示添加新笔记按钮
+            mTitleBar.setVisibility(View.GONE); // 隐藏标题栏
+            startAsyncNotesListQuery(); // 启动异步笔记列表查询
+            break;
+        case NOTE_LIST:
+            super.onBackPressed(); // 调用父类的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; // 返回
+    }
+
+    // 添加小部件ID到意图
+    intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] {
+        appWidgetId
+    });
+
+    sendBroadcast(intent); // 发送广播以更新小部件
+    setResult(RESULT_OK, intent); // 设置结果为OK
+}
+
+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); // 调用父类的onContextMenuClosed方法
+}
+
+@Override
+public boolean onContextItemSelected(MenuItem item) {
+    // 处理上下文菜单项的选择
+    if (mFocusNoteDataItem == null) { // 如果焦点笔记数据项为空
+        Log.e(TAG, "The long click data item is null"); // 日志记录错误
+        return false; // 返回false
+    }
+    switch (item.getItemId()) { // 根据菜单项ID执行相应操作
+        case MENU_FOLDER_VIEW:
+            openFolder(mFocusNoteDataItem); // 打开文件夹
+            break;
+        case MENU_FOLDER_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_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; // 返回true表示菜单项已处理
+}
+
+@Override
+public boolean onPrepareOptionsMenu(Menu menu) {
+    // 准备选项菜单
+    menu.clear(); // 清除菜单项
+    if (mState == ListEditState.NOTE_LIST) { // 如果当前状态是笔记列表
+        getMenuInflater().inflate(R.menu.note_list, menu); // 加载笔记列表菜单
+        // 设置同步或取消同步的菜单项标题
+        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; // 返回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; // 返回true表示菜单项已处理
+}
+
+@Override
+public boolean onSearchRequested() {
+    // 请求搜索
+    startSearch(null, false, null /* appData */, false); // 启动搜索
+    return true; // 返回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) {
+                // SD卡未挂载
+                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;
+}

src/NotesListAdapter.java

@@ -0,0 +1,195 @@
+/*
+ * 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; // 导入Context类
+import android.database.Cursor; // 导入Cursor类
+import android.util.Log; // 导入Log类
+import android.view.View; // 导入View类
+import android.view.ViewGroup; // 导入ViewGroup类
+import android.widget.CursorAdapter; // 导入CursorAdapter类
+
+import net.micode.notes.data.Notes; // 导入Notes类
+
+import java.util.Collection; // 导入Collection接口
+import java.util.HashMap; // 导入HashMap类
+import java.util.HashSet; // 导入HashSet类
+import java.util.Iterator; // 导入Iterator接口
+
+
+// 自定义的笔记列表适配器类，继承自CursorAdapter
+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; // 是否处于选择模式
+
+    // 定义AppWidgetAttribute内部类，用于存储小部件属性
+    public static class AppWidgetAttribute {
+        public int widgetId; // 小部件ID
+        public int widgetType; // 小部件类型
+    };
+
+    // 构造函数，接收上下文对象
+    public NotesListAdapter(Context context) {
+        super(context, null); // 调用父类构造函数
+        mSelectedIndex = new HashMap<Integer, Boolean>(); // 初始化选中状态哈希映射
+        mContext = context; // 初始化上下文对象
+        mNotesCount = 0; // 初始化笔记计数为0
+    }
+
+    // 新建视图
+    @Override
+    public View newView(Context context, Cursor cursor, ViewGroup parent) {
+        return new NotesListItem(context); // 返回新的NotesListItem视图
+    }
+
+    // 绑定视图
+    @Override
+    public void bindView(View view, Context context, Cursor cursor) {
+        if (view instanceof NotesListItem) { // 如果视图是NotesListItem的实例
+            NoteItemData itemData = new NoteItemData(context, cursor); // 创建NoteItemData对象
+            ((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); // 设置选中状态
+                }
+            }
+        }
+    }
+
+    // 获取选中的笔记ID集合
+    public HashSet<Long> getSelectedItemIds() {
+        HashSet<Long> itemSet = new HashSet<Long>(); // 创建ID集合
+        for (Integer position : mSelectedIndex.keySet()) { // 遍历选中状态哈希映射
+            if (mSelectedIndex.get(position) == true) { // 如果选中
+                Long id = getItemId(position); // 获取ID
+                if (id == Notes.ID_ROOT_FOLDER) { // 如果是根文件夹ID
+                    Log.d(TAG, "Wrong item id, should not happen"); // 日志记录错误
+                } else {
+                    itemSet.add(id); // 添加到ID集合
+                }
+            }
+        }
+        return itemSet; // 返回ID集合
+    }
+
+    // 获取选中的小部件属性集合
+    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); // 创建NoteItemData对象
+                    widget.widgetId = item.getWidgetId(); // 获取小部件ID
+                    widget.widgetType = item.getWidgetType(); // 获取小部件类型
+                    itemSet.add(widget); // 添加到小部件属性集合
+                } else {
+                    Log.e(TAG, "Invalid cursor"); // 日志记录错误
+                    return null; // 返回null
+                }
+            }
+        }
+        return itemSet; // 返回小部件属性集合
+    }
+}
+public int getSelectedCount() {
+    // 获取选中项的数量
+    Collection<Boolean> values = mSelectedIndex.values(); // 获取选中状态值的集合
+    if (null == values) {
+        return 0; // 如果集合为空，则返回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); // 如果选中项的数量大于0且等于笔记总数，则返回true
+}
+
+public boolean isSelectedItem(final int position) {
+    // 检查指定位置的项是否被选中
+    if (null == mSelectedIndex.get(position)) { // 如果指定位置没有选中状态
+        return false; // 返回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; // 返回
+        }
+    }
+}

src/NotesListItem.java

@@ -0,0 +1,129 @@
+/*
+ * 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; // 导入Notes类
+import net.micode.notes.tool.DataUtils; // 导入数据工具类
+import net.micode.notes.tool.ResourceParser.NoteItemBgResources; // 导入笔记项背景资源解析器类
+
+// 自定义的笔记列表项类，继承自LinearLayout
+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) { // 如果父ID是通话记录文件夹
+            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(); // 获取背景颜色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()); // 如果是文件夹类型，设置文件夹背景
+        }
+    }
+
+    public NoteItemData getItemData() {
+        // 返回笔记项数据
+        return mItemData;
+    }
+}

src/NotesPreferenceActivity.java

@@ -0,0 +1,465 @@
+/*
+ * 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.accounts.Account; // 导入Account类
+import android.accounts.AccountManager; // 导入AccountManager类
+import android.app.ActionBar; // 导入ActionBar类
+import android.app.AlertDialog; // 导入AlertDialog类
+import android.content.BroadcastReceiver; // 导入BroadcastReceiver类
+import android.content.ContentValues; // 导入ContentValues类
+import android.content.Context; // 导入Context类
+import android.content.DialogInterface; // 导入DialogInterface类
+import android.content.Intent; // 导入Intent类
+import android.content.IntentFilter; // 导入IntentFilter类
+import android.content.SharedPreferences; // 导入SharedPreferences类
+import android.os.Bundle; // 导入Bundle类
+import android.preference.Preference; // 导入Preference类
+import android.preference.Preference.OnPreferenceClickListener; // 导入PreferenceClickListener接口
+import android.preference.PreferenceActivity; // 导入PreferenceActivity类
+import android.preference.PreferenceCategory; // 导入PreferenceCategory类
+import android.text.TextUtils; // 导入TextUtils类
+import android.text.format.DateFormat; // 导入DateFormat类
+import android.view.LayoutInflater; // 导入LayoutInflater类
+import android.view.Menu; // 导入Menu类
+import android.view.MenuItem; // 导入MenuItem类
+import android.view.View; // 导入View类
+import android.widget.Button; // 导入Button类
+import android.widget.TextView; // 导入TextView类
+import android.widget.Toast; // 导入Toast类
+
+import net.micode.notes.R; // 导入项目的资源文件
+import net.micode.notes.data.Notes; // 导入Notes类
+import net.micode.notes.data.Notes.NoteColumns; // 导入NoteColumns类
+import net.micode.notes.gtask.remote.GTaskSyncService; // 导入GTaskSyncService类
+
+// 继承自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"; // 设置背景颜色的键
+
+    private static final String PREFERENCE_SYNC_ACCOUNT_KEY = "pref_sync_account_key"; // 同步账户的键
+
+    private static final String AUTHORITIES_FILTER_KEY = "authorities"; // 权限过滤的键
+
+    private PreferenceCategory mAccountCategory; // 账户类别的PreferenceCategory
+
+    private GTaskReceiver mReceiver; // 用于接收GTask同步状态的BroadcastReceiver
+
+    private Account[] mOriAccounts; // 原始账户数组
+
+    private boolean mHasAddedAccount; // 是否添加了账户
+
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle); // 调用父类的onCreate方法
+
+        /* using the app icon for navigation */
+        getActionBar().setDisplayHomeAsUpEnabled(true); // 设置ActionBar的返回键可用
+
+        addPreferencesFromResource(R.xml.preferences); // 从资源文件中添加偏好设置
+        mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY); // 获取同步账户的PreferenceCategory
+        mReceiver = new GTaskReceiver(); // 创建GTaskReceiver实例
+        IntentFilter filter = new IntentFilter(); // 创建IntentFilter
+        filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME); // 添加GTask服务广播的Action
+        registerReceiver(mReceiver, filter); // 注册BroadcastReceiver
+
+        mOriAccounts = null; // 初始化原始账户数组为null
+        View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null); // 从布局文件中填充设置头部视图
+        getListView().addHeaderView(header, null, true); // 将头部视图添加到ListView
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume(); // 调用父类的onResume方法
+
+        // 如果用户添加了新账户，需要自动设置同步账户
+        if (mHasAddedAccount) {
+            Account[] accounts = getGoogleAccounts(); // 获取Google账户数组
+            if (mOriAccounts != null && accounts.length > mOriAccounts.length) { // 如果新账户数组长度大于原始账户数组长度
+                for (Account accountNew : accounts) { // 遍历新账户数组
+                    boolean found = false; // 初始化找到标志为false
+                    for (Account accountOld : mOriAccounts) { // 遍历原始账户数组
+                        if (TextUtils.equals(accountOld.name, accountNew.name)) { // 如果找到相同的账户
+                            found = true; // 设置找到标志为true
+                            break; // 跳出循环
+                        }
+                    }
+                    if (!found) { // 如果没有找到相同的账户
+                        setSyncAccount(accountNew.name); // 设置同步账户
+                        break; // 跳出循环
+                    }
+                }
+            }
+        }
+
+        refreshUI(); // 刷新用户界面
+    }
+}
+@Override
+protected void onDestroy() {
+    // 检查mReceiver是否已经被实例化，如果是，则注销广播接收器
+    if (mReceiver != null) {
+        unregisterReceiver(mReceiver);
+    }
+    // 调用父类的onDestroy方法，继续执行其他清理工作
+    super.onDestroy();
+}
+
+// 加载账户偏好设置
+private void loadAccountPreference() {
+    // 清除mAccountCategory中的所有Preference
+    mAccountCategory.removeAll();
+
+    // 创建一个新的Preference对象
+    Preference accountPref = new Preference(this);
+    // 获取默认同步账户的名称
+    final String defaultAccount = getSyncAccountName(this);
+    // 设置Preference的标题
+    accountPref.setTitle(getString(R.string.preferences_account_title));
+    // 设置Preference的摘要信息
+    accountPref.setSummary(getString(R.string.preferences_account_summary));
+    // 设置Preference点击事件的监听器
+    accountPref.setOnPreferenceClickListener(new OnPreferenceClickListener() {
+        public boolean onPreferenceClick(Preference preference) {
+            // 如果没有正在进行的同步操作
+            if (!GTaskSyncService.isSyncing()) {
+                // 如果defaultAccount为空，表示是第一次设置账户
+                if (TextUtils.isEmpty(defaultAccount)) {
+                    showSelectAccountAlertDialog(); // 显示选择账户的AlertDialog
+                } else {
+                    // 如果账户已经设置，提示用户更换账户的风险
+                    showChangeAccountConfirmAlertDialog();
+                }
+            } else {
+                // 如果正在进行同步操作，显示一个Toast提示用户不能更改账户
+                Toast.makeText(NotesPreferenceActivity.this,
+                        R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
+                        .show();
+            }
+            // 返回true表示已经处理了点击事件
+            return true;
+        }
+    });
+
+    // 将创建的Preference添加到mAccountCategory中
+    mAccountCategory.addPreference(accountPref);
+}
+
+// 加载同步按钮
+private void loadSyncButton() {
+    // 通过findViewById获取同步按钮和最后同步时间的TextView
+    Button syncButton = (Button) findViewById(R.id.preference_sync_button);
+    TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
+
+    // 根据是否正在同步来设置按钮的状态
+    if (GTaskSyncService.isSyncing()) {
+        // 如果正在同步，设置按钮文本为取消同步，并设置点击事件为取消同步操作
+        syncButton.setText(getString(R.string.preferences_button_sync_cancel));
+        syncButton.setOnClickListener(new View.OnClickListener() {
+            public void onClick(View v) {
+                GTaskSyncService.cancelSync(NotesPreferenceActivity.this); // 取消同步
+            }
+        });
+    } else {
+        // 如果没有同步操作，设置按钮文本为立即同步，并设置点击事件为开始同步操作
+        syncButton.setText(getString(R.string.preferences_button_sync_immediately));
+        syncButton.setOnClickListener(new View.OnClickListener() {
+            public void onClick(View v) {
+                GTaskSyncService.startSync(NotesPreferenceActivity.this); // 开始同步
+            }
+        });
+    }
+    // 根据账户名称是否为空来启用或禁用同步按钮
+    syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this)));
+
+    // 设置最后同步时间的显示
+    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,
+                    DateFormat.format(getString(R.string.preferences_last_sync_time_format),
+                            lastSyncTime)));
+            lastSyncTimeView.setVisibility(View.VISIBLE);
+        } else {
+            lastSyncTimeView.setVisibility(View.GONE);
+        }
+    }
+}
+
+// 刷新UI，加载账户偏好和同步按钮
+private void refreshUI() {
+    loadAccountPreference(); // 加载账户偏好
+    loadSyncButton(); // 加载同步按钮
+}
+// 显示选择账户的对话框
+private void showSelectAccountAlertDialog() {
+    // 创建AlertDialog.Builder对象，用于构建对话框
+    AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
+
+    // 从布局文件中加载自定义标题视图
+    View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
+    // 获取标题TextView并设置标题文本
+    TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
+    titleTextView.setText(getString(R.string.preferences_dialog_select_account_title));
+    // 获取副标题TextView并设置副标题文本
+    TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
+    subtitleTextView.setText(getString(R.string.preferences_dialog_select_account_tips));
+
+    // 设置自定义标题
+    dialogBuilder.setCustomTitle(titleView);
+    // 设置正面按钮（未设置文本和点击事件，后续会处理）
+    dialogBuilder.setPositiveButton(null, null);
+
+    // 获取Google账户列表
+    Account[] accounts = getGoogleAccounts();
+    // 获取当前同步账户名称
+    String defAccount = getSyncAccountName(this);
+
+    // 保存原始账户列表和添加账户标志
+    mOriAccounts = accounts;
+    mHasAddedAccount = false;
+
+    // 如果有账户可供选择
+    if (accounts.length > 0) {
+        // 创建CharSequence数组用于存储账户名称
+        CharSequence[] items = new CharSequence[accounts.length];
+        final CharSequence[] itemMapping = items; // 用于后续选择
+        int checkedItem = -1; // 记录选中的账户索引
+        int index = 0; // 当前索引
+        // 遍历账户列表
+        for (Account account : accounts) {
+            // 如果账户名称与默认账户名称匹配，记录选中的索引
+            if (TextUtils.equals(account.name, defAccount)) {
+                checkedItem = index;
+            }
+            // 将账户名称添加到items数组中
+            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(); // 刷新UI
+                    }
+                });
+    }
+
+    // 从布局文件中加载添加账户的视图
+    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; // 设置已添加账户标志
+            // 创建意图以打开添加账户设置
+            Intent intent = new Intent("android.settings.ADD_ACCOUNT_SETTINGS");
+            intent.putExtra(AUTHORITIES_FILTER_KEY, new String[] {
+                "gmail-ls" // 过滤器，指定要添加的账户类型
+            });
+            startActivityForResult(intent, -1); // 启动添加账户设置
+            dialog.dismiss(); // 关闭对话框
+        }
+    });
+}
+
+// 显示更改账户确认对话框
+private void showChangeAccountConfirmAlertDialog() {
+    // 创建AlertDialog.Builder对象
+    AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
+
+    // 从布局文件中加载自定义标题视图
+    View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
+    // 获取标题TextView并设置标题文本
+    TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
+    titleTextView.setText(getString(R.string.preferences_dialog_change_account_title,
+            getSyncAccountName(this))); // 显示当前同步账户名称
+    // 获取副标题TextView并设置副标题文本
+    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_remove_account), // 移除账户
+            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(); // 刷新UI
+            }
+        }
+    });
+    // 显示对话框
+    dialogBuilder.show();
+}
+
+// 获取Google账户列表
+private Account[] getGoogleAccounts() {
+    // 获取AccountManager实例
+    AccountManager accountManager = AccountManager.get(this);
+    // 返回所有Google账户
+    return accountManager.getAccountsByType("com.google");
+}
+
+// 设置同步账户
+private void setSyncAccount(String account) {
+    // 检查当前同步账户是否与传入的账户不同
+    if (!getSyncAccountName(this).equals(account)) {
+        // 获取SharedPreferences实例，用于存储偏好设置
+        SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
+        SharedPreferences.Editor editor = settings.edit();
+        // 如果传入的账户不为空，则保存账户名称；否则保存空字符串
+        if (account != null) {
+            editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, account);
+        } else {
+            editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
+        }
+        editor.commit(); // 提交更改
+
+        // 清除最后同步时间
+        setLastSyncTime(this, 0);
+
+        // 清除本地与gtask相关的信息
+        new Thread(new Runnable() {
+            public void run() {
+                ContentValues values = new ContentValues();
+                values.put(NoteColumns.GTASK_ID, ""); // 清空GTASK_ID
+                values.put(NoteColumns.SYNC_ID, 0); // 清空SYNC_ID
+                // 更新Notes.CONTENT_NOTE_URI中的数据
+                getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
+            }
+        }).start(); // 启动新线程执行清理操作
+
+        // 显示成功设置账户的Toast提示
+        Toast.makeText(NotesPreferenceActivity.this,
+                getString(R.string.preferences_toast_success_set_accout, account),
+                Toast.LENGTH_SHORT).show();
+    }
+}
+
+// 移除同步账户
+private void removeSyncAccount() {
+    // 获取SharedPreferences实例
+    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(); // 提交更改
+
+    // 清除本地与gtask相关的信息
+    new Thread(new Runnable() {
+        public void run() {
+            ContentValues values = new ContentValues();
+            values.put(NoteColumns.GTASK_ID, ""); // 清空GTASK_ID
+            values.put(NoteColumns.SYNC_ID, 0); // 清空SYNC_ID
+            // 更新Notes.CONTENT_NOTE_URI中的数据
+            getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
+        }
+    }).start(); // 启动新线程执行清理操作
+}
+
+// 获取当前同步账户名称
+public static String getSyncAccountName(Context context) {
+    // 获取SharedPreferences实例
+    SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
+            Context.MODE_PRIVATE);
+    // 返回存储的同步账户名称，默认为空字符串
+    return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
+}
+
+// 设置最后同步时间
+public static void setLastSyncTime(Context context, long time) {
+    // 获取SharedPreferences实例
+    SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
+            Context.MODE_PRIVATE);
+    SharedPreferences.Editor editor = settings.edit();
+    // 保存最后同步时间
+    editor.putLong(PREFERENCE_LAST_SYNC_TIME, time);
+    editor.commit(); // 提交更改
+}
+
+// 获取最后同步时间
+public static long getLastSyncTime(Context context) {
+    // 获取SharedPreferences实例
+    SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
+            Context.MODE_PRIVATE);
+    // 返回存储的最后同步时间，默认为0
+    return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);
+}
+
+// 定义GTaskReceiver类，继承自BroadcastReceiver
+private class GTaskReceiver extends BroadcastReceiver {
+
+    // 当接收到广播时调用
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        refreshUI(); // 刷新UI
+        // 检查广播中是否包含同步状态信息
+        if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {
+            // 获取同步状态的TextView并更新其文本
+            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: // 如果点击的是返回按钮
+            // 创建返回到NotesListActivity的意图
+            Intent intent = new Intent(this, NotesListActivity.class);
+            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); // 清除上层活动
+            startActivity(intent); // 启动活动
+            return true; // 返回true表示事件已处理
+        default:
+            return false; // 返回false表示未处理该事件
+    }
+}

src/SqlData.java

@@ -0,0 +1,147 @@
+/*
+ * 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.
+ */
+
+java
+复制代码
+	// 导入所需的包  
+
+	// ...（省略了导入语句，因为它们在前面的代码段中已给出）  
+
+	  
+
+	// SqlData类，用于处理与数据库中的特定数据项相关的操作  
+
+	public class SqlData {  
+
+	    // 定义日志标签，用于调试和日志记录  
+
+	    private static final String TAG = SqlData.class.getSimpleName();  
+
+	  
+
+	    // 定义一个无效ID常量，用于标识未设置或无效的ID  
+
+	    private static final int INVALID_ID = -99999;  
+
+	  
+
+	    // 定义要从数据库中检索的列的投影数组  
+
+	    public static final String[] PROJECTION_DATA = {  
+
+	        // ...（省略了列名，它们在前面的代码段中已给出）  
+
+	    };  
+
+	  
+
+	    // 定义投影数组中各列的索引，以便在Cursor中快速访问  
+
+	    // ...（省略了列索引常量，它们在前面的代码段中已给出）  
+
+	  
+
+	    // 私有成员变量，用于存储与数据项相关的状态和信息  
+
+	    // ...（省略了成员变量声明，它们在前面的代码段中已给出）  
+
+	  
+
+	    // 构造方法，用于创建新的SqlData实例  
+
+	    // 当isCreate为true时，表示这是一个新创建的数据项；否则，它表示一个已存在的数据项  
+
+	    public SqlData(Context context) {  
+
+	        // ...（省略了构造方法体，它已经在前面的代码段中给出）  
+
+	    }  
+
+	  
+
+	    // 构造方法，用于从Cursor加载已存在的数据项  
+
+	    public SqlData(Context context, Cursor c) {  
+
+	        // ...（省略了构造方法体，它已经在前面的代码段中给出）  
+
+	    }  
+
+	  
+
+	    // 私有方法，用于从Cursor加载数据到成员变量中  
+
+	    private void loadFromCursor(Cursor c) {  
+
+	        // ...（省略了方法体，它已经在前面的代码段中给出）  
+
+	    }  
+
+	  
+
+	    // 公共方法，用于设置数据项的内容，根据传入的JSONObject更新成员变量和差异数据  
+
+	    public void setContent(JSONObject js) throws JSONException {  
+
+	        // ...（省略了方法体，但保留了注释说明）  
+
+	        // 这个方法首先检查JSONObject中是否包含特定的键，并根据这些键的值更新成员变量和差异数据（mDiffDataValues）  
+
+	    }  
+
+	  
+
+	    // 公共方法，用于获取数据项的内容，并将其作为JSONObject返回  
+
+	    public JSONObject getContent() throws JSONException {  
+
+	        // ...（省略了方法体，但保留了注释说明）  
+
+	        // 如果这是一个新创建的数据项（尚未插入数据库），则记录错误并返回null  
+
+	        // 否则，将数据项的内容构建为JSONObject并返回  
+
+	    }  
+
+	  
+
+	    // 公共方法，用于提交数据项到数据库  
+
+	    // 如果isCreate为true，则插入新数据项；否则，更新现有数据项  
+
+	    public void commit(long noteId, boolean validateVersion, long version) {  
+
+	        // ...（省略了方法体，但保留了注释说明）  
+
+	        // 这个方法根据isCreate的值决定是插入新数据项还是更新现有数据项  
+
+	        // 如果validateVersion为true，则在更新时检查版本以避免冲突  
+
+	        // 提交成功后，清除差异数据并将isCreate设置为false  
+
+	    }  
+
+	  
+
+	    // 公共方法，用于获取数据项的ID  
+
+	    public long getId() {  
+
+	        return mDataId;  
+
+	    }  
+
+	}