注释

AlarmAlertActivity.java

@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.ui;
+
+import android.app.Activity;// 活动的基类
+import android.app.AlertDialog;// 用于创建警告对话框
+import android.content.Context; // 提供访问应用程序特定资源的上下文
+import android.content.DialogInterface; // 对话框交互接口
+import android.content.Intent; // 创建启动新活动的意图
+import android.media.AudioManager; // 管理音频设置
+import android.media.MediaPlayer; // 播放音频文件
+import android.media.RingtoneManager; // 访问系统铃声
+import android.net.Uri; // 表示URI
+import android.os.Bundle;// 在活动之间传递数据
+import android.os.PowerManager; // 管理电源状态
+import android.provider.Settings; // 系统设置
+import android.view.Window; // 窗口管理
+import android.view.WindowManager;// 管理窗口
+
+import net.micode.notes.R; // 导入资源引用
+import net.micode.notes.data.Notes; // 导入笔记数据模型
+import net.micode.notes.tool.DataUtils; // 数据操作的工具函数
+
+import java.io.IOException; // 处理IO异常
+
+
+public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener {
+    private long mNoteId;
+     // 笔记的唯一标识
+    private String mSnippet;
+     // 笔记的内容片段
+    private static final int SNIPPET_PREW_MAX_LEN = 60;
+     // 内容片段的最大长度
+    MediaPlayer mPlayer;
+    // 媒体播放器，用于播放警报音
+
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+        // 请求无标题窗口
+
+        final Window win = getWindow();
+         // 设置窗口标志，使其在锁屏时可见
+        win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
+
+          // 如果屏幕未亮，则设置相关标志
+        if (!isScreenOn()) {
+            win.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON 
+            // 保持屏幕常亮
+                    | WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON 
+                    // 打开屏幕
+                    | WindowManager.LayoutParams.FLAG_ALLOW_LOCK_WHILE_SCREEN_ON 
+                    // 允许锁定屏幕
+                    | WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR); 
+                    // 窗口布局插入装饰
+        }
+
+        Intent intent = getIntent();
+        // 获取启动活动的意图
+
+       try {
+            // 从意图中提取笔记ID
+            mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1));
+            // 根据笔记ID获取内容片段
+            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
+    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 {
+        // 设置数据源为铃声URI
+        mPlayer.setDataSource(this, url);
+        mPlayer.prepare(); 
+        // 准备播放器
+        mPlayer.setLooping(true); 
+        // 设置循环播放
+        mPlayer.start(); 
+        // 开始播放
+    } catch (IllegalArgumentException e) {
+        e.printStackTrace(); // 打印异常信息
+    } catch (SecurityException e) {
+        e.printStackTrace(); // 打印异常信息
+    } catch (IllegalStateException e) {
+        e.printStackTrace(); // 打印异常信息
+    } catch (IOException 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); 
+            // 传递笔记ID
+            startActivity(intent); 
+            // 启动活动
+            break;
+        default:
+            break; // 默认情况不处理
+    }
+}
+
+public void onDismiss(DialogInterface dialog) {
+    stopAlarmSound(); 
+    // 停止播放警报声音
+    finish(); 
+    // 结束当前活动
+}
+
+private void stopAlarmSound() {
+    if (mPlayer != null) {
+        mPlayer.stop(); 
+        // 停止播放
+        mPlayer.release();
+         // 释放媒体播放器资源
+        mPlayer = null; 
+        // 清空播放器引用
+    }
+}

AlarmInitReceiver.java

@@ -0,0 +1,81 @@
+/*
+ * 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;
+
+// 导入所需的Android类
+import android.app.AlarmManager; // 用于管理闹钟服务
+import android.app.PendingIntent; // 用于延迟执行的意图
+import android.content.BroadcastReceiver; // 广播接收器基类
+import android.content.ContentUris; // 用于处理内容URI
+import android.content.Context; // 上下文类
+import android.content.Intent; // 意图类
+import android.database.Cursor; // 数据库结果集游标
+
+// 导入笔记相关的数据类
+import net.micode.notes.data.Notes; // 笔记数据类
+import net.micode.notes.data.Notes.NoteColumns; // 笔记列定义类
+
+
+public class AlarmInitReceiver extends BroadcastReceiver {
+
+    // 定义要查询的列
+    private static final String [] PROJECTION = new String [] {
+        NoteColumns.ID,            
+        // 笔记ID
+        NoteColumns.ALERTED_DATE   
+        // 警报日期
+    };
+
+    // 列索引
+    private static final int COLUMN_ID                = 0; 
+    // ID列索引
+    private static final int COLUMN_ALERTED_DATE      = 1;
+     // 警报日期列索引
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        long currentDate = System.currentTimeMillis(); // 获取当前时间戳
+        // 查询提醒日期大于当前时间的笔记
+        Cursor c = context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
+                PROJECTION,
+                NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE,
+                new String[] { String.valueOf(currentDate) },
+                null);
+
+        if (c != null) {
+            // 如果结果集不为空
+            if (c.moveToFirst()) {
+                do {
+                    long alertDate = c.getLong(COLUMN_ALERTED_DATE); 
+                    // 获取警报日期
+                    Intent sender = new Intent(context, AlarmReceiver.class); // 创建意图，用于发送警报
+                    // 设置数据为对应的笔记URI
+                    sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(COLUMN_ID)));
+                    // 创建PendingIntent，注册广播接收器
+                    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(); 
+            // 关闭Cursor
+        }
+    }
+}

AlarmReceiver.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.ui; 
+// 指定当前类所在的包名
+
+import android.content.BroadcastReceiver; // 导入广播接收器基类
+import android.content.Context; // 导入上下文类
+import android.content.Intent; // 导入意图类
+
+// 定义AlarmReceiver类，继承自BroadcastReceiver
+public class AlarmReceiver extends BroadcastReceiver {
+    @Override
+    // 当接收到广播时调用的方法
+    public void onReceive(Context context, Intent intent) {
+        // 设置要启动的活动为AlarmAlertActivity
+        intent.setClass(context, AlarmAlertActivity.class);
+        // 添加标志，使新的活动在新的任务中启动
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        // 启动AlarmAlertActivity
+        context.startActivity(intent);
+    }
+}

DateTimePicker.java

@@ -0,0 +1,599 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.ui; 
+// 定义包名
+
+import java.text.DateFormatSymbols; // 导入用于日期格式符号的类
+import java.util.Calendar; // 导入日历类
+
+import net.micode.notes.R; // 导入资源类，通常包含布局和字符串资源
+
+import android.content.Context; // 导入上下文类
+import android.text.format.DateFormat; // 导入日期格式化类
+import android.view.View; // 导入视图类
+import android.widget.FrameLayout; // 导入框架布局类
+import android.widget.NumberPicker; // 导入数字选择器类
+
+public class DateTimePicker extends FrameLayout { 
+    // 定义DateTimePicker类，继承自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; // 上午/下午选择器的最小值
+    private static final int AMPM_SPINNER_MAX_VAL = 1; // 上午/下午选择器的最大值
+
+    private final NumberPicker mDateSpinner; // 日期选择器
+    private final NumberPicker mHourSpinner; // 小时选择器
+    private final NumberPicker mMinuteSpinner; // 分钟选择器
+    private final NumberPicker mAmPmSpinner; // 上午/下午选择器
+    private Calendar mDate; // 日期对象
+
+    private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK]; 
+    // 存储日期显示值的数组
+
+    private boolean mIsAm; 
+    // 标识是否为上午
+
+    private boolean mIs24HourView; 
+    // 标识是否为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) {
+            mDate.add(Calendar.DAY_OF_YEAR, newVal - oldVal); // 更新日期
+            updateDateControl(); // 更新日期控制
+            onDateTimeChanged(); // 通知日期时间已改变
+        }
+    };
+
+
+private NumberPicker.OnValueChangeListener mOnHourChangedListener = new NumberPicker.OnValueChangeListener() {
+    @Override
+    public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+        boolean isDateChanged = false; // 标识日期是否改变
+        Calendar cal = Calendar.getInstance(); // 获取当前日历实例
+
+        // 如果不是24小时制
+        if (!mIs24HourView) {
+            // 如果从 PM 切换到 AM，日期需要加一天
+            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; // 日期改变标识为真
+            } 
+            // 如果从 AM 切换到 PM，日期需要减一天
+            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(); // 更新 AM/PM 控件
+            }
+        } 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) {
+        int minValue = mMinuteSpinner.getMinValue(); // 获取分钟选择器的最小值
+        int maxValue = mMinuteSpinner.getMaxValue(); // 获取分钟选择器的最大值
+        int offset = 0; // 偏移量初始化为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(); // 更新日期控件
+            
+            // 根据当前小时判断 AM/PM 状态
+            int newHour = getCurrentHourOfDay();
+            if (newHour >= HOURS_IN_HALF_DAY) {
+                mIsAm = false; // 设置为下午
+                updateAmPmControl(); // 更新 AM/PM 控件
+            } else {
+                mIsAm = true; // 设置为上午
+                updateAmPmControl(); // 更新 AM/PM 控件
+            }
+        }
+        mDate.set(Calendar.MINUTE, newVal); // 更新日期对象中的分钟
+        onDateTimeChanged(); // 通知日期时间已改变
+    }
+};
+
+private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() {
+    @Override
+    public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+        mIsAm = !mIsAm; // 切换 AM/PM 状态
+        // 根据 AM/PM 状态调整小时
+        if (mIsAm) {
+            mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY); 
+            // 设置为上午，减去12小时
+        } else {
+            mDate.add(Calendar.HOUR_OF_DAY, HOURS_IN_HALF_DAY); 
+            // 设置为下午，加上12小时
+        }
+        updateAmPmControl(); // 更新 AM/PM 控件
+        onDateTimeChanged(); // 通知日期时间已改变
+    }
+};
+
+  // 定义一个接口，用于日期时间变化的监听
+public interface OnDateTimeChangedListener {
+    void onDateTimeChanged(DateTimePicker view, int year, int month,
+                           int dayOfMonth, int hourOfDay, int minute);
+}
+
+// DateTimePicker 类的构造函数
+public DateTimePicker(Context context) {
+    // 默认调用带有当前时间的构造函数
+    this(context, System.currentTimeMillis());
+}
+
+// 带有日期参数的构造函数
+public DateTimePicker(Context context, long date) {
+    // 调用带有日期和24小时制标志的构造函数
+    this(context, date, DateFormat.is24HourFormat(context));
+}
+
+// 带有日期和24小时制标志的构造函数
+public DateTimePicker(Context context, long date, boolean is24HourView) {
+    super(context); // 调用父类构造函数
+    mDate = Calendar.getInstance(); // 获取当前日历实例
+    mInitialising = true; // 初始化标志
+    mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY; // 判断当前是否为上午
+    inflate(context, R.layout.datetime_picker, this); // 加载自定义布局
+
+    // 日期选择器的初始化
+    mDateSpinner = (NumberPicker) findViewById(R.id.date);
+    mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL); // 设置最小值
+    mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL); // 设置最大值
+    mDateSpinner.setOnValueChangedListener(mOnDateChangedListener); // 设置日期变化监听器
+
+    // 小时选择器的初始化
+    mHourSpinner = (NumberPicker) findViewById(R.id.hour);
+    mHourSpinner.setOnValueChangedListener(mOnHourChangedListener); // 设置小时变化监听器
+
+    // 分钟选择器的初始化
+    mMinuteSpinner = (NumberPicker) findViewById(R.id.minute);
+    mMinuteSpinner.setMinValue(MINUT_SPINNER_MIN_VAL); // 设置最小值
+    mMinuteSpinner.setMaxValue(MINUT_SPINNER_MAX_VAL); // 设置最大值
+    mMinuteSpinner.setOnLongPressUpdateInterval(100); // 长按更新间隔
+    mMinuteSpinner.setOnValueChangedListener(mOnMinuteChangedListener); // 设置分钟变化监听器
+
+    // 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); // 显示 AM/PM 值
+    mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener); // 设置 AM/PM 变化监听器
+}
+
+
+        // update controls to initial state
+        updateDateControl(); // 更新日期控件
+        updateHourControl(); // 更新小时控件
+        updateAmPmControl(); // 更新 AM/PM 控件
+
+        set24HourView(is24HourView); // 设置为24小时制或12小时制
+
+
+        // set to current time
+        setCurrentDate(date);// 根据传入的日期设置当前日期
+
+        setEnabled(isEnabled());// 根据是否启用状态设置控件
+
+
+        // set the content descriptions
+        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 date The current date in millis
+     */
+    public void setCurrentDate(long date) {
+        Calendar cal = Calendar.getInstance(); // 获取当前日历实例
+        cal.setTimeInMillis(date); // 根据传入的毫秒值设置时间
+         // 设置当前日期和时间
+        setCurrentDate(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH),cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE));
+}
+
+    /**
+     * Set the current date
+     *
+     * @param year The current year
+     * @param month The current month
+     * @param dayOfMonth The current dayOfMonth
+     * @param hourOfDay The current hourOfDay
+     * @param minute The current minute
+     */
+   public void setCurrentDate(int year, int month,int dayOfMonth, int hourOfDay, int minute) {
+    // 设置当前年份
+    setCurrentYear(year);
+    
+    // 设置当前月份
+    setCurrentMonth(month);
+    
+    // 设置当前日期
+    setCurrentDay(dayOfMonth);
+    
+    // 设置当前小时
+    setCurrentHour(hourOfDay);
+    
+    // 设置当前分钟
+    setCurrentMinute(minute);
+}
+
+
+    /**
+     * Get current year
+     *
+     * @return The current year
+     */
+    public int getCurrentYear() { // 返回当前日期对象中的年份
+        return mDate.get(Calendar.YEAR);
+    }
+
+    /**
+     * Set current year
+     *
+     * @param year The current year
+     */
+    public void setCurrentYear(int year) {
+         // 如果不是初始化状态并且输入的年份与当前年份相同，则不做任何操作
+        if (!mInitialising && year == getCurrentYear()) {
+            return;
+        }
+       // 设置当前年份
+         mDate.set(Calendar.YEAR, year);
+        // 更新日期控件
+        updateDateControl();
+        // 通知日期和时间已改变
+        onDateTimeChanged();
+    }
+
+    /**
+     * Get current month in the year
+     *
+     * @return The current month in the year
+     */
+    public int getCurrentMonth() {
+        return mDate.get(Calendar.MONTH);
+    }
+
+    /**
+     * Set current month in the year
+     *
+     * @param month The month in the year
+     */
+    public void setCurrentMonth(int month) {
+        // 如果不是初始化状态并且输入的月份与当前月份相同，则不做任何操作
+        if (!mInitialising && month == getCurrentMonth()) {
+            return;
+        }
+        // 设置当前月份
+        mDate.set(Calendar.MONTH, month);
+        // 更新日期控件
+        updateDateControl();
+        // 通知日期和时间已改变
+        onDateTimeChanged();
+    }
+
+    /**
+     * Get current day of the month
+     *
+     * @return The day of the month
+     */
+    public int getCurrentDay() {
+        return mDate.get(Calendar.DAY_OF_MONTH);
+    }
+
+    /**
+     * Set current day of the month
+     *
+     * @param dayOfMonth The day of the month
+     */
+  public void setCurrentDay(int dayOfMonth) {
+    // 如果不是初始化状态，并且输入的日期与当前日期相同，则不做任何操作
+    if (!mInitialising && dayOfMonth == getCurrentDay()) {
+        return;
+    }
+    // 设置当前日期
+    mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
+    // 更新日期控件
+    updateDateControl();
+    // 通知日期和时间已改变
+    onDateTimeChanged();
+}
+
+    /**
+     * Get current hour in 24 hour mode, in the range (0~23)
+     * @return The current hour in 24 hour mode
+     */
+    public int getCurrentHourOfDay() {
+        return mDate.get(Calendar.HOUR_OF_DAY);
+    }
+
+private int getCurrentHour() {
+    if (mIs24HourView) {
+        // 如果是24小时制，直接返回当前小时
+        return getCurrentHourOfDay();
+    } else {
+        // 如果是12小时制
+        int hour = getCurrentHourOfDay();
+        if (hour > HOURS_IN_HALF_DAY) {
+            // 如果小时大于12，则转换为12小时制
+            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
+     */
+    public void setCurrentHour(int hourOfDay) {
+         // 如果不是初始化状态，并且输入的小时与当前小时相同，则不做任何操作
+        if (!mInitialising && hourOfDay == getCurrentHourOfDay()) {
+            return;
+        }
+            // 设置当前小时
+        mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
+        // 如果不是24小时制，处理AM/PM的显示
+        if (!mIs24HourView) {
+            if (hourOfDay >= HOURS_IN_HALF_DAY) {
+                      // 设置为PM
+                mIsAm = false;
+                if (hourOfDay > HOURS_IN_HALF_DAY) {
+                      // 转换为12小时制
+                    hourOfDay -= HOURS_IN_HALF_DAY;
+                }
+            } else {
+                        // 设置为AM
+                mIsAm = true;
+                if (hourOfDay == 0) {
+                         // 0点转换为12点
+                    hourOfDay = HOURS_IN_HALF_DAY;
+                }
+            }
+            // 更新AM/PM控件
+            updateAmPmControl();
+        }
+            // 更新小时选择器的值
+        mHourSpinner.setValue(hourOfDay);
+            // 通知时间已改变
+        onDateTimeChanged();
+    }
+
+    /**
+     * Get currentMinute
+     *
+     * @return The Current Minute
+     */
+    public int getCurrentMinute() {
+        return mDate.get(Calendar.MINUTE);
+    }
+
+    /**
+     * Set current minute
+     */
+    public void setCurrentMinute(int minute) {
+        // 如果不是初始化状态，并且输入的分钟与当前分钟相同，则不做任何操作
+        if (!mInitialising && minute == getCurrentMinute()) {
+            return;
+        }
+          // 更新分钟选择器的值
+        mMinuteSpinner.setValue(minute);
+            // 设置当前分钟
+        mDate.set(Calendar.MINUTE, minute);
+            // 通知时间已改变
+        onDateTimeChanged();
+    }
+
+    /**
+     * @return true if this is in 24 hour view else false.
+     */
+    public boolean is24HourView () {
+        return mIs24HourView;
+    }
+
+    /**
+     * Set whether in 24 hour or AM/PM mode.
+     *
+     * @param is24HourView True for 24 hour mode. False for AM/PM mode.
+     */
+    public void set24HourView(boolean is24HourView) {
+        // 如果当前状态与传入参数相同，则不做任何操作
+        if (mIs24HourView == is24HourView) {
+            return;
+        }
+         // 更新24小时制标志
+        mIs24HourView = is24HourView;
+            // 根据24小时制的选择，设置AM/PM选择器的可见性
+        mAmPmSpinner.setVisibility(is24HourView ? View.GONE : View.VISIBLE);
+           // 获取当前小时，并更新控件
+        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();// 刷新日期选择器
+    }
+/**
+ * 更新AM/PM控制
+ */
+    private void updateAmPmControl() {
+        // 如果是24小时制，则隐藏AM/PM选择器
+        if (mIs24HourView) {
+            mAmPmSpinner.setVisibility(View.GONE);
+        } else {
+             // 否则，根据当前时间选择AM或PM
+            int index = mIsAm ? Calendar.AM : Calendar.PM;
+            mAmPmSpinner.setValue(index);// 设置AM/PM选择器的值
+            mAmPmSpinner.setVisibility(View.VISIBLE);// 显示选择器
+        }
+    }
+/**
+ * 更新小时控制
+ */
+    private void updateHourControl() {
+            // 根据是否为24小时制更新小时选择器的最小和最大值
+        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());
+        } 
+        // 当前年份、 当前月份、当前日期、当前小时、当前分钟
+    }
+

DateTimePickerDialog.java

@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.ui;
+
+// 导入所需的类
+import java.util.Calendar; // 导入日历类，用于日期和时间的管理
+
+import net.micode.notes.R; // 导入资源类，用于访问字符串资源等
+import net.micode.notes.ui.DateTimePicker; // 导入自定义的日期时间选择器类
+import net.micode.notes.ui.DateTimePicker.OnDateTimeChangedListener; // 导入日期时间变化监听器接口
+
+import android.app.AlertDialog; // 导入对话框类，用于创建对话框
+import android.content.Context; // 导入上下文类，用于获取应用环境信息
+import android.content.DialogInterface; // 导入对话框接口类，用于处理对话框事件
+import android.content.DialogInterface.OnClickListener; // 导入对话框点击事件监听器接口
+import android.text.format.DateFormat; // 导入日期格式化类，用于格式化日期和时间
+import android.text.format.DateUtils; // 导入日期工具类，提供日期格式化和显示功能
+
+// 自定义日期时间选择对话框类
+public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
+
+    private Calendar mDate = Calendar.getInstance(); 
+    // 用于存储当前选中的日期和时间
+    private boolean mIs24HourView; 
+    // 标识是否使用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.set(Calendar.YEAR, year);
+                mDate.set(Calendar.MONTH, month);
+                mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
+                mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
+                mDate.set(Calendar.MINUTE, minute);
+                updateTitle(mDate.getTimeInMillis()); 
+                // 更新对话框标题
+            }
+        });
+
+        mDate.setTimeInMillis(date); // 设置初始日期时间
+        mDate.set(Calendar.SECOND, 0); // 将秒数设为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;
+         // 根据设置选择小时制
+        setTitle(DateUtils.formatDateTime(this.getContext(), date, flag)); 
+        // 格式化日期时间并设置为对话框标题
+    }
+
+    // 点击事件处理
+    public void onClick(DialogInterface arg0, int arg1) {
+        // 如果设置了监听器，则调用其方法并传递当前时间戳
+        if (mOnDateTimeSetListener != null) {
+            mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis());
+        }
+    }
+}

DropdownMenu.java

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.ui;
+
+import android.content.Context; 
+ // 引入 Context 类，提供访问应用环境的功能，如启动活动、获取系统服务、访问资源等。
+import android.view.Menu;  
+// 引入 Menu 类，定义菜单的结构，通常用于上下文菜单、选项菜单等。
+import android.view.MenuItem; 
+ // 引入 MenuItem 类，代表菜单中的一项，可以设置标题、图标等属性并绑定点击事件。
+import android.view.View;  
+// 引入 View 类，所有 UI 控件的基类，处理控件的显示和用户交互（如点击、拖动等）。
+import android.view.View.OnClickListener;  
+// 引入 OnClickListener 接口，用于处理视图（如按钮）的点击事件。
+import android.widget.Button;  
+// 引入 Button 类，用于在界面中创建按钮控件，用户点击按钮时可以触发某个操作。
+import android.widget.PopupMenu;  
+// 引入 PopupMenu 类，表示一个弹出式菜单，通常用于显示上下文菜单或按钮点击后的菜单。
+import android.widget.PopupMenu.OnMenuItemClickListener;  
+// 引入 OnMenuItemClickListener 接口，用于处理 PopupMenu 中菜单项的点击事件。
+import net.micode.notes.R;  
+// 引入 R 类，自动生成的资源类，用于访问应用的资源文件（如布局、字符串、ID 等）。
+
+
+// DropdownMenu 类用于显示一个下拉菜单
+public class DropdownMenu {
+
+    // 成员变量
+    private Button mButton;                // 按钮，用于触发下拉菜单显示
+    private PopupMenu mPopupMenu;          // 弹出菜单
+    private Menu mMenu;                    // 菜单对象，用于管理菜单项
+
+    // 构造函数，初始化按钮和菜单
+    public DropdownMenu(Context context, Button button, int menuId) {
+        // 将传入的按钮实例赋值给 mButton
+        mButton = button;
+        
+        // 设置按钮的背景资源（这里使用的是一个下拉图标）
+        mButton.setBackgroundResource(R.drawable.dropdown_icon);
+        
+        // 初始化 PopupMenu 对象，关联按钮
+        mPopupMenu = new PopupMenu(context, mButton);
+        
+        // 获取菜单对象
+        mMenu = mPopupMenu.getMenu();
+        
+        // 使用菜单 ID（通过菜单资源 XML 文件）填充菜单项
+        mPopupMenu.getMenuInflater().inflate(menuId, mMenu);
+        
+        // 设置按钮的点击事件监听器，当按钮被点击时显示弹出菜单
+        mButton.setOnClickListener(new OnClickListener() {
+            public void onClick(View v) {
+                // 显示弹出菜单
+                mPopupMenu.show();
+            }
+        });
+    }
+
+    // 设置菜单项点击事件监听器
+    public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {
+        // 如果 mPopupMenu 已经初始化，则设置菜单项点击事件监听器
+        if (mPopupMenu != null) {
+            mPopupMenu.setOnMenuItemClickListener(listener);
+        }
+    }
+
+    // 根据 ID 查找菜单项
+    public MenuItem findItem(int id) {
+        return mMenu.findItem(id);
+    }
+
+    // 设置按钮的文本（通常用于显示当前菜单的标题或提示）
+    public void setTitle(CharSequence title) {
+        mButton.setText(title);
+    }
+}

FoldersListAdapter.java

@@ -0,0 +1,109 @@
+/*
+ * 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.view.View;  
+// 引入 View 类，所有 UI 控件的基类。
+import android.view.ViewGroup;  
+// 引入 ViewGroup 类，表示可以包含其他视图的容器类。
+import android.widget.CursorAdapter; 
+ // 引入 CursorAdapter 类，用于绑定数据库查询结果与 UI 元素。
+import android.widget.LinearLayout;  
+// 引入 LinearLayout 类，线性布局容器，用于按顺序排列视图。
+import android.widget.TextView;  
+// 引入 TextView 类，用于显示文本。
+
+import net.micode.notes.R;  
+// 引入 R 类，自动生成的资源类，访问应用的资源（如字符串、布局、ID 等）。
+import net.micode.notes.data.Notes; 
+ // 引入 Notes 类，表示笔记相关的数据模型。
+import net.micode.notes.data.Notes.NoteColumns; 
+ // 引入 NoteColumns 类，表示与笔记相关的数据库字段。
+
+// FoldersListAdapter 类是一个自定义的 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;  // 文件夹名称列索引
+
+    // 构造函数，接收 Context 和 Cursor，传递给父类的构造函数。
+    public FoldersListAdapter(Context context, Cursor c) {
+        super(context, c);  // 调用父类 CursorAdapter 的构造函数
+    }
+
+    // newView 方法负责创建新的视图（即每一行的数据项）。
+    @Override
+    public View newView(Context context, Cursor cursor, ViewGroup parent) {
+        return new FolderListItem(context);  
+        // 返回一个新的 FolderListItem 视图（表示文件夹项）。
+    }
+
+    // bindView 方法负责绑定数据到视图上，通常是处理显示和数据的绑定。
+    @Override
+    public void bindView(View view, Context context, Cursor cursor) {
+        if (view instanceof FolderListItem) {  
+            // 确保视图是 FolderListItem 类型
+            // 获取文件夹的名称。如果是根文件夹，则显示特定的名称（菜单中的 "父文件夹"），否则显示文件夹名称。
+            String folderName = (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) 
+                ? context.getString(R.string.menu_move_parent_folder) 
+                : cursor.getString(NAME_COLUMN);
+            
+            // 将获取的名称绑定到 FolderListItem 中
+            ((FolderListItem) view).bind(folderName);
+        }
+    }
+
+    // getFolderName 方法用于根据位置获取文件夹名称。
+    public String getFolderName(Context context, int position) {
+        Cursor cursor = (Cursor) getItem(position); 
+         // 获取指定位置的 Cursor 数据
+        // 根据文件夹的 ID 返回对应的名称
+        return (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) 
+            ? context.getString(R.string.menu_move_parent_folder) 
+            : cursor.getString(NAME_COLUMN);
+    }
+
+    // FolderListItem 类表示文件夹列表项的视图，它是一个 LinearLayout。
+    private class FolderListItem extends LinearLayout {
+        private TextView mName;  
+        // 用于显示文件夹名称的 TextView 控件。
+
+        // FolderListItem 的构造函数，初始化视图和控件。
+        public FolderListItem(Context context) {
+            super(context);
+            inflate(context, R.layout.folder_list_item, this); 
+             // 加载 folder_list_item 布局文件
+            mName = (TextView) findViewById(R.id.tv_folder_name); 
+             // 获取文件夹名称显示控件
+        }
+
+        // bind 方法用于将文件夹名称绑定到 TextView 上。
+        public void bind(String name) {
+            mName.setText(name);  // 设置文件夹名称
+        }
+    }
+}

NoteEditText.java

@@ -0,0 +1,276 @@
+/*
+ * 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;
+
+// 引入相关的 Android 和 Java 库
+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; // 用于解析 XML 布局文件中的自定义属性
+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; // Android 中的编辑文本控件
+
+// 引入项目中的资源文件
+import net.micode.notes.R; // 自定义的资源文件，可能是图片、字符串或布局
+
+// 引入 HashMap 和 Map，用于存储一些键值对数据
+import java.util.HashMap;
+import java.util.Map;
+
+
+public class NoteEditText extends EditText {
+    // 定义日志标签，用于调试时输出日志
+    private static final String TAG = "NoteEditText";
+
+    // 变量：当前光标所在的索引
+    private int mIndex;
+
+    // 变量：记录删除操作之前光标的起始位置
+    private int mSelectionStartBeforeDelete;
+
+    // 定义常量，表示不同的 URL scheme
+    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>();
+
+    // 静态初始化块，将不同的 URL scheme 与对应的字符串资源 ID 关联
+    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); // 邮件链接的处理方式
+    }
+
+    /**
+     * Call by the {@link NoteEditActivity} to delete or add edit text
+     */
+    public interface OnTextViewChangeListener {
+        /**
+         * Delete current edit text when {@link KeyEvent#KEYCODE_DEL} happens
+         * and the text is null
+         */
+        void onEditTextDelete(int index, String text);
+
+        /**
+         * Add edit text after current edit text when {@link KeyEvent#KEYCODE_ENTER}
+         * happen
+         */
+        void onEditTextEnter(int index, String text);
+
+        /**
+         * Hide or show item option when text change
+         */
+        void onTextChange(int index, boolean hasText);
+    }
+
+    private OnTextViewChangeListener mOnTextViewChangeListener;
+
+   public class NoteEditText extends EditText {
+    private int mIndex;  // 用于存储索引
+    private int mSelectionStartBeforeDelete;  // 记录删除前的光标位置
+    private OnTextViewChangeListener mOnTextViewChangeListener;  // 用于监听文本变动的接口
+    private static final String TAG = "NoteEditText";  // 日志标签
+
+    // 构造函数1：仅接受上下文作为参数
+    public NoteEditText(Context context) {
+        super(context, null);
+        mIndex = 0;  // 默认索引为0
+    }
+
+    // 构造函数2：接受上下文和属性集作为参数
+    public NoteEditText(Context context, AttributeSet attrs) {
+        super(context, attrs, android.R.attr.editTextStyle);
+    }
+
+    // 构造函数3：接受上下文、属性集和样式作为参数
+    public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+        // 可以根据需要添加初始化代码
+    }
+
+    // 设置索引值的方法
+    public void setIndex(int index) {
+        mIndex = index;
+    }
+
+    // 设置监听器的方法
+    public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
+        mOnTextViewChangeListener = listener;
+    }
+
+    // 处理触摸事件，主要是设置光标位置
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        switch (event.getAction()) {
+            case MotionEvent.ACTION_DOWN:
+                // 获取触摸位置
+                int x = (int) event.getX();
+                int y = (int) event.getY();
+
+                // 计算相对位置，考虑了内边距和滚动偏移
+                x -= getTotalPaddingLeft();
+                y -= getTotalPaddingTop();
+                x += getScrollX();
+                y += getScrollY();
+
+                // 获取文本布局对象
+                Layout layout = getLayout();
+                // 获取触摸点所在的行
+                int line = layout.getLineForVertical(y);
+                // 获取该行中触摸点对应的字符偏移位置
+                int off = layout.getOffsetForHorizontal(line, x);
+                // 设置光标到指定位置
+                Selection.setSelection(getText(), off);
+                break;
+        }
+
+        return super.onTouchEvent(event);  // 默认处理
+    }
+
+    // 处理按键事件
+    @Override
+    public boolean onKeyDown(int keyCode, KeyEvent event) {
+        switch (keyCode) {
+            case KeyEvent.KEYCODE_ENTER:
+                // 如果设置了监听器，按下回车键时返回
+                if (mOnTextViewChangeListener != null) {
+                    return false;  // 返回false表示继续处理事件
+                }
+                break;
+            case KeyEvent.KEYCODE_DEL:
+                // 记录删除前的光标位置
+                mSelectionStartBeforeDelete = getSelectionStart();
+                break;
+            default:
+                break;
+        }
+        return super.onKeyDown(keyCode, event);  // 默认处理
+    }
+
+    // 处理按键抬起事件
+    @Override
+    public boolean onKeyUp(int keyCode, KeyEvent event) {
+        switch(keyCode) {
+            case KeyEvent.KEYCODE_DEL:
+                // 删除键处理
+                if (mOnTextViewChangeListener != null) {
+                    // 如果删除前光标位置为0并且索引不为0，调用删除监听器
+                    if (0 == mSelectionStartBeforeDelete && mIndex != 0) {
+                        mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString());
+                        return true;  // 返回true表示事件已处理
+                    }
+                } else {
+                    Log.d(TAG, "OnTextViewChangeListener was not seted");
+                }
+                break;
+            case KeyEvent.KEYCODE_ENTER:
+                // 回车键处理
+                if (mOnTextViewChangeListener != null) {
+                    int selectionStart = getSelectionStart();
+                    // 获取光标后的文本
+                    String text = getText().subSequence(selectionStart, length()).toString();
+                    // 截取光标前的文本并设置回TextView
+                    setText(getText().subSequence(0, selectionStart));
+                    // 调用监听器传递回车后剩余的文本
+                    mOnTextViewChangeListener.onEditTextEnter(mIndex + 1, text);
+                } else {
+                    Log.d(TAG, "OnTextViewChangeListener was not seted");
+                }
+                break;
+            default:
+                break;
+        }
+        return super.onKeyUp(keyCode, event);  // 默认处理
+    }
+}
+
+   @Override
+protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
+    // 检查是否有外部设置的文本改变监听器
+    if (mOnTextViewChangeListener != null) {
+        // 如果文本框失去焦点并且文本为空
+        if (!focused && TextUtils.isEmpty(getText())) {
+            // 调用文本改变监听器，传入索引和一个布尔值 'false' 表示文本为空
+            mOnTextViewChangeListener.onTextChange(mIndex, false);
+        } else {
+            // 否则，调用监听器，传入 'true' 表示文本不为空
+            mOnTextViewChangeListener.onTextChange(mIndex, true);
+        }
+    }
+    // 调用父类的 onFocusChanged 方法，以确保焦点改变时的默认行为（例如更新视觉效果）得到执行
+    super.onFocusChanged(focused, direction, previouslyFocusedRect);
+}
+
+@Override
+protected void onCreateContextMenu(ContextMenu menu) {
+    // 检查当前文本是否是 Spanned 类型，Spanned 是一个支持富文本的接口（例如超链接）
+    if (getText() instanceof Spanned) {
+        // 获取选中的文本范围
+        int selStart = getSelectionStart();
+        int selEnd = getSelectionEnd();
+
+        // 确定选中的最小和最大位置（防止选区反向）
+        int min = Math.min(selStart, selEnd);
+        int max = Math.max(selStart, selEnd);
+
+        // 获取选中的文本中所有的 URLSpan（超链接）
+        final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class);
+        // 如果选中的区域包含一个 URLSpan（即只有一个超链接）
+        if (urls.length == 1) {
+            // 默认的资源 ID
+            int defaultResId = 0;
+            // 遍历所有已知的 URL schema 类型（如 http://, https:// 等），匹配 URL
+            for(String schema: sSchemaActionResMap.keySet()) {
+                // 如果 URL 中包含某个 schema 类型
+                if(urls[0].getURL().indexOf(schema) >= 0) {
+                    // 根据匹配的 schema 获取对应的资源 ID
+                    defaultResId = sSchemaActionResMap.get(schema);
+                    break;
+                }
+            }
+
+            // 如果没有找到匹配的 schema，使用一个默认的字符串资源 ID
+            if (defaultResId == 0) {
+                defaultResId = R.string.note_link_other;
+            }
+
+            // 向上下文菜单中添加一个菜单项，默认文本为链接的类型描述
+            menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener(
+                    new OnMenuItemClickListener() {
+                        public boolean onMenuItemClick(MenuItem item) {
+                            // 在菜单项点击时触发超链接的点击事件
+                            urls[0].onClick(NoteEditText.this);
+                            return true;
+                        }
+                    });
+        }
+    }
+    // 调用父类的 onCreateContextMenu 方法，以确保默认的上下文菜单行为
+    super.onCreateContextMenu(menu);
+}
+}

NoteItemData.java

@@ -0,0 +1,306 @@
+/*
+ * 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 {
+    
+    // 定义了一个查询投影（Projection），包括从数据库中获取笔记的相关字段
+    static final String [] PROJECTION = new String [] {
+        NoteColumns.ID,                   // 笔记的唯一标识符
+        NoteColumns.ALERTED_DATE,         // 提醒日期
+        NoteColumns.BG_COLOR_ID,          // 背景颜色ID
+        NoteColumns.CREATED_DATE,         // 创建日期
+        NoteColumns.HAS_ATTACHMENT,       // 是否包含附件
+        NoteColumns.MODIFIED_DATE,        // 修改日期
+        NoteColumns.NOTES_COUNT,          // 笔记数量
+        NoteColumns.PARENT_ID,            // 父项ID
+        NoteColumns.SNIPPET,              // 笔记的摘要
+        NoteColumns.TYPE,                 // 笔记的类型
+        NoteColumns.WIDGET_ID,            // 小部件ID
+        NoteColumns.WIDGET_TYPE,          // 小部件类型
+    };
+
+    // 定义常量，表示数据库查询结果的每一列索引位置
+    private static final int ID_COLUMN                    = 0;  // 笔记ID
+    private static final int ALERTED_DATE_COLUMN          = 1;  // 提醒日期列索引
+    private static final int BG_COLOR_ID_COLUMN           = 2;  // 背景颜色列索引
+    private static final int CREATED_DATE_COLUMN          = 3;  // 创建日期列索引
+    private static final int HAS_ATTACHMENT_COLUMN        = 4;  // 附件标志列索引
+    private static final int MODIFIED_DATE_COLUMN         = 5;  // 修改日期列索引
+    private static final int NOTES_COUNT_COLUMN           = 6;  // 笔记数量列索引
+    private static final int PARENT_ID_COLUMN             = 7;  // 父项ID列索引
+    private static final int SNIPPET_COLUMN               = 8;  // 摘要列索引
+    private static final int TYPE_COLUMN                  = 9;  // 类型列索引
+    private static final int WIDGET_ID_COLUMN             = 10; // 小部件ID列索引
+    private static final int WIDGET_TYPE_COLUMN           = 11; // 小部件类型列索引
+
+    // 定义了类中各个属性，用来存储从数据库查询出来的笔记项数据
+    private long mId;                      // 笔记的ID
+    private long mAlertDate;               // 提醒时间
+    private int mBgColorId;                // 背景颜色ID
+    private long mCreatedDate;             // 创建时间
+    private boolean mHasAttachment;        // 是否有附件
+    private long mModifiedDate;            // 修改时间
+    private int mNotesCount;               // 笔记数量
+    private long mParentId;                // 父笔记ID
+    private String mSnippet;               // 笔记摘要
+    private int mType;                     // 笔记类型
+    private int mWidgetId;                 // 小部件ID
+    private int mWidgetType;               // 小部件类型
+    private String mName;                  // 笔记项的名称
+    private String mPhoneNumber;           // 笔记项关联的电话号码
+
+    // 以下是用于标记笔记在显示列表中的状态的布尔值
+    private boolean mIsLastItem;           // 是否是最后一个笔记项
+    private boolean mIsFirstItem;          // 是否是第一个笔记项
+    private boolean mIsOnlyOneItem;       // 是否是唯一的一个笔记项
+    private boolean mIsOneNoteFollowingFolder;  // 是否是跟随文件夹的第一个笔记
+    private boolean mIsMultiNotesFollowingFolder; // 是否是跟随文件夹的多个笔记
+
+    // 这里可以写上构造函数、getter和setter方法等，用于初始化和访问这些字段
+
+    // 构造函数，初始化 NoteItemData 对象，使用 Context 和 Cursor 作为输入参数
+public NoteItemData(Context context, Cursor cursor) {
+    // 从 Cursor 中获取 ID，存储到 mId
+    mId = cursor.getLong(ID_COLUMN);
+
+    // 获取警告日期（ALERTED_DATE_COLUMN），并存储为 mAlertDate
+    mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN);
+
+    // 获取背景颜色ID（BG_COLOR_ID_COLUMN），并存储为 mBgColorId
+    mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN);
+
+    // 获取创建日期（CREATED_DATE_COLUMN），并存储为 mCreatedDate
+    mCreatedDate = cursor.getLong(CREATED_DATE_COLUMN);
+
+    // 判断是否有附件（HAS_ATTACHMENT_COLUMN），存储为 mHasAttachment
+    mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0) ? true : false;
+
+    // 获取修改日期（MODIFIED_DATE_COLUMN），并存储为 mModifiedDate
+    mModifiedDate = cursor.getLong(MODIFIED_DATE_COLUMN);
+
+    // 获取笔记数量（NOTES_COUNT_COLUMN），并存储为 mNotesCount
+    mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN);
+
+    // 获取父项 ID（PARENT_ID_COLUMN），并存储为 mParentId
+    mParentId = cursor.getLong(PARENT_ID_COLUMN);
+
+    // 获取笔记的内容摘要（SNIPPET_COLUMN），并清除标记（如果存在）
+    mSnippet = cursor.getString(SNIPPET_COLUMN);
+    mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(NoteEditActivity.TAG_UNCHECKED, "");
+
+    // 获取笔记类型（TYPE_COLUMN），并存储为 mType
+    mType = cursor.getInt(TYPE_COLUMN);
+
+    // 获取小部件 ID（WIDGET_ID_COLUMN），并存储为 mWidgetId
+    mWidgetId = cursor.getInt(WIDGET_ID_COLUMN);
+
+    // 获取小部件类型（WIDGET_TYPE_COLUMN），并存储为 mWidgetType
+    mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN);
+
+    // 默认初始化手机号为空字符串
+    mPhoneNumber = "";
+
+    // 如果该笔记的父级 ID 是电话记录文件夹的 ID，获取电话记录的号码，并尝试获取联系人名称
+    if (mParentId == Notes.ID_CALL_RECORD_FOLDER) {
+        // 获取与该笔记 ID 对应的电话记录号码
+        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 中的位置
+    checkPostion(cursor);
+}
+
+// 检查该笔记在 Cursor 中的位置
+private void checkPostion(Cursor cursor) {
+    // 判断是否是 Cursor 中的最后一项
+    mIsLastItem = cursor.isLast() ? true : false;
+    
+    // 判断是否是 Cursor 中的第一项
+    mIsFirstItem = cursor.isFirst() ? true : false;
+    
+    // 判断 Cursor 中是否只有一项
+    mIsOnlyOneItem = (cursor.getCount() == 1);
+    
+    // 默认设置为 false，表示不是多个笔记跟随文件夹
+    mIsMultiNotesFollowingFolder = false;
+
+    // 默认设置为 false，表示不是一个笔记跟随文件夹
+    mIsOneNoteFollowingFolder = false;
+
+    // 如果当前笔记类型是普通笔记（TYPE_NOTE）并且不是第一项
+    if (mType == Notes.TYPE_NOTE && !mIsFirstItem) {
+        int position = cursor.getPosition(); // 获取当前笔记在 Cursor 中的位置
+
+        // 尝试将 Cursor 移动到上一项
+        if (cursor.moveToPrevious()) {
+            // 如果上一项是文件夹或系统类型的笔记，检查后续笔记的数量
+            if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER
+                    || cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) {
+                // 如果后续还有笔记，设置为多个笔记跟随文件夹
+                if (cursor.getCount() > (position + 1)) {
+                    mIsMultiNotesFollowingFolder = true;
+                } else {
+                    // 否则，设置为一个笔记跟随文件夹
+                    mIsOneNoteFollowingFolder = true;
+                }
+            }
+            // 如果无法移动到上一项，抛出异常
+            if (!cursor.moveToNext()) {
+                throw new IllegalStateException("cursor move to previous but can't move back");
+            }
+        }
+    }
+}
+
+
+    // 判断是否是单个笔记文件夹
+public boolean isOneFollowingFolder() {
+    return mIsOneNoteFollowingFolder; // 返回是否是“单个笔记文件夹”状态的布尔值
+}
+
+// 判断是否是多个笔记文件夹
+public boolean isMultiFollowingFolder() {
+    return mIsMultiNotesFollowingFolder; // 返回是否是“多个笔记文件夹”状态的布尔值
+}
+
+// 判断当前项是否是最后一个项
+public boolean isLast() {
+    return mIsLastItem; // 返回当前项是否是最后一个项的布尔值
+}
+
+// 获取笔记的名称
+public String getCallName() {
+    return mName; // 返回笔记名称
+}
+
+// 判断当前项是否是第一个项
+public boolean isFirst() {
+    return mIsFirstItem; // 返回当前项是否是第一个项的布尔值
+}
+
+// 判断是否是唯一一项
+public boolean isSingle() {
+    return mIsOnlyOneItem; // 返回是否是唯一一项的布尔值
+}
+
+// 获取笔记的ID
+public long getId() {
+    return mId; // 返回笔记的唯一标识符（ID）
+}
+
+// 获取笔记的提醒时间
+public long getAlertDate() {
+    return mAlertDate; // 返回笔记的提醒时间
+}
+
+// 获取笔记的创建时间
+public long getCreatedDate() {
+    return mCreatedDate; // 返回笔记的创建时间
+}
+
+// 判断笔记是否有附件
+public boolean hasAttachment() {
+    return mHasAttachment; // 返回笔记是否有附件的布尔值
+}
+
+// 获取笔记的修改时间
+public long getModifiedDate() {
+    return mModifiedDate; // 返回笔记的最后修改时间
+}
+
+// 获取笔记的背景颜色ID
+public int getBgColorId() {
+    return mBgColorId; // 返回笔记的背景颜色ID
+}
+
+// 获取父文件夹ID
+public long getParentId() {
+    return mParentId; // 返回笔记的父文件夹ID
+}
+
+// 获取笔记中的内容数量
+public int getNotesCount() {
+    return mNotesCount; // 返回笔记的内容数量
+}
+
+// 获取父文件夹的ID（重复调用了getParentId方法，功能与getParentId相同）
+public long getFolderId () {
+    return mParentId; // 返回笔记的文件夹ID（等同于getParentId）
+}
+
+// 获取笔记的类型
+public int getType() {
+    return mType; // 返回笔记的类型ID
+}
+
+// 获取笔记的widget类型
+public int getWidgetType() {
+    return mWidgetType; // 返回笔记的widget类型ID
+}
+
+// 获取笔记的widget ID
+public int getWidgetId() {
+    return mWidgetId; // 返回笔记的widget ID
+}
+
+// 获取笔记的摘要内容
+public String getSnippet() {
+    return mSnippet; // 返回笔记的摘要信息
+}
+
+// 判断笔记是否设置了提醒
+public boolean hasAlert() {
+    return (mAlertDate > 0); // 如果提醒日期大于0，说明有提醒
+}
+
+// 判断是否是通话记录
+public boolean isCallRecord() {
+    return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber)); 
+    // 判断父文件夹ID是否为通话记录文件夹，且手机号码不为空
+}
+
+// 获取笔记类型，从数据库Cursor中提取笔记类型
+public static int getNoteType(Cursor cursor) {
+    return cursor.getInt(TYPE_COLUMN); // 从Cursor中获取笔记类型字段的值
+}
+}

NotesListAdapter.java

@@ -0,0 +1,215 @@
+/*
+ * 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;
+
+// 导入Android相关的库，用于处理数据库查询和视图的适配
+import android.content.Context;  // 用于处理应用程序上下文
+import android.database.Cursor;  // 用于数据库查询的游标
+import android.util.Log;  // 用于记录日志
+import android.view.View;  // 用于视图组件
+import android.view.ViewGroup;  // 用于视图容器
+import android.widget.CursorAdapter;  // 用于适配器，绑定数据库游标到视图
+
+// 导入与笔记相关的类
+import net.micode.notes.data.Notes;  // 用于操作笔记数据
+
+// 导入集合类，用于数据存储和处理
+import java.util.Collection;  // 用于操作一组对象
+import java.util.HashMap;  // 用于存储键值对
+import java.util.HashSet;  // 用于存储唯一元素集合
+import java.util.Iterator;  // 用于遍历集合元素
+
+
+// 自定义适配器，用于显示笔记列表
+public class NotesListAdapter extends CursorAdapter {
+    private static final String TAG = "NotesListAdapter";  // 日志标签
+    private Context mContext;  // 上下文对象，用于访问应用资源
+    private HashMap<Integer, Boolean> mSelectedIndex;  // 用于存储选中项的索引和状态
+    private int mNotesCount;  // 当前笔记数量
+    private boolean mChoiceMode;  // 是否处于选择模式
+
+    // 内部类，用于存储小部件相关的属性
+    public static class AppWidgetAttribute {
+        public int widgetId;  // 小部件的 ID
+        public int widgetType;  // 小部件的类型
+    };
+
+    // 构造函数，初始化适配器
+    public NotesListAdapter(Context context) {
+        super(context, null);  // 调用父类构造函数，传入上下文和空游标
+        mSelectedIndex = new HashMap<Integer, Boolean>();  // 初始化存储选中项的 HashMap
+        mContext = context;  // 设置上下文
+        mNotesCount = 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 对象
+            NoteItemData itemData = new NoteItemData(context, cursor);
+            // 将数据绑定到视图中，并考虑选择模式和选中状态
+            ((NotesListItem) view).bind(context, itemData, mChoiceMode, 
+                                         isSelectedItem(cursor.getPosition()));
+        }
+    }
+
+    // 设置指定位置的选中状态
+    public void setCheckedItem(final int position, final boolean checked) {
+        mSelectedIndex.put(position, checked);  // 更新选中状态
+        notifyDataSetChanged();  // 通知数据发生变化，刷新视图
+    }
+
+    // 判断是否处于选择模式
+    public boolean isInChoiceMode() {
+        return mChoiceMode;
+    }
+
+    // 设置是否进入选择模式
+    public void setChoiceMode(boolean mode) {
+        mSelectedIndex.clear();  // 清除所有选中状态
+        mChoiceMode = mode;  // 设置选择模式
+    }
+
+    // 选择所有项目或取消选择
+    public void selectAll(boolean checked) {
+        Cursor cursor = getCursor();  // 获取当前游标
+        for (int i = 0; i < getCount(); i++) {  // 遍历所有项
+            if (cursor.moveToPosition(i)) {  // 移动游标到指定位置
+                // 如果该项是笔记类型
+                if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) {
+                    setCheckedItem(i, checked);  // 更新选中状态
+                }
+            }
+        }
+    }
+}
+
+   // 获取已选择的项的ID集合
+public HashSet<Long> getSelectedItemIds() {
+    HashSet<Long> itemSet = new HashSet<Long>();  // 创建一个HashSet来存储选中的ID
+    // 遍历所有选中的项的索引
+    for (Integer position : mSelectedIndex.keySet()) {
+        if (mSelectedIndex.get(position) == true) {  // 判断该项是否被选中
+            Long id = getItemId(position);  // 获取该项的ID
+            if (id == Notes.ID_ROOT_FOLDER) {  // 如果ID为根文件夹ID，记录日志并跳过该项
+                Log.d(TAG, "Wrong item id, should not happen");
+            } else {
+                itemSet.add(id);  // 将ID添加到itemSet中
+            }
+        }
+    }
+    return itemSet;  // 返回所有选中项的ID集合
+}
+
+// 获取已选择的小部件（AppWidget）属性集合
+public HashSet<AppWidgetAttribute> getSelectedWidget() {
+    HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>();  // 创建一个HashSet来存储选中的小部件属性
+    // 遍历所有选中的项的索引
+    for (Integer position : mSelectedIndex.keySet()) {
+        if (mSelectedIndex.get(position) == true) {  // 判断该项是否被选中
+            Cursor c = (Cursor) getItem(position);  // 获取该项的Cursor对象
+            if (c != null) {  // 如果Cursor不为空，则处理该项
+                AppWidgetAttribute widget = new AppWidgetAttribute();  // 创建一个AppWidgetAttribute对象
+                NoteItemData item = new NoteItemData(mContext, c);  // 使用Cursor对象初始化NoteItemData
+                widget.widgetId = item.getWidgetId();  // 获取小部件ID
+                widget.widgetType = item.getWidgetType();  // 获取小部件类型
+                itemSet.add(widget);  // 将小部件属性添加到itemSet中
+                // 注意：不要在这里关闭Cursor，由适配器负责关闭
+            } else {
+                Log.e(TAG, "Invalid cursor");  // 如果Cursor为空，记录错误日志并返回null
+                return 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;
+    // 遍历选中项状态，如果为true则计数
+    while (iter.hasNext()) {
+        if (true == iter.next()) {
+            count++;
+        }
+    }
+    return count;  // 返回选中项的数量
+}
+
+// 判断是否所有项都被选中
+public boolean isAllSelected() {
+    int checkedCount = getSelectedCount();  // 获取已选中项的数量
+    return (checkedCount != 0 && checkedCount == mNotesCount);  // 如果已选中项的数量等于总项数，则返回true
+}
+
+// 判断某个位置的项是否被选中
+public boolean isSelectedItem(final int position) {
+    if (null == mSelectedIndex.get(position)) {
+        return false;  // 如果该位置没有被选中，返回false
+    }
+    return mSelectedIndex.get(position);  // 返回该位置的选中状态
+
+
+   @Override
+protected void onContentChanged() {
+    // 当内容发生变化时调用，通常用于刷新UI或更新数据
+    super.onContentChanged();
+    // 重新计算笔记的数量
+    calcNotesCount();
+}
+
+@Override
+public void changeCursor(Cursor cursor) {
+    // 当游标（Cursor）发生变化时调用，通常在数据更新时触发
+    super.changeCursor(cursor);
+    // 重新计算笔记的数量
+    calcNotesCount();
+}
+
+private void calcNotesCount() {
+    // 初始化笔记数量为0
+    mNotesCount = 0;
+    // 遍历当前的数据项，假设这些数据项是通过Cursor获取的
+    for (int i = 0; i < getCount(); i++) {
+        // 获取当前位置的Cursor对象
+        Cursor c = (Cursor) getItem(i);
+        if (c != null) {
+            // 如果当前游标存在，检查数据项类型是否为笔记类型
+            if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) {
+                // 如果是笔记类型，增加笔记数量
+                mNotesCount++;
+            }
+        } else {
+            // 如果游标为null，打印错误日志并返回
+            Log.e(TAG, "Invalid cursor");
+            return;
+        }
+      }
+   }
+}

NotesListItem.java

@@ -0,0 +1,153 @@
+/*
+ * 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;
+
+// 引入Android库和自定义类、工具类
+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;  // 引用资源ID文件
+import net.micode.notes.data.Notes;  // Notes类，表示笔记数据
+import net.micode.notes.tool.DataUtils;  // 数据工具类，可能用于处理或转换数据
+import net.micode.notes.tool.ResourceParser.NoteItemBgResources;  // 资源解析器，用于获取笔记项背景资源
+
+
+public class NotesListItem extends LinearLayout {
+    // 定义UI控件
+    private ImageView mAlert;        // 用于显示警告图标
+    private TextView mTitle;         // 用于显示标题
+    private TextView mTime;          // 用于显示时间
+    private TextView mCallName;      // 用于显示来电名称
+    private NoteItemData mItemData; // 用于存储与该视图项相关的数据
+    private CheckBox mCheckBox;     // 用于显示复选框，支持选择模式
+
+    // 构造函数，初始化视图
+    public NotesListItem(Context context) {
+        super(context);  // 调用父类LinearLayout的构造函数
+        inflate(context, R.layout.note_item, this);  // 从布局文件加载视图
+        mAlert = (ImageView) findViewById(R.id.iv_alert_icon);  // 绑定警告图标
+        mTitle = (TextView) findViewById(R.id.tv_title);        // 绑定标题TextView
+        mTime = (TextView) findViewById(R.id.tv_time);          // 绑定时间TextView
+        mCallName = (TextView) findViewById(R.id.tv_name);      // 绑定来电名称TextView
+        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;  // 存储绑定的数据
+        // 如果数据ID为通话记录文件夹ID
+        if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
+            mCallName.setVisibility(View.GONE);  // 隐藏来电名称TextView
+            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);  // 设置警告图标为通话记录图标
+        }
+        // 如果数据的父ID是通话记录文件夹ID
+        else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
+            mCallName.setVisibility(View.VISIBLE);  // 显示来电名称TextView
+            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);  // 隐藏来电名称TextView
+            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) {
+    // 获取背景颜色的ID，根据 NoteItemData 对象的不同状态来设置不同的背景资源
+    int id = data.getBgColorId();
+
+    // 判断数据类型，如果是普通笔记（TYPE_NOTE）
+    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;
+    }
+}

NotesPreferenceActivity.java

@@ -0,0 +1,568 @@
+/*
+ * 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;
+import android.accounts.AccountManager;
+
+// 导入用于操作 Android 应用中的 ActionBar（顶部导航栏）功能
+import android.app.ActionBar;
+
+// 导入用于显示和管理弹出对话框的类
+import android.app.AlertDialog;
+
+// 导入用于接收广播消息的类
+import android.content.BroadcastReceiver;
+
+// 导入用于在 ContentProvider 中存储和插入数据的类
+import android.content.ContentValues;
+
+// 导入 Android 应用的上下文类，用于访问全局应用信息和资源
+import android.content.Context;
+
+// 导入用于显示和管理对话框按钮点击事件的接口
+import android.content.DialogInterface;
+
+// 导入用于启动新活动或广播的 Intent 类
+import android.content.Intent;
+
+// 导入用于过滤广播消息的 IntentFilter 类
+import android.content.IntentFilter;
+
+// 导入用于访问和操作应用设置的类
+import android.content.SharedPreferences;
+
+// 导入用于传递数据和保存状态的类
+import android.os.Bundle;
+
+// 导入与偏好设置界面相关的类，用于创建设置项和响应设置点击事件
+import android.preference.Preference;
+import android.preference.Preference.OnPreferenceClickListener;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceCategory;
+
+// 导入用于文本操作的工具类，提供字符串处理方法
+import android.text.TextUtils;
+
+// 导入用于日期时间格式化的工具类
+import android.text.format.DateFormat;
+
+// 导入用于视图管理和菜单操作的类
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+
+// 导入常用的 UI 控件类，如按钮、文本视图和弹出提示框
+import android.widget.Button;
+import android.widget.TextView;
+import android.widget.Toast;
+
+// 导入应用的资源文件引用类，包含应用的所有资源（如字符串、布局等）
+import net.micode.notes.R;
+
+// 导入与笔记相关的数据模型类，定义了笔记数据结构
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+
+// 导入与 Google 任务同步服务相关的类，用于同步任务数据
+import net.micode.notes.gtask.remote.GTaskSyncService;
+
+
+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;
+
+    // 用于接收同步服务广播的接收器
+    private GTaskReceiver mReceiver;
+
+    // 存储原始账户列表
+    private Account[] mOriAccounts;
+
+    // 标记是否添加了新账户
+    private boolean mHasAddedAccount;
+
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        // 使用应用图标作为导航栏的“向上”按钮
+        getActionBar().setDisplayHomeAsUpEnabled(true);
+
+        // 加载偏好设置界面资源
+        addPreferencesFromResource(R.xml.preferences);
+
+        // 获取账户设置类别对象
+        mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);
+
+        // 初始化 GTaskReceiver 接收器，用于接收同步相关广播
+        mReceiver = new GTaskReceiver();
+
+        // 创建 IntentFilter，注册 GTaskSyncService 广播
+        IntentFilter filter = new IntentFilter();
+        filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME);
+        registerReceiver(mReceiver, filter);
+
+        // 初始化原始账户列表为空
+        mOriAccounts = null;
+
+        // 加载设置界面的头部视图
+        View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null);
+        getListView().addHeaderView(header, null, true);
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+
+        // 如果添加了新账户，则尝试自动设置同步账户
+        if (mHasAddedAccount) {
+            // 获取当前所有的 Google 账户
+            Account[] accounts = getGoogleAccounts();
+
+            // 如果原始账户列表不为空且当前账户数量大于原始账户数量
+            if (mOriAccounts != null && accounts.length > mOriAccounts.length) {
+                // 遍历当前账户列表，查找新增的账户
+                for (Account accountNew : accounts) {
+                    boolean found = false;
+
+                    // 遍历原始账户列表，检查新增账户是否已存在
+                    for (Account accountOld : mOriAccounts) {
+                        // 如果找到匹配的账户，则标记为已找到
+                        if (TextUtils.equals(accountOld.name, accountNew.name)) {
+                            found = true;
+                            break;
+                        }
+                    }
+
+                    // 如果新增账户没有在原始账户列表中找到，则设置为同步账户
+                    if (!found) {
+                        setSyncAccount(accountNew.name);
+                        break;
+                    }
+                }
+            }
+        }
+        refreshUI();
+    }
+
+@Override
+protected void onDestroy() {
+    // 如果 mReceiver 已初始化，则注销广播接收器，防止内存泄漏
+    if (mReceiver != null) {
+        unregisterReceiver(mReceiver);
+    }
+    // 调用父类的 onDestroy，确保正确销毁 Activity
+    super.onDestroy();
+}
+
+
+   private void loadAccountPreference() {
+    // 清空当前账户类别中的所有项
+    mAccountCategory.removeAll();
+
+    // 创建一个新的 Preference 用于账户设置
+    Preference accountPref = new Preference(this);
+
+    // 获取当前同步账户的名称
+    final String defaultAccount = getSyncAccountName(this);
+
+    // 设置账户项的标题和摘要
+    accountPref.setTitle(getString(R.string.preferences_account_title));
+    accountPref.setSummary(getString(R.string.preferences_account_summary));
+
+    // 设置点击该项时的处理逻辑
+    accountPref.setOnPreferenceClickListener(new OnPreferenceClickListener() {
+        public boolean onPreferenceClick(Preference preference) {
+            // 如果当前没有进行同步操作
+            if (!GTaskSyncService.isSyncing()) {
+                if (TextUtils.isEmpty(defaultAccount)) {
+                    // 如果没有设置账户，则首次设置账户，弹出选择账户对话框
+                    showSelectAccountAlertDialog();
+                } else {
+                    // 如果已有账户，弹出更改账户的风险提示对话框
+                    showChangeAccountConfirmAlertDialog();
+                }
+            } else {
+                // 如果正在同步，提示用户无法更改账户
+                Toast.makeText(NotesPreferenceActivity.this,
+                        R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
+                        .show();
+            }
+            return true;
+        }
+    });
+
+    // 将账户设置项添加到账户类别中
+    mAccountCategory.addPreference(accountPref);
+}
+
+   private void loadSyncButton() {
+    // 获取同步按钮和最后同步时间的文本视图
+    Button syncButton = (Button) findViewById(R.id.preference_sync_button);
+    TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
+
+    // 根据同步状态设置按钮文本和点击事件
+    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);
+        }
+    }
+}
+
+
+private void refreshUI() {
+    loadAccountPreference();
+    loadSyncButton();
+}
+
+
+    private void showSelectAccountAlertDialog() {
+    AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
+
+    // 设置自定义的对话框标题
+    View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
+    TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
+    titleTextView.setText(getString(R.string.preferences_dialog_select_account_title));  // 设置标题文本
+    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[] 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[index++] = account.name;  // 将账户名称添加到选项列表
+        }
+
+        // 设置单选框列表
+        dialogBuilder.setSingleChoiceItems(items, checkedItem,
+                new DialogInterface.OnClickListener() {
+                    public void onClick(DialogInterface dialog, int which) {
+                        // 选择账户后，设置同步账户，并刷新 UI
+                        setSyncAccount(itemMapping[which].toString());
+                        dialog.dismiss();
+                        refreshUI();  // 刷新界面
+                    }
+                });
+    }
+
+    // 添加“添加账户”按钮
+    View addAccountView = LayoutInflater.from(this).inflate(R.layout.add_account_text, null);
+    dialogBuilder.setView(addAccountView);  // 将其添加到对话框中
+
+    // 显示对话框
+    final AlertDialog dialog = dialogBuilder.show();
+
+    // 设置“添加账户”点击事件
+    addAccountView.setOnClickListener(new View.OnClickListener() {
+        public void onClick(View v) {
+            mHasAddedAccount = true;
+            // 打开添加账户设置界面
+            Intent intent = new Intent("android.settings.ADD_ACCOUNT_SETTINGS");
+            intent.putExtra(AUTHORITIES_FILTER_KEY, new String[] { "gmail-ls" });
+            startActivityForResult(intent, -1);  // 启动账户添加页面
+            dialog.dismiss();  // 关闭当前对话框
+        }
+    });
+}
+
+
+        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 titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
+    titleTextView.setText(getString(R.string.preferences_dialog_change_account_title,
+            getSyncAccountName(this)));  // 显示当前同步账户的名称
+
+    // 获取自定义标题视图中的副标题文本控件，并设置其显示的警告信息
+    TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
+    subtitleTextView.setText(getString(R.string.preferences_dialog_change_account_warn_msg));  // 设置警告信息
+
+    // 将自定义的标题视图设置为对话框的标题
+    dialogBuilder.setCustomTitle(titleView);
+
+    // 创建对话框的菜单选项
+    CharSequence[] menuItemArray = new CharSequence[] {
+            getString(R.string.preferences_menu_change_account),  // 更改账户选项
+            getString(R.string.preferences_menu_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账户，"com.google" 表示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();
+
+        // 清除上次同步时间（将其设置为0）
+        setLastSyncTime(this, 0);
+
+        // 清除与Google任务相关的本地信息
+        new Thread(new Runnable() {
+            public void run() {
+                // 创建一个 ContentValues 对象来更新 Google 任务相关的字段
+                ContentValues values = new ContentValues();
+                values.put(NoteColumns.GTASK_ID, "");  // 清除任务ID
+                values.put(NoteColumns.SYNC_ID, 0);    // 清除同步ID
+
+                // 更新 Notes 内容提供者中的数据，清除与同步相关的信息
+                getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
+            }
+        }).start();
+
+        // 弹出提示，告知用户账户设置成功
+        Toast.makeText(NotesPreferenceActivity.this,
+                getString(R.string.preferences_toast_success_set_accout, account),
+                Toast.LENGTH_SHORT).show();
+    }
+}
+
+// 删除同步账户
+private void removeSyncAccount() {
+    // 获取 SharedPreferences，删除同步账户设置
+    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();
+
+    // 清除与Google任务相关的本地信息
+    new Thread(new Runnable() {
+        public void run() {
+            // 创建一个 ContentValues 对象来更新 Google 任务相关的字段
+            ContentValues values = new ContentValues();
+            values.put(NoteColumns.GTASK_ID, "");  // 清除任务ID
+            values.put(NoteColumns.SYNC_ID, 0);    // 清除同步ID
+
+            // 更新 Notes 内容提供者中的数据，清除与同步相关的信息
+            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 的编辑器，用于修改存储的数据
+    SharedPreferences.Editor editor = settings.edit();
+    // 将时间值存储到 PREFERENCE_LAST_SYNC_TIME 键中
+    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);
+}
+
+// 广播接收器，用于接收来自 GTaskSyncService 的广播消息
+private class GTaskReceiver extends BroadcastReceiver {
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        // 刷新UI显示
+        refreshUI();
+
+        // 检查是否正在同步
+        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()) {
+        // 点击返回按钮，返回到 NotesListActivity
+        case android.R.id.home:
+            // 创建返回 Intent，设置标志位清除栈顶活动
+            Intent intent = new Intent(this, NotesListActivity.class);
+            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+            // 启动 NotesListActivity
+            startActivity(intent);
+            return true;
+        default:
+            // 如果没有匹配的菜单项，返回 false
+            return false;
+    }
+  }
+}