006-2.cpp

@@ -1,79 +0,0 @@
-#include<stdio.h>
-#include<stdlib.h>
-void chiocesort(int arr[]) {
-	for (int i = 0; i < 29; i++) {
-		int index = i;
-		for (int j = i; j < 30; j++) {
-			if (arr[j] < arr[index]){
-				index = j;
-			}
-		}
-		int temp = arr[i];
-		arr[i] = arr[index];
-		arr[index] = temp;
-		for (int k = 0; k < 30; k++) {
-			printf("%d ", arr[k]);
-		}
-		printf("\n");
-	}
-}
-void adjustHeap(int arr[], int n, int root) {
-    int parent = root;       
-	int child = root * 2 + 1;
-	while (child < n) {
-		if ((child + 1) < n && arr[child] < arr[child + 1]) {
-			child++;
-		}
-		if (arr[parent] < arr[child]) {
-			int temp = arr[parent];
-			arr[parent] = arr[child];
-			arr[child] = temp;
-			parent = child;
-			child = parent * 2 + 1;
-		}
-		else 
-		{
-			break;
-		}
-	}
-}
-// 堆排序（升序）
-void heapSort(int arr[], int n) {
-	//建堆
-	printf("建堆过程\n");
-    for (int i = n / 2 - 1; i >= 0; i--) {
-        adjustHeap(arr, n, i);
-		for (int k = 0; k < 30; k++) {
-			printf("%d ", arr[k]);
-		}
-		printf("\n");
-    }
-	printf("调整过程\n");
-	for (int i = n - 1; i >= 0; i--) {
-		int temp = arr[i];
-		arr[i] = arr[0];
-		arr[0] = temp;
-		adjustHeap(arr, i, 0);
-		for (int k = 0; k < 30; k++) {
-			printf("%d ", arr[k]);
-		}
-		printf("\n");
-	}
-}
-int main() {
-	int arr[30];
-	int arr1[30];
-	printf("原始数组\n");
-	for (int i = 0; i < 30; i++) {
-		arr1[i] = rand() % 100;
-		arr[i] = arr1[i];
-		printf("%d ",arr[i]);
-	}
-	printf("\n");
-	printf("选择排序\n");
-	chiocesort(arr);
-	printf("\n");
-	printf("heap\n");
-	heapSort(arr1, 30);
-	return 0;
-}

README.md

@@ -1,2 +0,0 @@
-# rjgc
-

ui/AlarmAlertActivity.java

@@ -0,0 +1,248 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.ui;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.content.DialogInterface.OnDismissListener;
+import android.content.Intent;
+import android.media.AudioManager;
+import android.media.MediaPlayer;
+import android.media.RingtoneManager;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.PowerManager;
+import android.provider.Settings;
+import android.view.Window;
+import android.view.WindowManager;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.tool.DataUtils;
+
+import java.io.IOException;
+
+
+/**
+ * 闹钟提醒活动 - 笔记定时提醒功能
+ *
+ * 【模块功能】
+ * 1. 当笔记设置的提醒时间到达时，自动弹出提醒对话框
+ * 2. 支持在锁屏状态下显示提醒界面（唤醒屏幕）
+ * 3. 播放系统默认的闹钟铃声提醒用户
+ * 4. 显示笔记内容摘要（最多60个字符）
+ * 5. 提供两种操作选项：
+ *    - "确定"：关闭提醒并停止闹钟
+ *    - "查看"：跳转到笔记编辑页面查看完整内容（仅屏幕开启时显示）
+ *
+ * 【使用场景】
+ * - 用户为笔记设置了提醒时间后，系统在指定时间触发此活动
+ * - 无论应用是否在前台运行，都能正常显示提醒
+ * - 支持锁屏状态下唤醒屏幕并显示提醒
+ *
+ * 【技术要点】
+ * - 使用WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED实现锁屏显示
+ * - 使用MediaPlayer播放系统闹钟铃声
+ * - 通过Intent从AlarmReceiver接收笔记ID
+ * - 实现OnClickListener和OnDismissListener处理用户交互
+ *
+ * 【生命周期】
+ * 1. onCreate: 初始化界面、获取笔记数据、播放闹钟声音
+ * 2. onClick: 处理用户点击按钮事件
+ * 3. onDismiss: 对话框关闭时停止闹钟并结束活动
+ *
+ * @author MiCode Open Source Community
+ * @modified 2026-05-07 (Complete Chinese Documentation & Bug Fix)
+ * @version 1.0
+ * @see AlarmReceiver 闹钟广播接收器
+ * @see AlarmInitReceiver 闹钟初始化接收器
+ * @see NoteEditActivity 笔记编辑活动
+ */
+public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener {
+
+    // 笔记ID
+    private long mNoteId;
+
+    // 笔记内容摘要
+    private String mSnippet;
+
+    // 摘要最大显示长度
+    private static final int SNIPPET_PREW_MAX_LEN = 60;
+
+    // 媒体播放器，用于播放闹钟声音
+    MediaPlayer mPlayer;
+
+    /**
+     * 活动创建时的初始化方法
+     * 设置窗口标志、获取笔记数据、显示对话框并播放闹钟声音
+     *
+     * @param savedInstanceState 保存的实例状态
+     */
+    @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 {
+            // 从Intent的URI路径中提取笔记ID
+            mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1));
+            // 根据笔记ID获取内容摘要
+            mSnippet = DataUtils.getSnippetById(this.getContentResolver(), mNoteId);
+            // 如果摘要过长，截取前60个字符并添加省略提示
+            mSnippet = mSnippet.length() > SNIPPET_PREW_MAX_LEN ? mSnippet.substring(0,
+                    SNIPPET_PREW_MAX_LEN) + getResources().getString(R.string.notelist_string_info)
+                    : mSnippet;
+        } catch (IllegalArgumentException e) {
+            // URI格式错误，打印异常并退出
+            e.printStackTrace();
+            return;
+        }
+
+        mPlayer = new MediaPlayer();
+        // 验证笔记是否在数据库中可见
+        if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) {
+            showActionDialog();
+            playAlarmSound();
+        } else {
+            // 笔记不存在或不可见，直接关闭活动
+            finish();
+        }
+    }
+
+    /**
+     * 检查屏幕是否处于开启状态
+     *
+     * @return true表示屏幕已开启，false表示屏幕关闭
+     */
+    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 {
+            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);
+    }
+
+    /**
+     * 处理对话框按钮点击事件
+     *
+     * @param dialog 对话框对象
+     * @param which 被点击的按钮标识
+     */
+    public void onClick(DialogInterface dialog, int which) {
+        switch (which) {
+            case DialogInterface.BUTTON_NEGATIVE:
+                // 点击"查看"按钮，跳转到笔记编辑页面
+                Intent intent = new Intent(this, NoteEditActivity.class);
+                intent.setAction(Intent.ACTION_VIEW);
+                intent.putExtra(Intent.EXTRA_UID, mNoteId);
+                startActivity(intent);
+                break;
+            default:
+                // 点击"确定"按钮，不做额外操作，由onDismiss处理
+                break;
+        }
+    }
+
+    /**
+     * 对话框关闭时的回调方法
+     * 停止闹钟声音并结束当前活动
+     *
+     * @param dialog 对话框对象
+     */
+    public void onDismiss(DialogInterface dialog) {
+        stopAlarmSound();
+        finish();
+    }
+
+    /**
+     * 停止闹钟声音并释放媒体播放器资源
+     * 防止内存泄漏
+     */
+    private void stopAlarmSound() {
+        if (mPlayer != null) {
+            mPlayer.stop();
+            mPlayer.release();
+            mPlayer = null;
+        }
+    }
+}

ui/AlarmInitReceiver.java

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.ui;
+
+import android.app.AlarmManager;
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.ContentUris;
+import android.content.Context;
+import android.content.Intent;
+import android.database.Cursor;
+
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+
+
+// ... existing code ...
+
+/**
+ * 闹钟初始化广播接收器
+ *
+ * 【功能说明】
+ * 1. 在系统启动或应用重启时恢复所有未触发的闹钟
+ * 2. 查询数据库中所有设置了提醒日期且尚未到期的笔记
+ * 3. 为每个笔记重新注册系统闹钟服务
+ */
+public class AlarmInitReceiver extends BroadcastReceiver {
+
+    // 查询投影：只需要ID和提醒日期两个字段
+    private static final String [] PROJECTION = new String [] {
+            NoteColumns.ID,
+            NoteColumns.ALERTED_DATE
+    };
+
+    private static final int COLUMN_ID                = 0;
+    private static final int COLUMN_ALERTED_DATE      = 1;
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        long currentDate = System.currentTimeMillis();
+        // 查询所有提醒日期大于当前时间且类型为普通笔记的记录
+        Cursor c = context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
+                PROJECTION,
+                NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE,
+                new String[] { String.valueOf(currentDate) },
+                null);
+
+        if (c != null) {
+            if (c.moveToFirst()) {
+                do {
+                    long alertDate = c.getLong(COLUMN_ALERTED_DATE);
+                    // 创建用于触发闹钟的Intent
+                    Intent sender = new Intent(context, AlarmReceiver.class);
+                    sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(COLUMN_ID)));
+                    PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, 0);
+                    // 获取系统闹钟管理器并设置闹钟
+                    AlarmManager alermManager = (AlarmManager) context
+                            .getSystemService(Context.ALARM_SERVICE);
+                    alermManager.set(AlarmManager.RTC_WAKEUP, alertDate, pendingIntent);
+                } while (c.moveToNext());
+            }
+            c.close();
+        }
+    }
+}

ui/AlarmReceiver.java

@@ -0,0 +1,43 @@
+/*
+ * 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;
+
+// ... existing code ...
+
+/**
+ * 闹钟触发广播接收器
+ *
+ * 【功能说明】
+ * 1. 接收系统闹钟服务发出的广播
+ * 2. 启动AlarmAlertActivity显示提醒对话框
+ * 3. 使用NEW_TASK标志确保在没有任务栈的情况下也能正常启动
+ */
+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);
+        context.startActivity(intent);
+    }
+}
+

ui/DateTimePicker.java

@@ -0,0 +1,528 @@
+/*
+ * 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;
+
+// ... existing code ...
+
+/**
+ * 日期时间选择器组件
+ *
+ * 【功能说明】
+ * 1. 自定义FrameLayout，集成日期和时间选择功能
+ * 2. 支持24小时制和12小时制（AM/PM）切换
+ * 3. 包含日期、小时、分钟、AM/PM四个NumberPicker组件
+ * 4. 自动处理日期进位（如分钟从59到0时小时加1）
+ * 5. 提供日期时间变化监听接口
+ * 6. 显示最近一周的日期供选择
+ */
+public class DateTimePicker extends FrameLayout {
+
+    private static final boolean DEFAULT_ENABLE_STATE = true;
+
+    private static final int HOURS_IN_HALF_DAY = 12;
+    private static final int HOURS_IN_ALL_DAY = 24;
+    private static final int DAYS_IN_ALL_WEEK = 7;
+    private static final int DATE_SPINNER_MIN_VAL = 0;
+    private static final int DATE_SPINNER_MAX_VAL = DAYS_IN_ALL_WEEK - 1;
+    private static final int HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW = 0;
+    private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23;
+    private static final int HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW = 1;
+    private static final int HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW = 12;
+    private static final int MINUT_SPINNER_MIN_VAL = 0;
+    private static final int MINUT_SPINNER_MAX_VAL = 59;
+    private static final int AMPM_SPINNER_MIN_VAL = 0;
+    private static final int AMPM_SPINNER_MAX_VAL = 1;
+
+    private final NumberPicker mDateSpinner;
+    private final NumberPicker mHourSpinner;
+    private final NumberPicker mMinuteSpinner;
+    private final NumberPicker mAmPmSpinner;
+    private Calendar mDate;
+
+    private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];
+
+    private boolean mIsAm;
+
+    private boolean mIs24HourView;
+
+    private boolean mIsEnabled = DEFAULT_ENABLE_STATE;
+
+    private boolean mInitialising;
+
+    private OnDateTimeChangedListener mOnDateTimeChangedListener;
+
+    /**
+     * 日期变化监听器
+     * 当日期选择器值改变时，更新日期并触发回调
+     */
+    private NumberPicker.OnValueChangeListener mOnDateChangedListener = new NumberPicker.OnValueChangeListener() {
+        @Override
+        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+            mDate.add(Calendar.DAY_OF_YEAR, newVal - oldVal);
+            updateDateControl();
+            onDateTimeChanged();
+        }
+    };
+
+    /**
+     * 小时变化监听器
+     * 处理小时变化时的日期进位和AM/PM切换
+     */
+    private NumberPicker.OnValueChangeListener mOnHourChangedListener = new NumberPicker.OnValueChangeListener() {
+        @Override
+        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+            boolean isDateChanged = false;
+            Calendar cal = Calendar.getInstance();
+            if (!mIs24HourView) {
+                // 12小时制下的日期进位逻辑
+                if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) {
+                    cal.setTimeInMillis(mDate.getTimeInMillis());
+                    cal.add(Calendar.DAY_OF_YEAR, 1);
+                    isDateChanged = true;
+                } else if (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
+                    cal.setTimeInMillis(mDate.getTimeInMillis());
+                    cal.add(Calendar.DAY_OF_YEAR, -1);
+                    isDateChanged = true;
+                }
+                if (oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY ||
+                        oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
+                    mIsAm = !mIsAm;
+                    updateAmPmControl();
+                }
+            } else {
+                // 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;
+            if (oldVal == maxValue && newVal == minValue) {
+                offset += 1;
+            } else if (oldVal == minValue && newVal == maxValue) {
+                offset -= 1;
+            }
+            if (offset != 0) {
+                mDate.add(Calendar.HOUR_OF_DAY, offset);
+                mHourSpinner.setValue(getCurrentHour());
+                updateDateControl();
+                int newHour = getCurrentHourOfDay();
+                if (newHour >= HOURS_IN_HALF_DAY) {
+                    mIsAm = false;
+                    updateAmPmControl();
+                } else {
+                    mIsAm = true;
+                    updateAmPmControl();
+                }
+            }
+            mDate.set(Calendar.MINUTE, newVal);
+            onDateTimeChanged();
+        }
+    };
+
+    /**
+     * AM/PM变化监听器
+     * 切换上午/下午时调整小时值
+     */
+    private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() {
+        @Override
+        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+            mIsAm = !mIsAm;
+            if (mIsAm) {
+                mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY);
+            } else {
+                mDate.add(Calendar.HOUR_OF_DAY, HOURS_IN_HALF_DAY);
+            }
+            updateAmPmControl();
+            onDateTimeChanged();
+        }
+    };
+
+    /**
+     * 日期时间变化监听器接口
+     */
+    public interface OnDateTimeChangedListener {
+        void onDateTimeChanged(DateTimePicker view, int year, int month,
+                               int dayOfMonth, int hourOfDay, int minute);
+    }
+
+    public DateTimePicker(Context context) {
+        this(context, System.currentTimeMillis());
+    }
+
+    public DateTimePicker(Context context, long date) {
+        this(context, date, DateFormat.is24HourFormat(context));
+    }
+
+    /**
+     * 构造函数
+     * @param context 上下文对象
+     * @param date 初始日期时间（毫秒时间戳）
+     * @param is24HourView 是否为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);
+
+        String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings();
+        mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm);
+        mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL);
+        mAmPmSpinner.setMaxValue(AMPM_SPINNER_MAX_VAL);
+        mAmPmSpinner.setDisplayedValues(stringsForAmPm);
+        mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener);
+
+        // 初始化控件状态
+        updateDateControl();
+        updateHourControl();
+        updateAmPmControl();
+
+        set24HourView(is24HourView);
+
+        // 设置为当前时间
+        setCurrentDate(date);
+
+        setEnabled(isEnabled());
+
+        // 完成初始化
+        mInitialising = false;
+    }
+
+    @Override
+    public void setEnabled(boolean enabled) {
+        if (mIsEnabled == enabled) {
+            return;
+        }
+        super.setEnabled(enabled);
+        mDateSpinner.setEnabled(enabled);
+        mMinuteSpinner.setEnabled(enabled);
+        mHourSpinner.setEnabled(enabled);
+        mAmPmSpinner.setEnabled(enabled);
+        mIsEnabled = enabled;
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return mIsEnabled;
+    }
+
+    /**
+     * 获取当前日期的时间戳
+     * @return 当前日期的毫秒时间戳
+     */
+    public long getCurrentDateInTimeMillis() {
+        return mDate.getTimeInMillis();
+    }
+
+    /**
+     * 设置当前日期
+     * @param date 日期时间戳（毫秒）
+     */
+    public void setCurrentDate(long date) {
+        Calendar cal = Calendar.getInstance();
+        cal.setTimeInMillis(date);
+        setCurrentDate(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH),
+                cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE));
+    }
+
+    /**
+     * 设置当前日期时间
+     * @param year 年
+     * @param month 月
+     * @param dayOfMonth 日
+     * @param hourOfDay 小时
+     * @param minute 分钟
+     */
+    public void setCurrentDate(int year, int month,
+                               int dayOfMonth, int hourOfDay, int minute) {
+        setCurrentYear(year);
+        setCurrentMonth(month);
+        setCurrentDay(dayOfMonth);
+        setCurrentHour(hourOfDay);
+        setCurrentMinute(minute);
+    }
+
+    /**
+     * 获取当前年份
+     * @return 年份
+     */
+    public int getCurrentYear() {
+        return mDate.get(Calendar.YEAR);
+    }
+
+    /**
+     * 设置当前年份
+     * @param year 年份
+     */
+    public void setCurrentYear(int year) {
+        if (!mInitialising && year == getCurrentYear()) {
+            return;
+        }
+        mDate.set(Calendar.YEAR, year);
+        updateDateControl();
+        onDateTimeChanged();
+    }
+
+    /**
+     * 获取当前月份
+     * @return 月份（0-11）
+     */
+    public int getCurrentMonth() {
+        return mDate.get(Calendar.MONTH);
+    }
+
+    /**
+     * 设置当前月份
+     * @param month 月份（0-11）
+     */
+    public void setCurrentMonth(int month) {
+        if (!mInitialising && month == getCurrentMonth()) {
+            return;
+        }
+        mDate.set(Calendar.MONTH, month);
+        updateDateControl();
+        onDateTimeChanged();
+    }
+
+    /**
+     * 获取当前日期（月中的第几天）
+     * @return 日期（1-31）
+     */
+    public int getCurrentDay() {
+        return mDate.get(Calendar.DAY_OF_MONTH);
+    }
+
+    /**
+     * 设置当前日期
+     * @param dayOfMonth 日期（1-31）
+     */
+    public void setCurrentDay(int dayOfMonth) {
+        if (!mInitialising && dayOfMonth == getCurrentDay()) {
+            return;
+        }
+        mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
+        updateDateControl();
+        onDateTimeChanged();
+    }
+
+    /**
+     * 获取当前小时（24小时制，0-23）
+     * @return 小时数
+     */
+    public int getCurrentHourOfDay() {
+        return mDate.get(Calendar.HOUR_OF_DAY);
+    }
+
+    private int getCurrentHour() {
+        if (mIs24HourView){
+            return getCurrentHourOfDay();
+        } else {
+            int hour = getCurrentHourOfDay();
+            if (hour > HOURS_IN_HALF_DAY) {
+                return hour - HOURS_IN_HALF_DAY;
+            } else {
+                return hour == 0 ? HOURS_IN_HALF_DAY : hour;
+            }
+        }
+    }
+
+    /**
+     * 设置当前小时（24小时制）
+     * @param hourOfDay 小时数（0-23）
+     */
+    public void setCurrentHour(int hourOfDay) {
+        if (!mInitialising && hourOfDay == getCurrentHourOfDay()) {
+            return;
+        }
+        mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
+        if (!mIs24HourView) {
+            if (hourOfDay >= HOURS_IN_HALF_DAY) {
+                mIsAm = false;
+                if (hourOfDay > HOURS_IN_HALF_DAY) {
+                    hourOfDay -= HOURS_IN_HALF_DAY;
+                }
+            } else {
+                mIsAm = true;
+                if (hourOfDay == 0) {
+                    hourOfDay = HOURS_IN_HALF_DAY;
+                }
+            }
+            updateAmPmControl();
+        }
+        mHourSpinner.setValue(hourOfDay);
+        onDateTimeChanged();
+    }
+
+    /**
+     * 获取当前分钟
+     * @return 分钟数（0-59）
+     */
+    public int getCurrentMinute() {
+        return mDate.get(Calendar.MINUTE);
+    }
+
+    /**
+     * 设置当前分钟
+     * @param minute 分钟数（0-59）
+     */
+    public void setCurrentMinute(int minute) {
+        if (!mInitialising && minute == getCurrentMinute()) {
+            return;
+        }
+        mMinuteSpinner.setValue(minute);
+        mDate.set(Calendar.MINUTE, minute);
+        onDateTimeChanged();
+    }
+
+    /**
+     * 判断是否为24小时制
+     * @return true表示24小时制
+     */
+    public boolean is24HourView () {
+        return mIs24HourView;
+    }
+
+    /**
+     * 设置24小时制或AM/PM模式
+     * @param is24HourView true表示24小时制，false表示12小时制
+     */
+    public void set24HourView(boolean is24HourView) {
+        if (mIs24HourView == is24HourView) {
+            return;
+        }
+        mIs24HourView = is24HourView;
+        mAmPmSpinner.setVisibility(is24HourView ? View.GONE : View.VISIBLE);
+        int hour = getCurrentHourOfDay();
+        updateHourControl();
+        setCurrentHour(hour);
+        updateAmPmControl();
+    }
+
+    /**
+     * 更新日期选择器显示
+     * 显示最近一周的日期（格式：MM.dd 星期几）
+     */
+    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() {
+        if (mIs24HourView) {
+            mAmPmSpinner.setVisibility(View.GONE);
+        } else {
+            int index = mIsAm ? Calendar.AM : Calendar.PM;
+            mAmPmSpinner.setValue(index);
+            mAmPmSpinner.setVisibility(View.VISIBLE);
+        }
+    }
+
+    /**
+     * 更新小时控件的取值范围
+     */
+    private void updateHourControl() {
+        if (mIs24HourView) {
+            mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW);
+            mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW);
+        } else {
+            mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW);
+            mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW);
+        }
+    }
+
+    /**
+     * 设置日期时间变化监听器
+     * @param callback 监听器回调
+     */
+    public void setOnDateTimeChangedListener(OnDateTimeChangedListener callback) {
+        mOnDateTimeChangedListener = callback;
+    }
+
+    /**
+     * 触发日期时间变化回调
+     */
+    private void onDateTimeChanged() {
+        if (mOnDateTimeChangedListener != null) {
+            mOnDateTimeChangedListener.onDateTimeChanged(this, getCurrentYear(),
+                    getCurrentMonth(), getCurrentDay(), getCurrentHourOfDay(), getCurrentMinute());
+        }
+    }
+}

ui/DateTimePickerDialog.java

@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.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;
+
+// ... existing code ...
+
+/**
+ * 日期时间选择对话框
+ *
+ * 【功能说明】
+ * 1. 基于AlertDialog封装的日期时间选择器
+ * 2. 集成DateTimePicker组件提供可视化选择界面
+ * 3. 支持24小时制和12小时制显示
+ * 4. 实时更新对话框标题显示当前选择的日期时间
+ */
+public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
+
+    private Calendar mDate = Calendar.getInstance();
+    private boolean mIs24HourView;
+    private OnDateTimeSetListener mOnDateTimeSetListener;
+    private DateTimePicker mDateTimePicker;
+
+    /**
+     * 日期时间设置监听器接口
+     */
+    public interface OnDateTimeSetListener {
+        /**
+         * 当用户点击确定按钮时触发
+         * @param dialog 对话框对象
+         * @param date 选择的日期时间（毫秒时间戳）
+         */
+        void OnDateTimeSet(AlertDialog dialog, long date);
+    }
+
+    /**
+     * 构造函数
+     * @param context 上下文对象
+     * @param date 初始日期时间（毫秒时间戳）
+     */
+    public DateTimePickerDialog(Context context, long date) {
+        super(context);
+        mDateTimePicker = new DateTimePicker(context);
+        setView(mDateTimePicker);
+        // 设置日期时间变化监听器，实时更新标题
+        mDateTimePicker.setOnDateTimeChangedListener(new OnDateTimeChangedListener() {
+            public void onDateTimeChanged(DateTimePicker view, int year, int month,
+                                          int dayOfMonth, int hourOfDay, int minute) {
+                mDate.set(Calendar.YEAR, year);
+                mDate.set(Calendar.MONTH, month);
+                mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
+                mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
+                mDate.set(Calendar.MINUTE, minute);
+                updateTitle(mDate.getTimeInMillis());
+            }
+        });
+        mDate.setTimeInMillis(date);
+        mDate.set(Calendar.SECOND, 0);
+        mDateTimePicker.setCurrentDate(mDate.getTimeInMillis());
+        setButton(context.getString(R.string.datetime_dialog_ok), this);
+        setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener)null);
+        set24HourView(DateFormat.is24HourFormat(this.getContext()));
+        updateTitle(mDate.getTimeInMillis());
+    }
+
+    /**
+     * 设置是否为24小时制
+     * @param is24HourView true表示24小时制，false表示12小时制
+     */
+    public void set24HourView(boolean is24HourView) {
+        mIs24HourView = is24HourView;
+    }
+
+    /**
+     * 设置日期时间设置监听器
+     * @param callBack 监听器回调
+     */
+    public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) {
+        mOnDateTimeSetListener = callBack;
+    }
+
+    /**
+     * 更新对话框标题，显示格式化的日期时间
+     * @param date 日期时间（毫秒时间戳）
+     */
+    private void updateTitle(long date) {
+        int flag =
+                DateUtils.FORMAT_SHOW_YEAR |
+                        DateUtils.FORMAT_SHOW_DATE |
+                        DateUtils.FORMAT_SHOW_TIME;
+        flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_24HOUR;
+        setTitle(DateUtils.formatDateTime(this.getContext(), date, flag));
+    }
+
+    /**
+     * 处理对话框按钮点击事件
+     * @param arg0 对话框对象
+     * @param arg1 按钮标识
+     */
+    public void onClick(DialogInterface arg0, int arg1) {
+        if (mOnDateTimeSetListener != null) {
+            mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis());
+        }
+    }
+
+}

ui/DropdownMenu.java

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.ui;
+
+import android.content.Context;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.PopupMenu;
+import android.widget.PopupMenu.OnMenuItemClickListener;
+
+import net.micode.notes.R;
+
+// ... existing code ...
+
+/**
+ * 下拉菜单组件
+ *
+ * 【功能说明】
+ * 1. 封装PopupMenu的常用操作
+ * 2. 提供简单的API来创建和管理下拉菜单
+ * 3. 支持菜单项点击监听和标题设置
+ */
+public class DropdownMenu {
+    private Button mButton;
+    private PopupMenu mPopupMenu;
+    private Menu mMenu;
+
+    /**
+     * 构造函数
+     * @param context 上下文对象
+     * @param button 触发菜单的按钮
+     * @param menuId 菜单资源ID
+     */
+    public DropdownMenu(Context context, Button button, int menuId) {
+        mButton = button;
+        mButton.setBackgroundResource(R.drawable.dropdown_icon);
+        mPopupMenu = new PopupMenu(context, mButton);
+        mMenu = mPopupMenu.getMenu();
+        // 加载菜单资源
+        mPopupMenu.getMenuInflater().inflate(menuId, mMenu);
+        // 设置按钮点击事件，显示弹出菜单
+        mButton.setOnClickListener(new OnClickListener() {
+            public void onClick(View v) {
+                mPopupMenu.show();
+            }
+        });
+    }
+
+    /**
+     * 设置菜单项点击监听器
+     * @param listener 菜单项点击监听器
+     */
+    public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {
+        if (mPopupMenu != null) {
+            mPopupMenu.setOnMenuItemClickListener(listener);
+        }
+    }
+
+    /**
+     * 查找指定ID的菜单项
+     * @param id 菜单项ID
+     * @return 找到的菜单项，未找到返回null
+     */
+    public MenuItem findItem(int id) {
+        return mMenu.findItem(id);
+    }
+
+    /**
+     * 设置按钮标题
+     * @param title 标题文本
+     */
+    public void setTitle(CharSequence title) {
+        mButton.setText(title);
+    }
+}

ui/FoldersListAdapter.java

@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.ui;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.CursorAdapter;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+
+// ... existing code ...
+
+/**
+ * 文件夹列表适配器
+ *
+ * 【功能说明】
+ * 1. 用于在ListView中显示文件夹列表
+ * 2. 继承自CursorAdapter，直接绑定数据库游标数据
+ * 3. 特殊处理根文件夹，显示为"父文件夹"
+ */
+public class FoldersListAdapter extends CursorAdapter {
+    // 查询投影：ID和摘要（文件夹名称）
+    public static final String [] PROJECTION = {
+            NoteColumns.ID,
+            NoteColumns.SNIPPET
+    };
+
+    public static final int ID_COLUMN   = 0;
+    public static final int NAME_COLUMN = 1;
+
+    public FoldersListAdapter(Context context, Cursor c) {
+        super(context, c);
+    }
+
+    @Override
+    public View newView(Context context, Cursor cursor, ViewGroup parent) {
+        return new FolderListItem(context);
+    }
+
+    @Override
+    public void bindView(View view, Context context, Cursor cursor) {
+        if (view instanceof FolderListItem) {
+            // 如果是根文件夹，显示"父文件夹"，否则显示文件夹名称
+            String folderName = (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
+                    .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
+            ((FolderListItem) view).bind(folderName);
+        }
+    }
+
+    /**
+     * 获取指定位置的文件夹名称
+     * @param context 上下文对象
+     * @param position 列表位置
+     * @return 文件夹名称
+     */
+    public String getFolderName(Context context, int position) {
+        Cursor cursor = (Cursor) getItem(position);
+        return (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
+                .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
+    }
+
+    /**
+     * 文件夹列表项视图
+     */
+    private class FolderListItem extends LinearLayout {
+        private TextView mName;
+
+        public FolderListItem(Context context) {
+            super(context);
+            inflate(context, R.layout.folder_list_item, this);
+            mName = (TextView) findViewById(R.id.tv_folder_name);
+        }
+
+        public void bind(String name) {
+            mName.setText(name);
+        }
+    }
+}

ui/NoteEditActivity.java

@@ -0,0 +1,976 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.ui;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.SearchManager;
+import android.appwidget.AppWidgetManager;
+import android.content.ContentUris;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.graphics.Paint;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.text.Spannable;
+import android.text.SpannableString;
+import android.text.TextUtils;
+import android.text.format.DateUtils;
+import android.text.style.BackgroundColorSpan;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.WindowManager;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.CheckBox;
+import android.widget.CompoundButton;
+import android.widget.CompoundButton.OnCheckedChangeListener;
+import android.widget.EditText;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.TextNote;
+import net.micode.notes.model.WorkingNote;
+import net.micode.notes.model.WorkingNote.NoteSettingChangedListener;
+import net.micode.notes.tool.DataUtils;
+import net.micode.notes.tool.ResourceParser;
+import net.micode.notes.tool.ResourceParser.NoteBgResources;
+import net.micode.notes.tool.ResourceParser.TextAppearanceResources;
+import net.micode.notes.ui.DateTimePickerDialog.OnDateTimeSetListener;
+import net.micode.notes.ui.NoteEditText.OnTextViewChangeListener;
+import net.micode.notes.widget.NoteWidgetProvider_2x;
+import net.micode.notes.widget.NoteWidgetProvider_4x;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+
+/**
+ * 笔记编辑活动 - 便签核心功能模块
+ *
+ * 【模块功能】
+ * 1. 笔记创建与编辑：支持新建笔记和编辑现有笔记
+ * 2. 背景颜色设置：提供5种颜色主题（黄、红、蓝、绿、白）
+ * 3. 字体大小调整：支持4种字号（小、中、大、超大）
+ * 4. 清单模式：支持待办事项列表，可勾选完成状态
+ * 5. 闹钟提醒：可为笔记设置定时提醒
+ * 6. 分享功能：支持将笔记内容分享到其他应用
+ * 7. 桌面快捷方式：可创建笔记的快速访问入口
+ * 8. 搜索高亮：从搜索结果进入时高亮显示关键词
+ * 9. 通话记录便签：支持从通话记录创建便签
+ * 10. 自动保存：离开页面时自动保存笔记内容
+ *
+ * 【界面组成】
+ * - 头部区域：显示修改时间、提醒时间、背景色按钮
+ * - 编辑区域：普通文本编辑器或清单模式编辑器
+ * - 弹出面板：背景色选择器、字体大小选择器
+ *
+ * 【工作流程】
+ * 1. onCreate: 初始化界面，根据Intent加载或创建笔记
+ * 2. onResume: 刷新屏幕显示，应用最新设置
+ * 3. onPause: 自动保存笔记内容到数据库
+ * 4. 用户操作: 编辑文本、更改设置、触发菜单项
+ * 5. 数据持久化: 通过WorkingNote模型层保存到数据库
+ *
+ * 【关键技术】
+ * - WorkingNote: 工作笔记模型，管理笔记的临时状态
+ * - NoteEditText: 自定义编辑框，支持清单模式
+ * - SharedPreferences: 存储用户偏好（如字体大小）
+ * - SpannableString: 实现搜索关键词高亮
+ * - DateTimePickerDialog: 日期时间选择对话框
+ *
+ * 【数据来源】
+ * - ACTION_VIEW: 查看/编辑现有笔记（携带笔记ID）
+ * - ACTION_INSERT_OR_EDIT: 新建笔记（可携带文件夹ID、小部件信息等）
+ * - 搜索结果: 携带搜索关键词用于高亮显示
+ * - 通话记录: 携带电话号码和通话时间
+ *
+ * @author MiCode Open Source Community
+ * @modified 2026-05-07 (Complete Chinese Annotation Enhancement)
+ * @version 1.0
+ * @see WorkingNote 工作笔记模型类
+ * @see NoteEditText 自定义编辑文本组件
+ * @see NotesListActivity 笔记列表活动
+ */
+public class NoteEditActivity extends Activity implements OnClickListener,
+        NoteSettingChangedListener, OnTextViewChangeListener {
+
+    /**
+     * 头部视图持有者 - 缓存UI组件引用，避免重复findViewById
+     * 包含：修改时间文本、提醒图标、提醒时间文本、背景色按钮
+     */
+    private static class HeadViewHolder {
+        public TextView tvModified;
+        public ImageView ivAlertIcon;
+        public TextView tvAlertDate;
+        public ImageView ibSetBgColor;
+    }
+
+    // 背景颜色选择按钮映射：按钮ID -> 颜色资源ID
+    private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<>();
+    static {
+        sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW);
+        sBgSelectorBtnsMap.put(R.id.iv_bg_red, ResourceParser.RED);
+        sBgSelectorBtnsMap.put(R.id.iv_bg_blue, ResourceParser.BLUE);
+        sBgSelectorBtnsMap.put(R.id.iv_bg_green, ResourceParser.GREEN);
+        sBgSelectorBtnsMap.put(R.id.iv_bg_white, ResourceParser.WHITE);
+    }
+
+    // 背景颜色选中状态映射：颜色资源ID -> 选中标记View ID
+    private static final Map<Integer, Integer> sBgSelectorSelectionMap = new HashMap<>();
+    static {
+        sBgSelectorSelectionMap.put(ResourceParser.YELLOW, R.id.iv_bg_yellow_select);
+        sBgSelectorSelectionMap.put(ResourceParser.RED, R.id.iv_bg_red_select);
+        sBgSelectorSelectionMap.put(ResourceParser.BLUE, R.id.iv_bg_blue_select);
+        sBgSelectorSelectionMap.put(ResourceParser.GREEN, R.id.iv_bg_green_select);
+        sBgSelectorSelectionMap.put(ResourceParser.WHITE, R.id.iv_bg_white_select);
+    }
+
+    // 字体大小按钮映射：布局ID -> 字体大小资源ID
+    private static final Map<Integer, Integer> sFontSizeBtnsMap = new HashMap<>();
+    static {
+        sFontSizeBtnsMap.put(R.id.ll_font_large, ResourceParser.TEXT_LARGE);
+        sFontSizeBtnsMap.put(R.id.ll_font_small, ResourceParser.TEXT_SMALL);
+        sFontSizeBtnsMap.put(R.id.ll_font_normal, ResourceParser.TEXT_MEDIUM);
+        sFontSizeBtnsMap.put(R.id.ll_font_super, ResourceParser.TEXT_SUPER);
+    }
+
+    // 字体大小选中状态映射：字体大小资源ID -> 选中标记View ID
+    private static final Map<Integer, Integer> sFontSelectorSelectionMap = new HashMap<>();
+    static {
+        sFontSelectorSelectionMap.put(ResourceParser.TEXT_LARGE, R.id.iv_large_select);
+        sFontSelectorSelectionMap.put(ResourceParser.TEXT_SMALL, R.id.iv_small_select);
+        sFontSelectorSelectionMap.put(ResourceParser.TEXT_MEDIUM, R.id.iv_medium_select);
+        sFontSelectorSelectionMap.put(ResourceParser.TEXT_SUPER, R.id.iv_super_select);
+    }
+
+    private static final String TAG = "NoteEditActivity";
+
+    private HeadViewHolder mNoteHeaderHolder;
+    private View mHeadViewPanel;
+    private View mNoteBgColorSelector;
+    private View mFontSizeSelector;
+    private EditText mNoteEditor;
+    private View mNoteEditorPanel;
+    private WorkingNote mWorkingNote;
+    private SharedPreferences mSharedPrefs;
+    private int mFontSizeId;
+
+    private static final String PREFERENCE_FONT_SIZE = "pref_font_size";
+    private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10;
+
+    // 清单模式标记符号
+    public static final String TAG_CHECKED = "\u221A";    // 已勾选标记 ✓
+    public static final String TAG_UNCHECKED = "\u25A1";  // 未勾选标记 □
+
+    private LinearLayout mEditTextList;
+    private String mUserQuery;       // 用户搜索关键词
+    private Pattern mPattern;        // 搜索关键词正则表达式
+
+    /**
+     * 活动创建时的初始化方法
+     * 设置布局、初始化状态和资源
+     * @param savedInstanceState 保存的实例状态
+     */
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        this.setContentView(R.layout.note_edit);
+
+        if (savedInstanceState == null && !initActivityState(getIntent())) {
+            finish();
+            return;
+        }
+        initResources();
+    }
+
+    /**
+     * 恢复被系统回收的Activity状态
+     * 当Activity因内存不足被销毁后重新创建时调用
+     * @param savedInstanceState 包含之前保存状态的Bundle
+     */
+    @Override
+    protected void onRestoreInstanceState(Bundle savedInstanceState) {
+        super.onRestoreInstanceState(savedInstanceState);
+        if (savedInstanceState != null && savedInstanceState.containsKey(Intent.EXTRA_UID)) {
+            Intent intent = new Intent(Intent.ACTION_VIEW);
+            intent.putExtra(Intent.EXTRA_UID, savedInstanceState.getLong(Intent.EXTRA_UID));
+            if (!initActivityState(intent)) {
+                finish();
+                return;
+            }
+            Log.d(TAG, "Restoring from killed activity");
+        }
+    }
+
+    /**
+     * 初始化Activity状态：根据Intent加载现有笔记或创建新笔记
+     *
+     * 支持的Intent动作：
+     * - ACTION_VIEW: 查看/编辑现有笔记
+     * - ACTION_INSERT_OR_EDIT: 创建新笔记
+     * - 其他: 默认创建新笔记
+     *
+     * @param intent 启动此Activity的Intent
+     * @return true表示初始化成功，false表示失败应关闭Activity
+     */
+    private boolean initActivityState(Intent intent) {
+        mWorkingNote = null;
+
+        if (intent == null || intent.getAction() == null) {
+            Log.e(TAG, "Intent or action is null, creating new note");
+            createNewNoteInternal();
+            return true;
+        }
+
+        String action = intent.getAction();
+
+        if (TextUtils.equals(Intent.ACTION_VIEW, action)) {
+            // 查看/编辑现有笔记
+            long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0);
+            mUserQuery = "";
+
+            // 从搜索结果启动，提取搜索关键词用于高亮显示
+            if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) {
+                noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY));
+                mUserQuery = intent.getStringExtra(SearchManager.USER_QUERY);
+                // 转义特殊字符，构建不区分大小写的正则表达式
+                mUserQuery = mUserQuery.replace("\\", "\\\\").replace("$", "\\$");
+                mPattern = Pattern.compile(mUserQuery, Pattern.CASE_INSENSITIVE);
+            }
+
+            // 验证笔记是否存在且可见
+            if (!DataUtils.visibleInNoteDatabase(getContentResolver(), noteId, Notes.TYPE_NOTE)) {
+                Intent jump = new Intent(this, NotesListActivity.class);
+                startActivity(jump);
+                showToast(R.string.error_note_not_exist);
+                finish();
+                return false;
+            } else {
+                // 从数据库加载笔记
+                mWorkingNote = WorkingNote.load(this, noteId);
+                if (mWorkingNote == null) {
+                    Log.e(TAG, "load note failed with note id" + noteId);
+                    finish();
+                    return false;
+                }
+            }
+            // 查看模式：默认隐藏软键盘
+            getWindow().setSoftInputMode(
+                    WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN
+                            | WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
+        } else if(TextUtils.equals(Intent.ACTION_INSERT_OR_EDIT, action)) {
+            // 新建笔记，可能携带文件夹ID、小部件信息、通话记录等
+            createNewNoteInternalWithIntent(intent);
+        } else {
+            // 未知动作，默认创建新笔记
+            Log.w(TAG, "Unknown action: " + action + ", creating new note");
+            createNewNoteInternal();
+        }
+        return true;
+    }
+
+    /**
+     * 创建空白笔记（内部方法）
+     * 使用默认参数创建新笔记：根文件夹、无小部件、默认背景色
+     */
+    private void createNewNoteInternal() {
+        try {
+            mWorkingNote = WorkingNote.createEmptyNote(this, Notes.ID_ROOT_FOLDER,
+                    AppWidgetManager.INVALID_APPWIDGET_ID, Notes.TYPE_WIDGET_INVALIDE,
+                    ResourceParser.getDefaultBgId(this));
+            if (mWorkingNote == null) {
+                Log.e(TAG, "Failed to create empty note");
+                showToast(R.string.error_note_not_exist);
+                finish();
+                return;
+            }
+            // 新建模式：默认显示软键盘
+            getWindow().setSoftInputMode(
+                    WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE
+                            | WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
+        } catch (Exception e) {
+            Log.e(TAG, "Exception in createNewNoteInternal: " + e.getMessage());
+            showToast(R.string.error_note_not_exist);
+            finish();
+        }
+    }
+
+    /**
+     * 根据Intent参数创建新笔记
+     * 支持以下参数：
+     * - 文件夹ID：指定笔记所属文件夹
+     * - 小部件ID和类型：从小部件创建的笔记
+     * - 背景色ID：指定的背景颜色
+     * - 电话号码和通话时间：通话记录便签
+     *
+     * @param intent 包含创建参数的Intent
+     */
+    private void createNewNoteInternalWithIntent(Intent intent) {
+        try {
+            long folderId = intent.getLongExtra(Notes.INTENT_EXTRA_FOLDER_ID, 0);
+            int widgetId = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_ID,
+                    AppWidgetManager.INVALID_APPWIDGET_ID);
+            int widgetType = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_TYPE,
+                    Notes.TYPE_WIDGET_INVALIDE);
+            int bgResId = intent.getIntExtra(Notes.INTENT_EXTRA_BACKGROUND_ID,
+                    ResourceParser.getDefaultBgId(this));
+
+            // 解析通话记录便签参数
+            String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);
+            long callDate = intent.getLongExtra(Notes.INTENT_EXTRA_CALL_DATE, 0);
+            if (callDate != 0 && phoneNumber != null) {
+                if (TextUtils.isEmpty(phoneNumber)) {
+                    Log.w(TAG, "The call record number is null");
+                }
+                long noteId = 0;
+                // 检查是否已存在该通话记录的便签
+                if ((noteId = DataUtils.getNoteIdByPhoneNumberAndCallDate(getContentResolver(),
+                        phoneNumber, callDate)) > 0) {
+                    mWorkingNote = WorkingNote.load(this, noteId);
+                    if (mWorkingNote == null) {
+                        Log.e(TAG, "load call note failed with note id" + noteId);
+                        finish();
+                        return;
+                    }
+                } else {
+                    // 创建新的通话记录便签
+                    mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId,
+                            widgetType, bgResId);
+                    mWorkingNote.convertToCallNote(phoneNumber, callDate);
+                }
+            } else {
+                // 创建普通笔记
+                mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId, widgetType,
+                        bgResId);
+            }
+
+            if (mWorkingNote == null) {
+                Log.e(TAG, "Failed to create note from intent");
+                showToast(R.string.error_note_not_exist);
+                finish();
+                return;
+            }
+
+            // 新建模式：默认显示软键盘
+            getWindow().setSoftInputMode(
+                    WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE
+                            | WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
+        } catch (Exception e) {
+            Log.e(TAG, "Exception in createNewNoteInternalWithIntent: " + e.getMessage());
+            showToast(R.string.error_note_not_exist);
+            finish();
+        }
+    }
+
+    /**
+     * 初始化UI资源和事件监听器
+     * 包括：头部视图、编辑器、背景色选择器、字体大小选择器等
+     */
+    private void initResources() {
+        if (mWorkingNote == null) {
+            Log.e(TAG, "mWorkingNote is null in initResources, finishing");
+            finish();
+            return;
+        }
+
+        // 初始化头部视图组件
+        mHeadViewPanel = findViewById(R.id.note_title);
+        mNoteHeaderHolder = new HeadViewHolder();
+        mNoteHeaderHolder.tvModified = (TextView) findViewById(R.id.tv_modified_date);
+        mNoteHeaderHolder.ivAlertIcon = (ImageView) findViewById(R.id.iv_alert_icon);
+        mNoteHeaderHolder.tvAlertDate = (TextView) findViewById(R.id.tv_alert_date);
+        mNoteHeaderHolder.ibSetBgColor = (ImageView) findViewById(R.id.btn_set_bg_color);
+        mNoteHeaderHolder.ibSetBgColor.setOnClickListener(this);
+
+        // 初始化编辑器组件
+        mNoteEditor = (EditText) findViewById(R.id.note_edit_view);
+        mNoteEditorPanel = findViewById(R.id.sv_note_edit);
+
+        // 设置笔记设置变化监听器
+        mWorkingNote.setOnSettingStatusChangedListener(this);
+
+        // 点击编辑区域外部时隐藏软键盘
+        mNoteEditor.setOnTouchListener(new View.OnTouchListener() {
+            @Override
+            public boolean onTouch(View v, MotionEvent event) {
+                if (mNoteEditor.getVisibility() == View.VISIBLE) {
+                    hideSoftInput();
+                }
+                return false;
+            }
+        });
+
+        // 初始化背景色选择器
+        mNoteBgColorSelector = findViewById(R.id.note_bg_color_selector);
+        for (int id : sBgSelectorBtnsMap.keySet()) {
+            findViewById(id).setOnClickListener(this);
+        }
+
+        // 初始化字体大小选择器
+        mFontSizeSelector = findViewById(R.id.font_size_selector);
+        for (int id : sFontSizeBtnsMap.keySet()) {
+            findViewById(id).setOnClickListener(this);
+        }
+
+        // 加载用户偏好设置
+        mSharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);
+        mFontSizeId = mSharedPrefs.getInt(PREFERENCE_FONT_SIZE, ResourceParser.BG_DEFAULT_FONT_SIZE);
+
+        // 应用字体大小设置
+        mNoteEditor.setTextAppearance(this, TextAppearanceResources.getTexAppearanceResource(mFontSizeId));
+
+        // 初始化清单模式容器
+        mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list);
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        if (mWorkingNote != null) {
+            initNoteScreen();
+        } else {
+            Log.e(TAG, "mWorkingNote is null in onResume, finishing activity");
+            finish();
+        }
+    }
+
+    /**
+     * 初始化笔记屏幕显示
+     * 根据笔记状态设置内容、背景色、字体、提醒状态等
+     */
+    private void initNoteScreen() {
+        if (mWorkingNote == null) {
+            Log.e(TAG, "mWorkingNote is null in initNoteScreen");
+            finish();
+            return;
+        }
+
+        try {
+            String content = mWorkingNote.getContent();
+            if (content == null) {
+                content = "";
+            }
+
+            // 根据模式切换显示方式
+            if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
+                switchToListMode(content);
+            } else {
+                showTextEditor();
+                // 如果有搜索关键词，应用高亮显示
+                mNoteEditor.setText(getHighlightQueryResult(content, mUserQuery));
+                mNoteEditor.setSelection(mNoteEditor.getText().length());
+            }
+
+            // 隐藏所有背景色选中标记
+            for (Integer id : sBgSelectorSelectionMap.keySet()) {
+                findViewById(sBgSelectorSelectionMap.get(id)).setVisibility(View.GONE);
+            }
+
+            // 显示修改时间
+            mNoteHeaderHolder.tvModified.setText(DateUtils.formatDateTime(this,
+                    mWorkingNote.getModifiedDate(), DateUtils.FORMAT_SHOW_DATE
+                            | DateUtils.FORMAT_NUMERIC_DATE | DateUtils.FORMAT_SHOW_TIME
+                            | DateUtils.FORMAT_SHOW_YEAR));
+
+            // 更新提醒状态显示
+            updateAlertStatus();
+
+            // 应用背景色
+            mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());
+            mNoteHeaderHolder.ibSetBgColor.setImageResource(
+                    NoteBgResources.getNoteTitleBgResource(mWorkingNote.getBgColorId()));
+            // 显示当前背景色的选中标记
+            findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(View.VISIBLE);
+        } catch (Exception e) {
+            Log.e(TAG, "Exception in initNoteScreen: " + e.getMessage());
+            showToast(R.string.error_note_not_exist);
+            finish();
+        }
+    }
+
+    /**
+     * 更新闹钟提醒状态显示
+     * 如果设置了提醒时间，显示提醒图标和时间；否则隐藏
+     */
+    private void updateAlertStatus() {
+        long alertDate = mWorkingNote.getAlertDate();
+        if (alertDate > 0) {
+            mNoteHeaderHolder.tvAlertDate.setText(DateUtils.formatDateTime(this, alertDate,
+                    DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_NUMERIC_DATE
+                            | DateUtils.FORMAT_SHOW_TIME | DateUtils.FORMAT_SHOW_YEAR));
+            mNoteHeaderHolder.ivAlertIcon.setVisibility(View.VISIBLE);
+            mNoteHeaderHolder.tvAlertDate.setVisibility(View.VISIBLE);
+        } else {
+            mNoteHeaderHolder.ivAlertIcon.setVisibility(View.GONE);
+            mNoteHeaderHolder.tvAlertDate.setVisibility(View.GONE);
+        }
+    }
+
+    /**
+     * 切换到清单模式
+     * 将普通文本按行分割，每行创建一个可勾选的编辑框
+     * @param content 笔记内容
+     */
+    private void switchToListMode(String content) {
+        mNoteEditor.setVisibility(View.GONE);
+        mEditTextList.setVisibility(View.VISIBLE);
+        mEditTextList.removeAllViews();
+        if (!TextUtils.isEmpty(content)) {
+            String[] items = content.split("\n");
+            for (String item : items) {
+                if (TextUtils.isEmpty(item)) {
+                    continue;
+                }
+                addEditTextToGroup(item);
+            }
+        }
+        // 添加一个空的编辑框供用户继续输入
+        addEditTextToGroup("");
+    }
+
+    /**
+     * 添加编辑框到清单组
+     * 创建一个包含复选框和编辑框的列表项
+     * @param text 初始文本内容
+     */
+    private void addEditTextToGroup(String text) {
+        LayoutInflater inflater = LayoutInflater.from(this);
+        LinearLayout llItem = (LinearLayout) inflater.inflate(R.layout.note_edit_list_item, null);
+        mEditTextList.addView(llItem);
+
+        NoteEditText et = (NoteEditText) llItem.findViewById(R.id.et_edit_text);
+        et.setOnTextViewChangeListener(this);
+        et.setText(text);
+        et.setFocusable(true);
+        et.requestFocus();
+    }
+
+    /**
+     * 显示普通文本编辑器
+     * 隐藏清单模式容器，显示标准EditText
+     */
+    private void showTextEditor() {
+        mNoteEditor.setVisibility(View.VISIBLE);
+        mEditTextList.setVisibility(View.GONE);
+    }
+
+    /**
+     * 获取带高亮显示的查询结果
+     * 使用SpannableString为搜索关键词添加背景色高亮
+     *
+     * @param fullText 完整文本内容
+     * @param userQuery 用户搜索关键词
+     * @return 带高亮标记的Spannable对象
+     */
+    private Spannable getHighlightQueryResult(String fullText, String userQuery) {
+        SpannableString spannable = new SpannableString(fullText != null ? fullText : "");
+        if (!TextUtils.isEmpty(userQuery) && mPattern != null) {
+            Matcher matcher = mPattern.matcher(spannable.toString());
+            while (matcher.find()) {
+                // 为匹配的关键词添加黄色背景高亮
+                spannable.setSpan(
+                        new BackgroundColorSpan(this.getResources().getColor(R.color.user_query_highlight)),
+                        matcher.start(), matcher.end(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+            }
+        }
+        return spannable;
+    }
+
+    /**
+     * 处理点击事件
+     * 包括：背景色按钮、字体大小按钮的点击
+     * @param v 被点击的视图
+     */
+    @Override
+    public void onClick(View v) {
+        int id = v.getId();
+        if (id == R.id.btn_set_bg_color) {
+            showBackgroundSelector();
+        } else if (sBgSelectorBtnsMap.containsKey(id)) {
+            setBgColor(sBgSelectorBtnsMap.get(id));
+        } else if (sFontSizeBtnsMap.containsKey(id)) {
+            setFontSize(sFontSizeBtnsMap.get(id));
+        }
+    }
+
+    /**
+     * 显示/隐藏背景颜色选择器
+     * 显示背景色选择器时隐藏字体大小选择器
+     */
+    private void showBackgroundSelector() {
+        if (mNoteBgColorSelector.getVisibility() == View.GONE) {
+            mNoteBgColorSelector.setVisibility(View.VISIBLE);
+            mFontSizeSelector.setVisibility(View.GONE);
+        } else {
+            mNoteBgColorSelector.setVisibility(View.GONE);
+        }
+    }
+
+    /**
+     * 设置笔记背景颜色
+     * 更新笔记模型、UI背景和选中标记
+     * @param color 颜色资源ID
+     */
+    private void setBgColor(int color) {
+        mWorkingNote.setBgColorId(color);
+        mNoteEditorPanel.setBackgroundResource(NoteBgResources.getNoteBgResource(color));
+        mNoteHeaderHolder.ibSetBgColor.setImageResource(NoteBgResources.getNoteTitleBgResource(color));
+        mNoteBgColorSelector.setVisibility(View.GONE);
+        // 隐藏所有选中标记，只显示当前颜色的标记
+        for (Integer key : sBgSelectorSelectionMap.keySet()) {
+            findViewById(sBgSelectorSelectionMap.get(key)).setVisibility(View.GONE);
+        }
+        findViewById(sBgSelectorSelectionMap.get(color)).setVisibility(View.VISIBLE);
+    }
+
+    /**
+     * 设置字体大小
+     * 保存到SharedPreferences并应用到编辑器
+     * @param fontSize 字体大小资源ID
+     */
+    private void setFontSize(int fontSize) {
+        mFontSizeId = fontSize;
+        mSharedPrefs.edit().putInt(PREFERENCE_FONT_SIZE, fontSize).commit();
+        mNoteEditor.setTextAppearance(this, TextAppearanceResources.getTexAppearanceResource(fontSize));
+        mFontSizeSelector.setVisibility(View.GONE);
+        // 隐藏所有选中标记，只显示当前字号的标记
+        for (Integer key : sFontSelectorSelectionMap.keySet()) {
+            findViewById(sFontSelectorSelectionMap.get(key)).setVisibility(View.GONE);
+        }
+        findViewById(sFontSelectorSelectionMap.get(fontSize)).setVisibility(View.VISIBLE);
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        getMenuInflater().inflate(R.menu.note_edit, menu);
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        int id = item.getItemId();
+
+        if (id == R.id.menu_new_note) {
+            createNewNote();
+        } else if (id == R.id.menu_delete) {
+            // 删除笔记前显示确认对话框
+            AlertDialog.Builder builder = new AlertDialog.Builder(this);
+            builder.setTitle(getString(R.string.alert_title_delete));
+            builder.setIcon(android.R.drawable.ic_dialog_alert);
+            builder.setMessage(getString(R.string.alert_message_delete_note));
+            builder.setPositiveButton(android.R.string.ok,
+                    new DialogInterface.OnClickListener() {
+                        public void onClick(DialogInterface dialog, int which) {
+                            deleteCurrentNote();
+                            finish();
+                        }
+                    });
+            builder.setNegativeButton(android.R.string.cancel, null);
+            builder.show();
+        } else if (id == R.id.menu_font_size) {
+            showFontSizeSelector();
+        } else if (id == R.id.menu_list_mode) {
+            // 切换清单模式
+            mWorkingNote.setCheckListMode(mWorkingNote.getCheckListMode() == 0 ?
+                    TextNote.MODE_CHECK_LIST : 0);
+        } else if (id == R.id.menu_share) {
+            sendTo(this, mWorkingNote.getContent());
+        } else if (id == R.id.menu_send_to_desktop) {
+            createShortcutOnDesktop();
+        } else if (id == R.id.menu_alert) {
+            setAlarm();
+        } else if (id == R.id.menu_delete_remind) {
+            // 删除提醒
+            mWorkingNote.setAlertDate(0, false);
+            updateAlertStatus();
+        }
+
+        return true;
+    }
+
+    /**
+     * 创建新笔记
+     * 启动新的NoteEditActivity并关闭当前页面
+     */
+    private void createNewNote() {
+        Intent intent = new Intent(this, NoteEditActivity.class);
+        intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
+        intent.setType(Notes.TextNote.CONTENT_TYPE);
+        startActivity(intent);
+        finish();
+    }
+
+    /**
+     * 删除当前笔记
+     * 仅当笔记已存在于数据库中时才执行删除
+     */
+    private void deleteCurrentNote() {
+        if (mWorkingNote.existInDatabase()) {
+            DataUtils.batchDeleteNotes(getContentResolver(), new HashSet<Long>() {{
+                add(mWorkingNote.getNoteId());
+            }});
+        }
+    }
+
+    /**
+     * 显示/隐藏字体大小选择器
+     * 显示字体大小选择器时隐藏背景色选择器
+     */
+    private void showFontSizeSelector() {
+        if (mFontSizeSelector.getVisibility() == View.GONE) {
+            mFontSizeSelector.setVisibility(View.VISIBLE);
+            mNoteBgColorSelector.setVisibility(View.GONE);
+        } else {
+            mFontSizeSelector.setVisibility(View.GONE);
+        }
+    }
+
+    /**
+     * 分享内容到其他应用
+     * 使用ACTION_SEND Intent共享纯文本
+     *
+     * @param context 上下文对象
+     * @param info 要分享的文本内容
+     */
+    private void sendTo(Context context, String info) {
+        Intent intent = new Intent(Intent.ACTION_SEND);
+        intent.putExtra(Intent.EXTRA_TEXT, info != null ? info : "");
+        intent.setType("text/plain");
+        context.startActivity(intent);
+    }
+
+    /**
+     * 创建桌面快捷方式
+     * 设置快捷方式名称、意图和图标
+     */
+    private void createShortcutOnDesktop() {
+        Intent shortcut = new Intent(Intent.ACTION_CREATE_SHORTCUT);
+        shortcut.putExtra(Intent.EXTRA_SHORTCUT_NAME, generateShortcutName());
+        shortcut.putExtra(Intent.EXTRA_SHORTCUT_INTENT, getIntent());
+        shortcut.putExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE,
+                Intent.ShortcutIconResource.fromContext(this, R.drawable.icon_app));
+        setResult(RESULT_OK, shortcut);
+        finish();
+    }
+
+    /**
+     * 生成快捷方式名称
+     * 截取笔记内容前10个字符，超出部分用省略号表示
+     *
+     * @return 快捷方式名称字符串
+     */
+    private String generateShortcutName() {
+        String name = mWorkingNote.getContent();
+        if (name == null) {
+            name = "";
+        }
+        if (name.length() > SHORTCUT_ICON_TITLE_MAX_LEN) {
+            name = name.substring(0, SHORTCUT_ICON_TITLE_MAX_LEN) + "...";
+        }
+        return name;
+    }
+
+    /**
+     * 设置闹钟提醒
+     * 显示日期时间选择对话框，用户选择后设置提醒时间
+     */
+    private void setAlarm() {
+        DateTimePickerDialog d = new DateTimePickerDialog(this, System.currentTimeMillis());
+        d.setOnDateTimeSetListener(new OnDateTimeSetListener() {
+            public void OnDateTimeSet(AlertDialog dialog, long date) {
+                mWorkingNote.setAlertDate(date, true);
+                updateAlertStatus();
+            }
+        });
+        d.show();
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+        if (mWorkingNote != null) {
+            if (saveNote()) {
+                Log.d(TAG, "Note saved successfully");
+            } else {
+                Log.d(TAG, "Failed to save note");
+            }
+        }
+    }
+
+    /**
+     * 保存笔记内容
+     * 根据模式获取文本内容（普通模式或清单模式），然后保存到数据库
+     *
+     * @return true表示保存成功，false表示失败
+     */
+    private boolean saveNote() {
+        if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
+            String content = getCheckListContent();
+            mWorkingNote.setWorkingText(content);
+        } else {
+            mWorkingNote.setWorkingText(mNoteEditor.getText().toString());
+        }
+        return mWorkingNote.saveNote();
+    }
+
+    /**
+     * 获取清单模式的内容
+     * 遍历所有清单项，拼接成以换行符分隔的字符串
+     *
+     * @return 清单内容字符串
+     */
+    private String getCheckListContent() {
+        StringBuilder sb = new StringBuilder();
+        int count = mEditTextList.getChildCount();
+        for (int i = 0; i < count; i++) {
+            View view = mEditTextList.getChildAt(i);
+            if (view instanceof LinearLayout) {
+                NoteEditText et = (NoteEditText) ((LinearLayout) view).findViewById(R.id.et_edit_text);
+                if (et != null) {
+                    String text = et.getText().toString();
+                    if (!TextUtils.isEmpty(text)) {
+                        sb.append(text).append("\n");
+                    }
+                }
+            }
+        }
+        return sb.toString();
+    }
+
+    // ==========================================
+    // 接口实现方法
+    // ==========================================
+
+    /**
+     * 背景颜色改变时的回调
+     * 由WorkingNote触发，实际处理在setBgColor中完成
+     */
+    @Override
+    public void onBackgroundColorChanged() {
+        // 背景颜色变更由 setBgColor 处理
+    }
+
+    /**
+     * 闹钟提醒设置改变时的回调
+     * 更新界面上的提醒状态显示
+     *
+     * @param date 提醒时间戳
+     * @param set true表示设置提醒，false表示取消提醒
+     */
+    @Override
+    public void onClockAlertChanged(long date, boolean set) {
+        updateAlertStatus();
+    }
+
+    /**
+     * 桌面小部件改变时的回调
+     * 当笔记通过Widget创建或修改时调用
+     */
+    @Override
+    public void onWidgetChanged() {
+        // 当笔记通过 Widget 创建或修改时调用
+    }
+
+    /**
+     * 清单模式改变时的回调
+     * 在普通模式和清单模式之间切换
+     *
+     * @param oldMode 旧的模式值
+     * @param newMode 新的模式值
+     */
+    @Override
+    public void onCheckListModeChanged(int oldMode, int newMode) {
+        if (newMode == TextNote.MODE_CHECK_LIST) {
+            // 切换到清单模式
+            String currentText = mNoteEditor.getText() != null ? mNoteEditor.getText().toString() : "";
+            switchToListMode(currentText);
+        } else {
+            // 切换回普通模式
+            showTextEditor();
+            mNoteEditor.setText(getHighlightQueryResult(getCheckListContent(), mUserQuery));
+        }
+    }
+
+    /**
+     * 清单项文本改变时的回调
+     * 可用于控制选项按钮的显示/隐藏
+     *
+     * @param index 编辑框索引
+     * @param hasText true表示有文本，false表示空文本
+     */
+    @Override
+    public void onTextChange(int index, boolean hasText) {
+        // 清单模式下的文本变化处理
+    }
+
+    /**
+     * 清单项删除时的回调
+     * 当用户在清单项开头按删除键时触发
+     *
+     * @param index 被删除编辑框的索引
+     * @param text 被删除编辑框的文本内容
+     */
+    @Override
+    public void onEditTextDelete(int index, String text) {
+        // 清单模式下的删除处理
+    }
+
+    /**
+     * 清单项回车时的回调
+     * 当用户在清单项中按回车键时触发，创建新项
+     *
+     * @param index 新编辑框的索引
+     * @param text 光标后的文本（将移动到新编辑框）
+     */
+    @Override
+    public void onEditTextEnter(int index, String text) {
+        // 清单模式下的回车处理
+    }
+
+    /**
+     * 隐藏软键盘
+     * 使用InputMethodManager隐藏输入法键盘
+     */
+    private void hideSoftInput() {
+        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
+        if (imm != null) {
+            imm.hideSoftInputFromWindow(mNoteEditor.getWindowToken(), 0);
+        }
+    }
+
+    /**
+     * 显示Toast提示消息
+     * @param resId 字符串资源ID
+     */
+    private void showToast(int resId) {
+        Toast.makeText(this, resId, Toast.LENGTH_SHORT).show();
+    }
+}

ui/NoteEditText.java

@@ -0,0 +1,258 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.ui;
+
+import android.content.Context;
+import android.graphics.Rect;
+import android.text.Layout;
+import android.text.Selection;
+import android.text.Spanned;
+import android.text.TextUtils;
+import android.text.style.URLSpan;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.ContextMenu;
+import android.view.KeyEvent;
+import android.view.MenuItem;
+import android.view.MenuItem.OnMenuItemClickListener;
+import android.view.MotionEvent;
+import android.widget.EditText;
+
+import net.micode.notes.R;
+
+import java.util.HashMap;
+import java.util.Map;
+
+// ... existing code ...
+
+/**
+ * 自定义编辑文本组件
+ *
+ * 【功能说明】
+ * 1. 继承EditText，专为清单模式设计
+ * 2. 支持按回车键创建新的编辑框
+ * 3. 支持按删除键在文本为空时删除当前编辑框
+ * 4. 支持链接点击（电话、网址、邮件）
+ * 5. 提供文本变化监听接口
+ */
+public class NoteEditText extends EditText {
+    private static final String TAG = "NoteEditText";
+    private int mIndex;
+    private int mSelectionStartBeforeDelete;
+
+    private static final String SCHEME_TEL = "tel:" ;
+    private static final String SCHEME_HTTP = "http:" ;
+    private static final String SCHEME_EMAIL = "mailto:" ;
+
+    // URL方案与菜单文本资源的映射
+    private static final Map<String, Integer> sSchemaActionResMap = new HashMap<String, Integer>();
+    static {
+        sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel);
+        sSchemaActionResMap.put(SCHEME_HTTP, R.string.note_link_web);
+        sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email);
+    }
+
+    /**
+     * 文本视图变化监听器接口
+     * 由NoteEditActivity实现，用于管理清单模式下的多个编辑框
+     */
+    public interface OnTextViewChangeListener {
+        /**
+         * 当按下删除键且文本为空时触发，删除当前编辑框
+         * @param index 当前编辑框的索引
+         * @param text 编辑框中的文本内容
+         */
+        void onEditTextDelete(int index, String text);
+
+        /**
+         * 当按下回车键时触发，在当前编辑框后添加新编辑框
+         * @param index 新编辑框的索引
+         * @param text 光标后的文本内容（将被移动到新编辑框）
+         */
+        void onEditTextEnter(int index, String text);
+
+        /**
+         * 当文本内容变化时触发，用于显示/隐藏项目选项
+         * @param index 编辑框索引
+         * @param hasText true表示有文本，false表示空文本
+         */
+        void onTextChange(int index, boolean hasText);
+    }
+
+    private OnTextViewChangeListener mOnTextViewChangeListener;
+
+    public NoteEditText(Context context) {
+        super(context, null);
+        mIndex = 0;
+    }
+
+    /**
+     * 设置编辑框的索引位置
+     * @param index 索引值
+     */
+    public void setIndex(int index) {
+        mIndex = index;
+    }
+
+    /**
+     * 设置文本变化监听器
+     * @param listener 监听器对象
+     */
+    public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
+        mOnTextViewChangeListener = listener;
+    }
+
+    public NoteEditText(Context context, AttributeSet attrs) {
+        super(context, attrs, android.R.attr.editTextStyle);
+    }
+
+    public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    /**
+     * 处理触摸事件，精确定位光标位置
+     * @param event 触摸事件对象
+     * @return 是否消费该事件
+     */
+    @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:
+                // 回车键交给onKeyUp处理
+                if (mOnTextViewChangeListener != null) {
+                    return false;
+                }
+                break;
+            case KeyEvent.KEYCODE_DEL:
+                // 记录删除前的光标位置
+                mSelectionStartBeforeDelete = getSelectionStart();
+                break;
+            default:
+                break;
+        }
+        return super.onKeyDown(keyCode, event);
+    }
+
+    @Override
+    public boolean onKeyUp(int keyCode, KeyEvent event) {
+        switch(keyCode) {
+            case KeyEvent.KEYCODE_DEL:
+                // 如果光标在开头且不是第一个编辑框，则删除当前编辑框
+                if (mOnTextViewChangeListener != null) {
+                    if (0 == mSelectionStartBeforeDelete && mIndex != 0) {
+                        mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString());
+                        return true;
+                    }
+                } else {
+                    Log.d(TAG, "OnTextViewChangeListener was not seted");
+                }
+                break;
+            case KeyEvent.KEYCODE_ENTER:
+                // 回车键：将光标后的文本移动到新编辑框
+                if (mOnTextViewChangeListener != null) {
+                    int selectionStart = getSelectionStart();
+                    String text = getText().subSequence(selectionStart, length()).toString();
+                    setText(getText().subSequence(0, selectionStart));
+                    mOnTextViewChangeListener.onEditTextEnter(mIndex + 1, text);
+                } else {
+                    Log.d(TAG, "OnTextViewChangeListener was not seted");
+                }
+                break;
+            default:
+                break;
+        }
+        return super.onKeyUp(keyCode, event);
+    }
+
+    @Override
+    protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
+        if (mOnTextViewChangeListener != null) {
+            // 失去焦点且文本为空时，通知监听器
+            if (!focused && TextUtils.isEmpty(getText())) {
+                mOnTextViewChangeListener.onTextChange(mIndex, false);
+            } else {
+                mOnTextViewChangeListener.onTextChange(mIndex, true);
+            }
+        }
+        super.onFocusChanged(focused, direction, previouslyFocusedRect);
+    }
+
+    /**
+     * 创建上下文菜单，用于处理链接点击
+     * @param menu 上下文菜单对象
+     */
+    @Override
+    protected void onCreateContextMenu(ContextMenu menu) {
+        if (getText() instanceof Spanned) {
+            int selStart = getSelectionStart();
+            int selEnd = getSelectionEnd();
+
+            int min = Math.min(selStart, selEnd);
+            int max = Math.max(selStart, selEnd);
+
+            // 查找选中文本中的URL链接
+            final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class);
+            if (urls.length == 1) {
+                int defaultResId = 0;
+                // 根据URL协议类型确定菜单文本
+                for(String schema: sSchemaActionResMap.keySet()) {
+                    if(urls[0].getURL().indexOf(schema) >= 0) {
+                        defaultResId = sSchemaActionResMap.get(schema);
+                        break;
+                    }
+                }
+
+                if (defaultResId == 0) {
+                    defaultResId = R.string.note_link_other;
+                }
+
+                menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener(
+                        new OnMenuItemClickListener() {
+                            public boolean onMenuItemClick(MenuItem item) {
+                                // 触发链接点击，打开相应应用
+                                urls[0].onClick(NoteEditText.this);
+                                return true;
+                            }
+                        });
+            }
+        }
+        super.onCreateContextMenu(menu);
+    }
+}

ui/NoteItemData.java

@@ -0,0 +1,344 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.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;
+
+
+// ... existing code ...
+
+/**
+ * 笔记项数据模型
+ *
+ * 【功能说明】
+ * 1. 封装笔记列表中的单个笔记项的所有数据
+ * 2. 从数据库游标中提取并缓存笔记信息
+ * 3. 提供便捷的访问方法来获取笔记属性
+ * 4. 支持判断笔记在列表中的位置关系（是否为首项、末项等）
+ */
+public class NoteItemData {
+    // 查询投影：包含笔记的所有必要字段
+    static final String [] PROJECTION = new String [] {
+            NoteColumns.ID,
+            NoteColumns.ALERTED_DATE,
+            NoteColumns.BG_COLOR_ID,
+            NoteColumns.CREATED_DATE,
+            NoteColumns.HAS_ATTACHMENT,
+            NoteColumns.MODIFIED_DATE,
+            NoteColumns.NOTES_COUNT,
+            NoteColumns.PARENT_ID,
+            NoteColumns.SNIPPET,
+            NoteColumns.TYPE,
+            NoteColumns.WIDGET_ID,
+            NoteColumns.WIDGET_TYPE,
+    };
+
+    // 列索引常量定义
+    private static final int ID_COLUMN                    = 0;
+    private static final int ALERTED_DATE_COLUMN          = 1;
+    private static final int BG_COLOR_ID_COLUMN           = 2;
+    private static final int CREATED_DATE_COLUMN          = 3;
+    private static final int HAS_ATTACHMENT_COLUMN        = 4;
+    private static final int MODIFIED_DATE_COLUMN         = 5;
+    private static final int NOTES_COUNT_COLUMN           = 6;
+    private static final int PARENT_ID_COLUMN             = 7;
+    private static final int SNIPPET_COLUMN               = 8;
+    private static final int TYPE_COLUMN                  = 9;
+    private static final int WIDGET_ID_COLUMN             = 10;
+    private static final int WIDGET_TYPE_COLUMN           = 11;
+
+    // 笔记基本属性
+    private long mId;
+    private long mAlertDate;
+    private int mBgColorId;
+    private long mCreatedDate;
+    private boolean mHasAttachment;
+    private long mModifiedDate;
+    private int mNotesCount;
+    private long mParentId;
+    private String mSnippet;
+    private int mType;
+    private int mWidgetId;
+    private int mWidgetType;
+    private String mName;
+    private String mPhoneNumber;
+
+    // 位置标记：用于UI渲染时判断显示样式
+    private boolean mIsLastItem;
+    private boolean mIsFirstItem;
+    private boolean mIsOnlyOneItem;
+    private boolean mIsOneNoteFollowingFolder;
+    private boolean mIsMultiNotesFollowingFolder;
+
+    /**
+     * 构造函数：从数据库游标中加载笔记数据
+     * @param context 上下文对象
+     * @param cursor 数据库游标，已移动到目标记录
+     */
+    public NoteItemData(Context context, Cursor cursor) {
+        // 从游标中提取各字段值
+        mId = cursor.getLong(ID_COLUMN);
+        mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN);
+        mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN);
+        mCreatedDate = cursor.getLong(CREATED_DATE_COLUMN);
+        mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0) ? true : false;
+        mModifiedDate = cursor.getLong(MODIFIED_DATE_COLUMN);
+        mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN);
+        mParentId = cursor.getLong(PARENT_ID_COLUMN);
+        mSnippet = cursor.getString(SNIPPET_COLUMN);
+        // 移除清单模式下的勾选标记
+        mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(
+                NoteEditActivity.TAG_UNCHECKED, "");
+        mType = cursor.getInt(TYPE_COLUMN);
+        mWidgetId = cursor.getInt(WIDGET_ID_COLUMN);
+        mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN);
+
+        mPhoneNumber = "";
+        // 如果是通话记录便签，获取联系人信息
+        if (mParentId == Notes.ID_CALL_RECORD_FOLDER) {
+            mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId);
+            if (!TextUtils.isEmpty(mPhoneNumber)) {
+                mName = Contact.getContact(context, mPhoneNumber);
+                if (mName == null) {
+                    mName = mPhoneNumber;
+                }
+            }
+        }
+
+        if (mName == null) {
+            mName = "";
+        }
+        // 检查当前笔记在列表中的位置
+        checkPostion(cursor);
+    }
+
+    /**
+     * 检查并设置笔记在列表中的位置关系
+     * 用于UI渲染时添加适当的分隔线和圆角效果
+     * @param cursor 数据库游标
+     */
+    private void checkPostion(Cursor cursor) {
+        mIsLastItem = cursor.isLast() ? true : false;
+        mIsFirstItem = cursor.isFirst() ? true : false;
+        mIsOnlyOneItem = (cursor.getCount() == 1);
+        mIsMultiNotesFollowingFolder = false;
+        mIsOneNoteFollowingFolder = false;
+
+        // 判断普通笔记是否紧跟在文件夹后面
+        if (mType == Notes.TYPE_NOTE && !mIsFirstItem) {
+            int position = cursor.getPosition();
+            if (cursor.moveToPrevious()) {
+                if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER
+                        || cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) {
+                    // 根据后续笔记数量判断是单个还是多个笔记跟随文件夹
+                    if (cursor.getCount() > (position + 1)) {
+                        mIsMultiNotesFollowingFolder = true;
+                    } else {
+                        mIsOneNoteFollowingFolder = true;
+                    }
+                }
+                if (!cursor.moveToNext()) {
+                    throw new IllegalStateException("cursor move to previous but can't move back");
+                }
+            }
+        }
+    }
+
+    /**
+     * 判断是否为紧跟在文件夹后的单个笔记
+     * @return true表示是单个笔记跟随文件夹
+     */
+    public boolean isOneFollowingFolder() {
+        return mIsOneNoteFollowingFolder;
+    }
+
+    /**
+     * 判断是否为紧跟在文件夹后的多个笔记之一
+     * @return true表示是多个笔记跟随文件夹
+     */
+    public boolean isMultiFollowingFolder() {
+        return mIsMultiNotesFollowingFolder;
+    }
+
+    /**
+     * 判断是否为列表最后一项
+     * @return true表示是最后一项
+     */
+    public boolean isLast() {
+        return mIsLastItem;
+    }
+
+    /**
+     * 获取通话记录对应的联系人名称
+     * @return 联系人名称或电话号码
+     */
+    public String getCallName() {
+        return mName;
+    }
+
+    /**
+     * 判断是否为列表第一项
+     * @return true表示是第一项
+     */
+    public boolean isFirst() {
+        return mIsFirstItem;
+    }
+
+    /**
+     * 判断是否为列表中唯一的一项
+     * @return true表示是唯一项
+     */
+    public boolean isSingle() {
+        return mIsOnlyOneItem;
+    }
+
+    /**
+     * 获取笔记ID
+     * @return 笔记ID
+     */
+    public long getId() {
+        return mId;
+    }
+
+    /**
+     * 获取提醒日期
+     * @return 提醒日期的时间戳（毫秒），0表示未设置提醒
+     */
+    public long getAlertDate() {
+        return mAlertDate;
+    }
+
+    /**
+     * 获取创建日期
+     * @return 创建日期的时间戳（毫秒）
+     */
+    public long getCreatedDate() {
+        return mCreatedDate;
+    }
+
+    /**
+     * 判断是否有附件
+     * @return true表示有附件
+     */
+    public boolean hasAttachment() {
+        return mHasAttachment;
+    }
+
+    /**
+     * 获取修改日期
+     * @return 修改日期的时间戳（毫秒）
+     */
+    public long getModifiedDate() {
+        return mModifiedDate;
+    }
+
+    /**
+     * 获取背景颜色ID
+     * @return 背景颜色资源ID
+     */
+    public int getBgColorId() {
+        return mBgColorId;
+    }
+
+    /**
+     * 获取父文件夹ID
+     * @return 父文件夹ID
+     */
+    public long getParentId() {
+        return mParentId;
+    }
+
+    /**
+     * 获取文件夹内笔记数量
+     * @return 笔记数量
+     */
+    public int getNotesCount() {
+        return mNotesCount;
+    }
+
+    /**
+     * 获取文件夹ID（与getParentId相同）
+     * @return 文件夹ID
+     */
+    public long getFolderId () {
+        return mParentId;
+    }
+
+    /**
+     * 获取笔记类型
+     * @return 笔记类型（普通笔记/文件夹/系统文件夹等）
+     */
+    public int getType() {
+        return mType;
+    }
+
+    /**
+     * 获取桌面小部件类型
+     * @return 小部件类型
+     */
+    public int getWidgetType() {
+        return mWidgetType;
+    }
+
+    /**
+     * 获取桌面小部件ID
+     * @return 小部件ID
+     */
+    public int getWidgetId() {
+        return mWidgetId;
+    }
+
+    /**
+     * 获取笔记内容摘要
+     * @return 笔记摘要文本
+     */
+    public String getSnippet() {
+        return mSnippet;
+    }
+
+    /**
+     * 判断是否设置了提醒
+     * @return true表示已设置提醒
+     */
+    public boolean hasAlert() {
+        return (mAlertDate > 0);
+    }
+
+    /**
+     * 判断是否为通话记录便签
+     * @return true表示是通话记录便签
+     */
+    public boolean isCallRecord() {
+        return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber));
+    }
+
+    /**
+     * 静态方法：从游标中获取笔记类型
+     * @param cursor 数据库游标
+     * @return 笔记类型
+     */
+    public static int getNoteType(Cursor cursor) {
+        return cursor.getInt(TYPE_COLUMN);
+    }
+}

ui/NotesListActivity.java

@@ -0,0 +1,953 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.ui;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.appwidget.AppWidgetManager;
+import android.content.AsyncQueryHandler;
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.database.Cursor;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.text.Editable;
+import android.text.TextUtils;
+import android.text.TextWatcher;
+import android.util.Log;
+import android.view.ActionMode;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.Display;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.MenuItem.OnMenuItemClickListener;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.View.OnCreateContextMenuListener;
+import android.view.View.OnTouchListener;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.AdapterView;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.AdapterView.OnItemLongClickListener;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.ListView;
+import android.widget.PopupMenu;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.gtask.remote.GTaskSyncService;
+import net.micode.notes.model.WorkingNote;
+import net.micode.notes.tool.BackupUtils;
+import net.micode.notes.tool.DataUtils;
+import net.micode.notes.tool.ResourceParser;
+import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;
+import net.micode.notes.ui.NotesListItem.NoteItemData;
+import net.micode.notes.widget.NoteWidgetProvider_2x;
+import net.micode.notes.widget.NoteWidgetProvider_4x;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.HashSet;
+
+/**
+ * 笔记列表活动 - 应用的主界面
+ *
+ * 【功能说明】
+ * 1. 显示所有笔记和文件夹的列表视图
+ * 2. 支持创建、编辑、删除笔记
+ * 3. 支持创建和管理文件夹（重命名/删除）
+ * 4. 支持多选批量操作（删除/移动）
+ * 5. 支持长按上下文菜单操作
+ * 6. 支持搜索和导出文本功能
+ * 7. 支持Google任务同步
+ * 8. 首次启动时显示使用说明便签
+ * 9. 支持通话记录便签显示
+ * 10. 支持桌面小部件更新
+ *
+ * 【界面组成】
+ * - ListView: 显示笔记和文件夹列表
+ * - 底部按钮: 新建笔记
+ * - 标题栏: 显示当前文件夹名称
+ * - 多选模式: ActionMode + 下拉菜单
+ *
+ * @author MiCode Open Source Community
+ * @modified 2026-05-07 (Complete Chinese Annotation)
+ */
+public class NotesListActivity extends Activity implements OnClickListener, OnItemLongClickListener {
+    // 异步查询令牌常量
+    private static final int FOLDER_NOTE_LIST_QUERY_TOKEN = 0;
+    private static final int FOLDER_LIST_QUERY_TOKEN = 1;
+
+    // 文件夹菜单项常量
+    private static final int MENU_FOLDER_DELETE = 0;
+    private static final int MENU_FOLDER_VIEW = 1;
+    private static final int MENU_FOLDER_CHANGE_NAME = 2;
+
+    // SharedPreferences键名：是否已添加介绍便签
+    private static final String PREFERENCE_ADD_INTRODUCTION = "net.micode.notes.introduction";
+
+    /**
+     * 列表编辑状态枚举
+     * NOTE_LIST: 根目录笔记列表
+     * SUB_FOLDER: 用户自定义文件夹内
+     * CALL_RECORD_FOLDER: 通话记录文件夹
+     */
+    private enum ListEditState {
+        NOTE_LIST, SUB_FOLDER, CALL_RECORD_FOLDER
+    }
+
+    private ListEditState mState;
+
+    private BackgroundQueryHandler mBackgroundQueryHandler;
+    private NotesListAdapter mNotesListAdapter;
+    private ListView mNotesListView;
+    private Button mAddNewNote;
+    private boolean mDispatch;
+    private int mOriginY;
+    private int mDispatchY;
+    private TextView mTitleBar;
+    private long mCurrentFolderId;
+    private ContentResolver mContentResolver;
+    private ModeCallback mModeCallBack;
+
+    private static final String TAG = "NotesListActivity";
+    public static final int NOTES_LISTVIEW_SCROLL_RATE = 30;
+    private NoteItemData mFocusNoteDataItem;
+
+    // 数据库查询条件
+    private static final String NORMAL_SELECTION = NoteColumns.PARENT_ID + "=?";
+    private static final String ROOT_FOLDER_SELECTION = "(" + NoteColumns.TYPE + "<>"
+            + Notes.TYPE_SYSTEM + " AND " + NoteColumns.PARENT_ID + "=?)" + " OR ("
+            + NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER + " AND "
+            + NoteColumns.NOTES_COUNT + ">0)";
+
+    // Activity请求码
+    private final static int REQUEST_CODE_OPEN_NODE = 102;
+    private final static int REQUEST_CODE_NEW_NODE = 103;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.note_list);
+        initResources();
+        setAppInfoFromRawRes();
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        if (resultCode == RESULT_OK
+                && (requestCode == REQUEST_CODE_OPEN_NODE || requestCode == REQUEST_CODE_NEW_NODE)) {
+            // 从编辑页面返回时刷新列表
+            mNotesListAdapter.changeCursor(null);
+        } else {
+            super.onActivityResult(requestCode, resultCode, data);
+        }
+    }
+
+    /**
+     * 首次启动时从raw资源加载使用说明并创建介绍便签
+     * 仅执行一次，通过SharedPreferences标记
+     */
+    private void setAppInfoFromRawRes() {
+        SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
+        if (!sp.getBoolean(PREFERENCE_ADD_INTRODUCTION, false)) {
+            StringBuilder sb = new StringBuilder();
+            InputStream in = null;
+            try {
+                in = getResources().openRawResource(R.raw.introduction);
+                if (in != null) {
+                    InputStreamReader isr = new InputStreamReader(in);
+                    BufferedReader br = new BufferedReader(isr);
+                    char [] buf = new char[1024];
+                    int len = 0;
+                    while ((len = br.read(buf)) > 0) {
+                        sb.append(buf, 0, len);
+                    }
+                } else {
+                    Log.e(TAG, "Read introduction file error");
+                    return;
+                }
+            } catch (IOException e) {
+                e.printStackTrace();
+                return;
+            } finally {
+                if(in != null) {
+                    try {
+                        in.close();
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+
+            WorkingNote note = WorkingNote.createEmptyNote(this, Notes.ID_ROOT_FOLDER,
+                    AppWidgetManager.INVALID_APPWIDGET_ID, Notes.TYPE_WIDGET_INVALIDE,
+                    ResourceParser.RED);
+            note.setWorkingText(sb.toString());
+            if (note.saveNote()) {
+                sp.edit().putBoolean(PREFERENCE_ADD_INTRODUCTION, true).commit();
+            } else {
+                Log.e(TAG, "Save introduction note error");
+                return;
+            }
+        }
+    }
+
+    @Override
+    protected void onStart() {
+        super.onStart();
+        startAsyncNotesListQuery();
+    }
+
+    /**
+     * 初始化UI组件和资源
+     * 包括ListView、适配器、按钮等
+     */
+    private void initResources() {
+        mContentResolver = this.getContentResolver();
+        mBackgroundQueryHandler = new BackgroundQueryHandler(this.getContentResolver());
+        mCurrentFolderId = Notes.ID_ROOT_FOLDER;
+        mNotesListView = (ListView) findViewById(R.id.notes_list);
+        mNotesListView.addFooterView(LayoutInflater.from(this).inflate(R.layout.note_list_footer, null),
+                null, false);
+        mNotesListView.setOnItemClickListener(new OnListItemClickListener());
+        mNotesListView.setOnItemLongClickListener(this);
+        mNotesListAdapter = new NotesListAdapter(this);
+        mNotesListView.setAdapter(mNotesListAdapter);
+        mAddNewNote = (Button) findViewById(R.id.btn_new_note);
+        mAddNewNote.setOnClickListener(this);
+        mAddNewNote.setOnTouchListener(new NewNoteOnTouchListener());
+        mDispatch = false;
+        mDispatchY = 0;
+        mOriginY = 0;
+        mTitleBar = (TextView) findViewById(R.id.tv_title_bar);
+        mState = ListEditState.NOTE_LIST;
+        mModeCallBack = new ModeCallback();
+    }
+
+    /**
+     * 多选模式回调类
+     * 实现ListView.MultiChoiceModeListener接口
+     * 处理批量选择和操作相关的逻辑
+     */
+    private class ModeCallback implements ListView.MultiChoiceModeListener, OnMenuItemClickListener {
+        private DropdownMenu mDropDownMenu;
+        private ActionMode mActionMode;
+        private MenuItem mMoveMenu;
+
+        public boolean onCreateActionMode(ActionMode mode, Menu menu) {
+            getMenuInflater().inflate(R.menu.note_list_options, menu);
+            menu.findItem(R.id.delete).setOnMenuItemClickListener(this);
+            mMoveMenu = menu.findItem(R.id.move);
+            // 通话记录文件夹或没有用户文件夹时隐藏移动选项
+            if (mFocusNoteDataItem != null && mFocusNoteDataItem.getParentId() == Notes.ID_CALL_RECORD_FOLDER
+                    || DataUtils.getUserFolderCount(mContentResolver) == 0) {
+                mMoveMenu.setVisible(false);
+            } else {
+                mMoveMenu.setVisible(true);
+                mMoveMenu.setOnMenuItemClickListener(this);
+            }
+            mActionMode = mode;
+            mNotesListAdapter.setChoiceMode(ListView.CHOICE_MODE_MULTIPLE);
+            mNotesListView.setLongClickable(false);
+            mAddNewNote.setVisibility(View.GONE);
+
+            View customView = LayoutInflater.from(NotesListActivity.this).inflate(
+                    R.layout.note_list_dropdown_menu, null);
+            mode.setCustomView(customView);
+            mDropDownMenu = new DropdownMenu(NotesListActivity.this,
+                    (Button) customView.findViewById(R.id.selection_menu),
+                    R.menu.note_list_dropdown);
+            mDropDownMenu.setOnDropdownMenuItemClickListener(new PopupMenu.OnMenuItemClickListener(){
+                public boolean onMenuItemClick(MenuItem item) {
+                    mNotesListAdapter.selectAll(!mNotesListAdapter.isAllSelected());
+                    updateMenu();
+                    return true;
+                }
+            });
+            return true;
+        }
+
+        /**
+         * 更新菜单显示，包括选中数量
+         */
+        private void updateMenu() {
+            int selectedCount = mNotesListAdapter.getSelectedCount();
+            mDropDownMenu.setTitle(String.valueOf(selectedCount));
+            if (selectedCount == 0) {
+                mMoveMenu.setVisible(false);
+            } else {
+                mMoveMenu.setVisible(true);
+            }
+        }
+
+        public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
+            return false;
+        }
+
+        public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
+            return false;
+        }
+
+        public void onDestroyActionMode(ActionMode mode) {
+            mNotesListAdapter.setChoiceMode(ListView.CHOICE_MODE_NONE);
+            mNotesListView.setLongClickable(true);
+            mAddNewNote.setVisibility(View.VISIBLE);
+        }
+
+        public void finishActionMode() {
+            mActionMode.finish();
+        }
+
+        public void onItemCheckedStateChanged(ActionMode mode, int position, long id,
+                                              boolean checked) {
+            mNotesListAdapter.setCheckedItem(position, checked);
+            updateMenu();
+        }
+
+        public boolean onMenuItemClick(MenuItem item) {
+            if (item.getItemId() == R.id.delete) {
+                AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
+                builder.setTitle(getString(R.string.alert_title_delete));
+                builder.setIcon(android.R.drawable.ic_dialog_alert);
+                builder.setMessage(getString(R.string.alert_message_delete_note));
+                builder.setPositiveButton(android.R.string.ok,
+                        new DialogInterface.OnClickListener() {
+                            public void onClick(DialogInterface dialog, int which) {
+                                batchDelete();
+                            }
+                        });
+                builder.setNegativeButton(android.R.string.cancel, null);
+                builder.show();
+            } else if (item.getItemId() == R.id.move) {
+                startQueryDestinationFolders();
+            }
+            return false;
+        }
+    }
+
+    /**
+     * 开始查询目标文件夹列表（用于移动笔记）
+     * 根据当前状态构建不同的查询条件
+     */
+    private void startQueryDestinationFolders() {
+        String selection = NoteColumns.TYPE + "=? AND " + NoteColumns.ID + "<>? AND " + NoteColumns.ID + "<>?";
+        selection = (mState == ListEditState.NOTE_LIST) ? selection :
+                "(" + selection + ") OR (" + NoteColumns.ID + "=?)";
+
+        String[] selectionArgs = (mState == ListEditState.NOTE_LIST) ?
+                new String[] { String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_ROOT_FOLDER),
+                        String.valueOf(Notes.ID_TEMPARAY_FOLDER) } :
+                new String[] { String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_ROOT_FOLDER),
+                        String.valueOf(Notes.ID_TEMPARAY_FOLDER), String.valueOf(mCurrentFolderId) };
+
+        mBackgroundQueryHandler.startQuery(FOLDER_LIST_QUERY_TOKEN, null,
+                Notes.CONTENT_NOTE_URI, FoldersListAdapter.PROJECTION, selection, selectionArgs, null);
+    }
+
+    /**
+     * 后台查询处理器
+     * 异步处理数据库查询操作，避免阻塞UI线程
+     */
+    private class BackgroundQueryHandler extends AsyncQueryHandler {
+        public BackgroundQueryHandler(ContentResolver contentResolver) {
+            super(contentResolver);
+        }
+
+        @Override
+        protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
+            switch (token) {
+                case FOLDER_NOTE_LIST_QUERY_TOKEN:
+                    mNotesListAdapter.changeCursor(cursor);
+                    break;
+                case FOLDER_LIST_QUERY_TOKEN:
+                    if (cursor != null && cursor.getCount() > 0) {
+                        showFolderListDialog(cursor);
+                    } else {
+                        Log.e(TAG, "Query folder list failed");
+                    }
+                    cursor.close();
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+
+    /**
+     * 显示文件夹列表对话框（用于选择移动目标）
+     * @param cursor 文件夹数据游标
+     */
+    private void showFolderListDialog(Cursor cursor) {
+        final Cursor foldersCursor = cursor;
+        final AlertDialog.Builder builder = new AlertDialog.Builder(this);
+        View view = LayoutInflater.from(this).inflate(R.layout.folder_list_item, null);
+        ListView foldersList = (ListView) view.findViewById(R.id.folders_list);
+        FoldersListAdapter adapter = new FoldersListAdapter(this, foldersCursor);
+        foldersList.setAdapter(adapter);
+        foldersList.setOnItemClickListener(new OnItemClickListener() {
+            @Override
+            public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
+                if (mFocusNoteDataItem != null) {
+                    ContentValues values = new ContentValues();
+                    values.put(NoteColumns.PARENT_ID, id);
+                    values.put(NoteColumns.LOCAL_MODIFIED, 1);
+                    mContentResolver.update(Notes.CONTENT_NOTE_URI, values, NoteColumns.ID + "=?",
+                            new String[] { String.valueOf(mFocusNoteDataItem.getId()) });
+                }
+                mModeCallBack.finishActionMode();
+            }
+        });
+        builder.setTitle("Move to folder");
+        builder.setView(view);
+        builder.setNegativeButton(android.R.string.cancel, null);
+        builder.show();
+    }
+
+    /**
+     * 开始异步查询笔记列表
+     * 根据当前文件夹ID和状态构建不同的查询条件
+     */
+    private void startAsyncNotesListQuery() {
+        String selection = (mCurrentFolderId == Notes.ID_ROOT_FOLDER) ? ROOT_FOLDER_SELECTION : NORMAL_SELECTION;
+        String[] selectionArgs = (mCurrentFolderId == Notes.ID_ROOT_FOLDER) ?
+                new String[] { String.valueOf(Notes.ID_ROOT_FOLDER) } :
+                new String[] { String.valueOf(mCurrentFolderId) };
+
+        mBackgroundQueryHandler.startQuery(FOLDER_NOTE_LIST_QUERY_TOKEN, null,
+                Notes.CONTENT_NOTE_URI, NotesListAdapter.PROJECTION, selection, selectionArgs,
+                NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC");
+    }
+
+    /**
+     * 列表项点击监听器
+     * 处理笔记和文件夹的点击事件
+     */
+    private final class OnListItemClickListener implements OnItemClickListener {
+        public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
+            // 忽略底部按钮的点击
+            if (position >= mNotesListAdapter.getCount()) {
+                return;
+            }
+
+            NoteItemData item = (NoteItemData) mNotesListAdapter.getItem(position);
+            if (item == null) return;
+
+            Log.d(TAG, "Item clicked: type=" + item.getType() + ", id=" + item.getId() + ", snippet=" + item.getSnippet());
+
+            if (item.getType() == Notes.TYPE_NOTE) {
+                openNode(item);
+            } else if (item.getType() == Notes.TYPE_FOLDER) {
+                Log.d(TAG, "Opening folder: " + item.getSnippet());
+                openFolder(item);
+            }
+        }
+    }
+
+    /**
+     * 打开笔记编辑页面
+     * @param data 笔记项数据
+     */
+    private void openNode(NoteItemData data) {
+        Intent intent = new Intent(this, NoteEditActivity.class);
+        intent.setAction(Intent.ACTION_VIEW);
+        intent.putExtra(Intent.EXTRA_UID, data.getId());
+        this.startActivityForResult(intent, REQUEST_CODE_OPEN_NODE);
+    }
+
+    /**
+     * 进入文件夹
+     * @param data 文件夹数据
+     */
+    private void openFolder(NoteItemData data) {
+        mCurrentFolderId = data.getId();
+        Log.d(TAG, "Entered folder ID: " + mCurrentFolderId);
+        startAsyncNotesListQuery();
+        if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
+            mState = ListEditState.CALL_RECORD_FOLDER;
+            mAddNewNote.setVisibility(View.GONE);
+        } else {
+            mState = ListEditState.SUB_FOLDER;
+        }
+        if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
+            mTitleBar.setText(R.string.call_record_folder_name);
+        } else {
+            mTitleBar.setText(data.getSnippet());
+        }
+        mTitleBar.setVisibility(View.VISIBLE);
+    }
+
+    @Override
+    public boolean onItemLongClick(AdapterView<?> parent, View view, int position, long id) {
+        if (position >= mNotesListAdapter.getCount()) {
+            mNotesListView.setSelection(position);
+            return false;
+        }
+
+        mFocusNoteDataItem = (NoteItemData) mNotesListAdapter.getItem(position);
+        if (mFocusNoteDataItem == null) {
+            Log.e(TAG, "Long click failed: mFocusNoteDataItem is null");
+            return false;
+        }
+
+        // 长按普通笔记：直接删除
+        if (mFocusNoteDataItem.getType() == Notes.TYPE_NOTE) {
+            AlertDialog.Builder builder = new AlertDialog.Builder(this);
+            builder.setTitle(getString(R.string.alert_title_delete));
+            builder.setMessage(getString(R.string.alert_message_delete_note));
+            builder.setPositiveButton(android.R.string.ok,
+                    new DialogInterface.OnClickListener() {
+                        public void onClick(DialogInterface dialog, int which) {
+                            HashSet<Long> ids = new HashSet<>();
+                            ids.add(mFocusNoteDataItem.getId());
+                            DataUtils.batchDeleteNotes(mContentResolver, ids);
+                            mNotesListAdapter.changeCursor(null);
+                            startAsyncNotesListQuery();
+                        }
+                    });
+            builder.setNegativeButton(android.R.string.cancel, null);
+            builder.show();
+            return true;
+        }
+
+        // 长按文件夹：弹出菜单（重命名/删除）
+        if (mFocusNoteDataItem.getType() == Notes.TYPE_FOLDER) {
+            showCreateOrModifyFolderDialog(false);
+            return true;
+        }
+
+        return false;
+    }
+
+    public void onClick(View v) {
+        if (v.getId() == R.id.btn_new_note) {
+            createNewNote();
+        }
+    }
+
+    /**
+     * 创建新笔记
+     * 传递当前文件夹ID
+     */
+    private void createNewNote() {
+        Intent intent = new Intent(this, NoteEditActivity.class);
+        intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
+        intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mCurrentFolderId);
+        this.startActivityForResult(intent, REQUEST_CODE_NEW_NODE);
+    }
+
+    /**
+     * 批量删除选中的笔记
+     * 在同步模式下移动到回收站，否则直接删除
+     * 同时更新关联的桌面小部件
+     */
+    private void batchDelete() {
+        new AsyncTask<Void, Void, HashSet<AppWidgetAttribute>>() {
+            protected HashSet<AppWidgetAttribute> doInBackground(Void... unused) {
+                HashSet<AppWidgetAttribute> widgets = mNotesListAdapter.getSelectedWidget();
+                if (!isSyncMode()) {
+                    if (DataUtils.batchDeleteNotes(mContentResolver, mNotesListAdapter
+                            .getSelectedItemIds())) {
+                    } else {
+                        Log.e(TAG, "Delete notes error, should not happens");
+                    }
+                } else {
+                    if (!DataUtils.batchMoveToFolder(mContentResolver, mNotesListAdapter
+                            .getSelectedItemIds(), Notes.ID_TRASH_FOLER)) {
+                        Log.e(TAG, "Move notes to trash folder error, should not happens");
+                    }
+                }
+                return widgets;
+            }
+
+            @Override
+            protected void onPostExecute(HashSet<AppWidgetAttribute> widgets) {
+                if (widgets != null) {
+                    for (AppWidgetAttribute widget : widgets) {
+                        if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+                                && widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) {
+                            updateWidget(widget.widgetId, widget.widgetType);
+                        }
+                    }
+                }
+                mModeCallBack.finishActionMode();
+            }
+        }.execute();
+    }
+
+    /**
+     * 删除文件夹及其所有内容
+     * @param folderId 文件夹ID
+     */
+    private void deleteFolder(long folderId) {
+        if (folderId == Notes.ID_ROOT_FOLDER) {
+            Log.e(TAG, "Wrong folder id, should not happen " + folderId);
+            return;
+        }
+
+        HashSet<Long> ids = new HashSet<>();
+        ids.add(folderId);
+        HashSet<AppWidgetAttribute> widgets = DataUtils.getFolderNoteWidget(mContentResolver,
+                folderId);
+        if (!isSyncMode()) {
+            DataUtils.batchDeleteNotes(mContentResolver, ids);
+        } else {
+            DataUtils.batchMoveToFolder(mContentResolver, ids, Notes.ID_TRASH_FOLER);
+        }
+        if (widgets != null) {
+            for (AppWidgetAttribute widget : widgets) {
+                if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+                        && widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) {
+                    updateWidget(widget.widgetId, widget.widgetType);
+                }
+            }
+        }
+    }
+
+    /**
+     * 显示软键盘
+     */
+    private void showSoftInput() {
+        InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
+        if (inputMethodManager != null) {
+            inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
+        }
+    }
+
+    /**
+     * 隐藏软键盘
+     * @param view 获取窗口令牌的视图
+     */
+    private void hideSoftInput(View view) {
+        InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
+        inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
+    }
+
+    /**
+     * 显示创建或修改文件夹的对话框
+     * @param create true表示创建新文件夹，false表示修改现有文件夹
+     */
+    private void showCreateOrModifyFolderDialog(final boolean create) {
+        final AlertDialog.Builder builder = new AlertDialog.Builder(this);
+        View view = LayoutInflater.from(this).inflate(R.layout.dialog_edit_text, null);
+        final EditText etName = (EditText) view.findViewById(R.id.et_foler_name);
+        showSoftInput();
+        if (!create) {
+            if (mFocusNoteDataItem != null) {
+                etName.setText(mFocusNoteDataItem.getSnippet());
+                builder.setTitle(getString(R.string.menu_folder_change_name));
+            } else {
+                Log.e(TAG, "The long click data item is null");
+                return;
+            }
+        } else {
+            etName.setText("");
+            builder.setTitle(this.getString(R.string.menu_create_folder));
+        }
+
+        builder.setPositiveButton(android.R.string.ok, null);
+        builder.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
+            public void onClick(DialogInterface dialog, int which) {
+                hideSoftInput(etName);
+            }
+        });
+
+        final Dialog dialog = builder.setView(view).show();
+        final Button positive = (Button)dialog.findViewById(android.R.id.button1);
+        positive.setOnClickListener(new OnClickListener() {
+            public void onClick(View v) {
+                hideSoftInput(etName);
+                String name = etName.getText().toString();
+                // 检查文件夹名称是否已存在
+                if (DataUtils.checkVisibleFolderName(mContentResolver, name)) {
+                    Toast.makeText(NotesListActivity.this, getString(R.string.folder_exist, name),
+                            Toast.LENGTH_LONG).show();
+                    etName.setSelection(0, etName.length());
+                    return;
+                }
+                if (!create) {
+                    // 修改文件夹名称
+                    if (!TextUtils.isEmpty(name)) {
+                        ContentValues values = new ContentValues();
+                        values.put(NoteColumns.SNIPPET, name);
+                        values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
+                        values.put(NoteColumns.LOCAL_MODIFIED, 1);
+                        mContentResolver.update(Notes.CONTENT_NOTE_URI, values, NoteColumns.ID
+                                + "=?", new String[] {
+                                String.valueOf(mFocusNoteDataItem.getId())
+                        });
+                    }
+                } else if (!TextUtils.isEmpty(name)) {
+                    // 创建新文件夹
+                    ContentValues values = new ContentValues();
+                    values.put(NoteColumns.SNIPPET, name);
+                    values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
+                    mContentResolver.insert(Notes.CONTENT_NOTE_URI, values);
+                }
+                dialog.dismiss();
+            }
+        });
+
+        if (TextUtils.isEmpty(etName.getText())) {
+            positive.setEnabled(false);
+        }
+        // 监听文本变化，控制确定按钮的启用状态
+        etName.addTextChangedListener(new TextWatcher() {
+            public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
+
+            public void onTextChanged(CharSequence s, int start, int before, int count) {
+                if (TextUtils.isEmpty(etName.getText())) {
+                    positive.setEnabled(false);
+                } else {
+                    positive.setEnabled(true);
+                }
+            }
+
+            public void afterTextChanged(Editable s) {}
+        });
+    }
+
+    @Override
+    public void onBackPressed() {
+        // 在子文件夹或通话记录文件夹中按返回键，返回根目录
+        if (mState == ListEditState.SUB_FOLDER) {
+            mCurrentFolderId = Notes.ID_ROOT_FOLDER;
+            mState = ListEditState.NOTE_LIST;
+            startAsyncNotesListQuery();
+            mTitleBar.setVisibility(View.GONE);
+            mAddNewNote.setVisibility(View.VISIBLE);
+        } else if (mState == ListEditState.CALL_RECORD_FOLDER) {
+            mCurrentFolderId = Notes.ID_ROOT_FOLDER;
+            mState = ListEditState.NOTE_LIST;
+            startAsyncNotesListQuery();
+            mTitleBar.setVisibility(View.GONE);
+            mAddNewNote.setVisibility(View.VISIBLE);
+        } else {
+            super.onBackPressed();
+        }
+    }
+
+    /**
+     * 更新桌面小部件
+     * @param widgetId 小部件ID
+     * @param widgetType 小部件类型
+     */
+    private void updateWidget(int widgetId, int widgetType) {
+        Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
+        if (widgetType == Notes.TYPE_WIDGET_2X) {
+            intent.setClass(this, NoteWidgetProvider_2x.class);
+        } else if (widgetType == Notes.TYPE_WIDGET_4X) {
+            intent.setClass(this, NoteWidgetProvider_4x.class);
+        } else {
+            Log.e(TAG, "Unspported widget type");
+            return;
+        }
+
+        intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] { widgetId });
+        sendBroadcast(intent);
+        setResult(RESULT_OK, intent);
+    }
+
+    /**
+     * 文件夹上下文菜单创建监听器
+     */
+    private final OnCreateContextMenuListener mFolderOnCreateContextMenuListener = new OnCreateContextMenuListener() {
+        @Override
+        public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
+            menu.setHeaderTitle(R.string.menu_folder_option);
+            menu.add(0, MENU_FOLDER_DELETE, 0, R.string.menu_folder_delete);
+            menu.add(0, MENU_FOLDER_CHANGE_NAME, 0, R.string.menu_folder_change_name);
+        }
+    };
+
+    @Override
+    public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
+        if (mState == ListEditState.NOTE_LIST) {
+            AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo) menuInfo;
+            if (info.position >= mNotesListAdapter.getCount()) {
+                return;
+            }
+            NoteItemData item = (NoteItemData) mNotesListAdapter.getItem(info.position);
+            // 只为文件夹显示上下文菜单
+            if (item.getType() == Notes.TYPE_FOLDER) {
+                menu.setHeaderTitle(R.string.menu_folder_option);
+                menu.add(0, MENU_FOLDER_DELETE, 0, R.string.menu_folder_delete);
+                menu.add(0, MENU_FOLDER_CHANGE_NAME, 0, R.string.menu_folder_change_name);
+            }
+        }
+    }
+
+    @Override
+    public boolean onContextItemSelected(MenuItem item) {
+        if (item.getItemId() == MENU_FOLDER_DELETE) {
+            AlertDialog.Builder builder = new AlertDialog.Builder(this);
+            builder.setTitle(getString(R.string.alert_title_delete));
+            builder.setIcon(android.R.drawable.ic_dialog_alert);
+            builder.setMessage(getString(R.string.alert_message_delete_folder));
+            builder.setPositiveButton(android.R.string.ok,
+                    new DialogInterface.OnClickListener() {
+                        public void onClick(DialogInterface dialog, int which) {
+                            deleteFolder(mFocusNoteDataItem.getId());
+                        }
+                    });
+            builder.setNegativeButton(android.R.string.cancel, null);
+            builder.show();
+        } else if (item.getItemId() == MENU_FOLDER_CHANGE_NAME) {
+            showCreateOrModifyFolderDialog(false);
+        }
+        return true;
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        getMenuInflater().inflate(R.menu.note_list, menu);
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        if (item.getItemId() == R.id.menu_new_folder) {
+            showCreateOrModifyFolderDialog(true);
+        } else if (item.getItemId() == R.id.menu_export_text) {
+            exportNoteToText();
+        } else if (item.getItemId() == R.id.menu_sync) {
+            if (GTaskSyncService.isSyncing()) {
+                GTaskSyncService.cancelSync(this);
+            } else {
+                GTaskSyncService.startSync(this);
+            }
+        } else if (item.getItemId() == R.id.menu_setting) {
+            Intent intent = new Intent(this, NotesPreferenceActivity.class);
+            startActivity(intent);
+        } else if (item.getItemId() == R.id.menu_search) {
+            onSearchRequested();
+        }
+        return true;
+    }
+
+    /**
+     * 导出笔记为文本文件
+     * 异步执行导出操作，并根据结果显示相应的提示
+     */
+    private void exportNoteToText() {
+        final BackupUtils backup = BackupUtils.getInstance(this);
+        new AsyncTask<Void, Void, Integer>() {
+            @Override
+            protected Integer doInBackground(Void... unused) {
+                return backup.exportToText();
+            }
+
+            @Override
+            protected void onPostExecute(Integer result) {
+                if (result == BackupUtils.STATE_SD_CARD_UNMOUONTED) {
+                    AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
+                    builder.setTitle(NotesListActivity.this
+                            .getString(R.string.failed_sdcard_export));
+                    builder.setMessage(NotesListActivity.this
+                            .getString(R.string.error_sdcard_unmounted));
+                    builder.setPositiveButton(android.R.string.ok, null);
+                    builder.show();
+                } else if (result == BackupUtils.SUCCESS) {
+                    AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
+                    builder.setTitle(NotesListActivity.this
+                            .getString(R.string.success_sdcard_export));
+                    builder.setMessage(NotesListActivity.this.getString(
+                            R.string.success_sdcard_exported, backup.getExportedTextFile()));
+                    builder.setPositiveButton(android.R.string.ok, null);
+                    builder.show();
+                } else if (result == BackupUtils.EXPORT_FILE_UNEXIST) {
+                    AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
+                    builder.setTitle(NotesListActivity.this
+                            .getString(R.string.failed_sdcard_export));
+                    builder.setMessage(NotesListActivity.this
+                            .getString(R.string.error_sdcard_export));
+                    builder.setPositiveButton(android.R.string.ok, null);
+                    builder.show();
+                }
+            }
+        }.execute();
+    }
+
+    /**
+     * 判断当前是否为同步模式
+     * @return true表示已设置同步账号
+     */
+    private boolean isSyncMode() {
+        return NotesPreferenceActivity.isSyncMode(this);
+    }
+
+    /**
+     * 新建笔记按钮触摸监听器
+     * 处理滑动事件，防止误触
+     */
+    private class NewNoteOnTouchListener implements OnTouchListener {
+        @Override
+        public boolean onTouch(View v, MotionEvent event) {
+            switch (event.getAction()) {
+                case MotionEvent.ACTION_DOWN:
+                    Display display = getWindowManager().getDefaultDisplay();
+                    int screenHeight = display.getHeight();
+                    int newNoteViewHeight = mAddNewNote.getHeight();
+                    int start = screenHeight - newNoteViewHeight;
+                    int eventY = start + (int) event.getY();
+                    eventY -= 38;
+                    if (mDispatchY == 0) {
+                        mDispatchY = (int) event.getY();
+                        mOriginY = mDispatchY;
+                    }
+                    if (eventY > mOriginY + 50) {
+                        mDispatch = true;
+                        mOriginY = mDispatchY;
+                    }
+                    break;
+                case MotionEvent.ACTION_MOVE:
+                    if (mDispatch) {
+                        mDispatchY = (int) event.getY();
+                    }
+                    break;
+                case MotionEvent.ACTION_UP:
+                    if (mDispatch) {
+                        mDispatch = false;
+                        if (mDispatchY - mOriginY > 50) {
+                            return true;
+                        }
+                    }
+                    mDispatchY = 0;
+                    mOriginY = 0;
+                    break;
+                default:
+                    break;
+            }
+            return false;
+        }
+    }
+}

ui/NotesListAdapter.java

@@ -0,0 +1,230 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package net.micode.notes.ui;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.CursorAdapter;
+import android.widget.ListView;
+
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.ui.NotesListItem.NoteItemData;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+// ... existing code ...
+
+/**
+ * 笔记列表适配器
+ *
+ * 【功能说明】
+ * 1. 继承CursorAdapter，用于在ListView中显示笔记列表
+ * 2. 支持多选模式，可批量操作笔记
+ * 3. 管理选中状态和桌面小部件信息
+ * 4. 自动统计笔记和文件夹数量
+ */
+public class NotesListAdapter extends CursorAdapter {
+    private Context mContext;
+    private Map<Long, Boolean> mSelectedIndex;
+    private int mChoiceMode;
+    private int mCount;
+
+    /**
+     * 桌面小部件属性类
+     * 用于存储小部件的ID和类型信息
+     */
+    public static class AppWidgetAttribute {
+        public int widgetId;
+        public int widgetType;
+    }
+
+    // 这里的索引顺序必须和 PROJECTION 数组完全一致
+    private static final int ID = 0;
+    private static final int SNIPPET = 1;
+    private static final int TYPE = 2;
+    private static final int MODIFIED_DATE = 3;
+    private static final int ALERT_DATE = 4;
+    private static final int BG_COLOR_ID = 5;
+    private static final int PARENT_ID = 7;
+
+    // 查询投影：包含笔记列表显示所需的所有字段
+    public static final String[] PROJECTION = {
+            NoteColumns.ID,
+            NoteColumns.SNIPPET,
+            NoteColumns.TYPE,
+            NoteColumns.MODIFIED_DATE,
+            NoteColumns.ALERTED_DATE,
+            NoteColumns.BG_COLOR_ID,
+            NoteColumns.HAS_ATTACHMENT,
+            NoteColumns.PARENT_ID
+    };
+
+    /**
+     * 构造函数
+     * @param context 上下文对象
+     */
+    public NotesListAdapter(Context context) {
+        super(context, null);
+        mSelectedIndex = new HashMap<>();
+        mContext = context;
+        mChoiceMode = 0;
+    }
+
+    @Override
+    public void changeCursor(Cursor cursor) {
+        super.changeCursor(cursor);
+        mCount = 0;
+        if (cursor != null) {
+            mCount = cursor.getCount();
+        }
+        // 切换游标时清空选中状态
+        mSelectedIndex.clear();
+    }
+
+    @Override
+    public View newView(Context context, Cursor cursor, ViewGroup parent) {
+        return new NotesListItem(mContext);
+    }
+
+    @Override
+    public void bindView(View view, Context context, Cursor cursor) {
+        if (view instanceof NotesListItem) {
+            NoteItemData itemData = new NoteItemData(context, cursor);
+            ((NotesListItem) view).bind(context, itemData, mChoiceMode == ListView.CHOICE_MODE_MULTIPLE,
+                    mSelectedIndex.containsKey(itemData.getId()) ? mSelectedIndex.get(itemData.getId()) : false);
+        }
+    }
+
+    /**
+     * 设置指定位置的笔记为选中或非选中状态
+     * @param position 列表位置
+     * @param checked true表示选中，false表示取消选中
+     */
+    public void setCheckedItem(final int position, final boolean checked) {
+        Cursor c = getCursor();
+        if (c.moveToPosition(position)) {
+            long id = c.getLong(ID);
+            if (id >= 0) {
+                mSelectedIndex.put(id, checked);
+            }
+        }
+        notifyDataSetChanged();
+    }
+
+    /**
+     * 设置选择模式
+     * @param mode 选择模式（单选/多选/无）
+     */
+    public void setChoiceMode(int mode) {
+        mChoiceMode = mode;
+        // 如果不是多选模式，清空选中状态
+        if (mChoiceMode != ListView.CHOICE_MODE_MULTIPLE) {
+            mSelectedIndex.clear();
+        }
+    }
+
+    /**
+     * 判断是否所有笔记都被选中
+     * @return true表示全部选中
+     */
+    public boolean isAllSelected() {
+        int selectedCount = mSelectedIndex.size();
+        return selectedCount == mCount && selectedCount > 0;
+    }
+
+    /**
+     * 全选或全不选
+     * @param checked true表示全选，false表示全不选
+     */
+    public void selectAll(boolean checked) {
+        Cursor c = getCursor();
+        mSelectedIndex.clear();
+        if (c != null) {
+            for (int i = 0; i < c.getCount(); i++) {
+                if (c.moveToPosition(i)) {
+                    long id = c.getLong(ID);
+                    if (id >= 0) {
+                        mSelectedIndex.put(id, checked);
+                    }
+                }
+            }
+        }
+        notifyDataSetChanged();
+    }
+
+    /**
+     * 获取已选中的笔记数量
+     * @return 选中数量
+     */
+    public int getSelectedCount() {
+        return mSelectedIndex.size();
+    }
+
+    /**
+     * 获取所有已选中笔记的ID集合
+     * @return 笔记ID集合
+     */
+    public HashSet<Long> getSelectedItemIds() {
+        HashSet<Long> ids = new HashSet<>();
+        for (Map.Entry<Long, Boolean> entry : mSelectedIndex.entrySet()) {
+            if (entry.getValue()) {
+                ids.add(entry.getKey());
+            }
+        }
+        return ids;
+    }
+
+    /**
+     * 获取所有已选中笔记关联的桌面小部件信息
+     * @return 小部件属性集合
+     */
+    public HashSet<AppWidgetAttribute> getSelectedWidget() {
+        HashSet<AppWidgetAttribute> widgets = new HashSet<>();
+        Cursor c = getCursor();
+        if (c != null) {
+            int widgetIdIdx = c.getColumnIndex(NoteColumns.WIDGET_ID);
+            int widgetTypeIdx = c.getColumnIndex(NoteColumns.TYPE);
+
+            for (int i = 0; i < c.getCount(); i++) {
+                if (c.moveToPosition(i)) {
+                    long id = c.getLong(ID);
+                    if (mSelectedIndex.containsKey(id) && mSelectedIndex.get(id)) {
+                        AppWidgetAttribute widget = new AppWidgetAttribute();
+                        if (widgetIdIdx >= 0) widget.widgetId = c.getInt(widgetIdIdx);
+                        if (widgetTypeIdx >= 0) widget.widgetType = c.getInt(widgetTypeIdx);
+                        widgets.add(widget);
+                    }
+                }
+            }
+        }
+        return widgets;
+    }
+
+    @Override
+    public NoteItemData getItem(int position) {
+        Cursor c = getCursor();
+        if (c.moveToPosition(position)) {
+            return new NoteItemData(mContext, c);
+        }
+        return null;
+    }
+}

ui/NotesListItem.java

@@ -0,0 +1,164 @@
+/*
+ * 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 android.text.format.DateFormat;
+import android.view.View;
+import android.widget.CheckBox;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+// ... existing code ...
+
+/**
+ * 笔记列表项视图
+ *
+ * 【功能说明】
+ * 1. 自定义LinearLayout，用于显示笔记列表中的每一项
+ * 2. 根据笔记类型（普通笔记/文件夹）显示不同的内容
+ * 3. 支持多选模式和勾选框显示
+ * 4. 显示提醒图标、标题、时间等信息
+ */
+public class NotesListItem extends LinearLayout {
+    private ImageView mAlert;
+    private TextView mTitle;
+    private TextView mTime;
+    private CheckBox mCheckBox;
+    private NoteItemData mItemData;
+
+    /**
+     * 构造函数：初始化视图组件
+     * @param context 上下文对象
+     */
+    public NotesListItem(Context context) {
+        super(context);
+        inflate(context, R.layout.note_item, this);
+        mAlert = (ImageView) findViewById(R.id.iv_alert_icon);
+        mTitle = (TextView) findViewById(R.id.tv_title);
+        mTime = (TextView) findViewById(R.id.tv_time);
+        mCheckBox = (CheckBox) findViewById(android.R.id.checkbox);
+    }
+
+    /**
+     * 绑定数据到视图
+     * @param context 上下文对象
+     * @param data 笔记项数据
+     * @param choiceMode 是否为多选模式
+     * @param checked 是否被选中
+     */
+    public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
+        if (data == null) return;
+        mItemData = data;
+
+        // 处理多选模式下的勾选框显示
+        if (choiceMode && data.getType() == Notes.TYPE_NOTE) {
+            mCheckBox.setVisibility(View.VISIBLE);
+            mCheckBox.setChecked(checked);
+        } else {
+            mCheckBox.setVisibility(View.GONE);
+        }
+
+        // 根据笔记类型显示不同内容
+        if (data.getType() == Notes.TYPE_NOTE) {
+            // 普通笔记：显示提醒图标、内容摘要和时间
+            mAlert.setVisibility(data.hasAlert() ? View.VISIBLE : View.GONE);
+            if (!TextUtils.isEmpty(data.getSnippet())) {
+                mTitle.setText(data.getSnippet());
+            } else {
+                mTitle.setText(context.getString(R.string.notelist_string_info));
+            }
+
+            // 根据修改日期和提醒日期决定显示哪个时间
+            if (data.getModifiedDate() - data.getAlertDate() >= 0) {
+                // 显示修改时间
+                if (DateFormat.is24HourFormat(context)) {
+                    mTime.setText(new SimpleDateFormat("yyyy-MM-dd HH:mm").format(new Date(data.getModifiedDate())));
+                } else {
+                    mTime.setText(DateFormat.format("yyyy-MM-dd hh:mm aa", data.getModifiedDate()));
+                }
+            } else {
+                // 显示提醒时间
+                if (DateFormat.is24HourFormat(context)) {
+                    mTime.setText(new SimpleDateFormat("MM-dd HH:mm").format(new Date(data.getAlertDate())));
+                } else {
+                    mTime.setText(DateFormat.format("MM-dd hh:mm aa", data.getAlertDate()));
+                }
+            }
+        } else if (data.getType() == Notes.TYPE_FOLDER) {
+            // 文件夹：隐藏提醒图标，显示文件夹名称和笔记数量
+            mAlert.setVisibility(View.GONE);
+            mTitle.setText(data.getSnippet());
+            mTime.setText("(" + data.getNotesCount() + ")");
+        }
+    }
+
+    /**
+     * 获取绑定的笔记项数据
+     * @return 笔记项数据对象
+     */
+    public NoteItemData getItemData() {
+        return mItemData;
+    }
+
+    /**
+     * 笔记项数据内部类（简化版）
+     * 注意：此内部类与外部的NoteItemData类重复，建议删除
+     */
+    public static class NoteItemData {
+        private long mId;
+        private long mAlertDate;
+        private int mBgColorId;
+        private int mType;
+        private String mSnippet;
+        private long mModifiedDate;
+        private long mParentId;
+        private int mNotesCount;
+
+        public NoteItemData(Context context, Cursor cursor) {
+            mId = cursor.getLong(0);
+            mSnippet = cursor.getString(1);
+            mType = cursor.getInt(2);
+            mModifiedDate = cursor.getLong(3);
+            mAlertDate = cursor.getLong(4);
+            mBgColorId = cursor.getInt(5);
+            mParentId = cursor.getLong(7);
+            // 简单处理数量，避免引用报错的方法
+            mNotesCount = (mType == Notes.TYPE_FOLDER) ? 0 : 1;
+        }
+
+        public long getId() { return mId; }
+        public long getAlertDate() { return mAlertDate; }
+        public int getBgColorId() { return mBgColorId; }
+        public int getType() { return mType; }
+        public String getSnippet() { return mSnippet; }
+        public long getModifiedDate() { return mModifiedDate; }
+        public long getParentId() { return mParentId; }
+        public int getNotesCount() { return mNotesCount; }
+        public boolean hasAlert() { return mAlertDate > 0; }
+    }
+}
+

ui/NotesPreferenceActivity.java

@@ -0,0 +1,420 @@
+/*
+ * 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;
+import android.app.ActionBar;
+import android.app.AlertDialog;
+import android.content.BroadcastReceiver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+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;
+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;
+import net.micode.notes.gtask.remote.GTaskSyncService;
+
+// ... existing code ...
+
+/**
+ * 笔记偏好设置活动
+ *
+ * 【功能说明】
+ * 1. 管理Google账户同步设置
+ * 2. 显示和控制同步状态
+ * 3. 选择和管理同步账户
+ * 4. 记录最后同步时间
+ * 5. 提供同步手动触发功能
+ */
+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;
+
+    /**
+     * 静态方法：判断当前是否为同步模式
+     * @param context 上下文对象
+     * @return true表示已设置同步账户
+     */
+    public static boolean isSyncMode(Context context) {
+        return !TextUtils.isEmpty(getSyncAccountName(context));
+    }
+
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+        getActionBar().setDisplayHomeAsUpEnabled(true);
+        addPreferencesFromResource(R.xml.preferences);
+        mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);
+        mReceiver = new GTaskReceiver();
+        // 注册广播接收器，监听同步状态变化
+        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) {
+            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() {
+        if (mReceiver != null) {
+            unregisterReceiver(mReceiver);
+        }
+        super.onDestroy();
+    }
+
+    /**
+     * 加载账户偏好设置项
+     * 创建账户选择 preference 并设置点击事件
+     */
+    private void loadAccountPreference() {
+        mAccountCategory.removeAll();
+        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);
+            }
+        }
+    }
+
+    /**
+     * 刷新UI界面
+     * 重新加载账户偏好和同步按钮状态
+     */
+    private void refreshUI() {
+        loadAccountPreference();
+        loadSyncButton();
+    }
+
+    /**
+     * 显示选择账户对话框
+     * 列出所有Google账户供用户选择
+     */
+    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);
+        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) {
+                            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();
+            }
+        });
+    }
+
+    /**
+     * 显示更改账户确认对话框
+     * 提供更改账户、移除账户、取消三个选项
+     */
+    private void showChangeAccountConfirmAlertDialog() {
+        AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
+        View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
+        TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
+        titleTextView.setText(getString(R.string.preferences_dialog_change_account_title,
+                getSyncAccountName(this)));
+        TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
+        subtitleTextView.setText(getString(R.string.preferences_dialog_change_account_warn_msg));
+        dialogBuilder.setCustomTitle(titleView);
+        CharSequence[] menuItemArray = new CharSequence[] {
+                getString(R.string.preferences_menu_change_account),
+                getString(R.string.preferences_menu_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();
+                }
+            }
+        });
+        dialogBuilder.show();
+    }
+
+    /**
+     * 获取所有Google账户
+     * @return Google账户数组
+     */
+    private Account[] getGoogleAccounts() {
+        AccountManager accountManager = AccountManager.get(this);
+        return accountManager.getAccountsByType("com.google");
+    }
+
+    /**
+     * 设置同步账户
+     * 清除旧的同步ID，准备重新同步
+     * @param account 账户名称
+     */
+    private void setSyncAccount(String account) {
+        if (!getSyncAccountName(this).equals(account)) {
+            SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
+            SharedPreferences.Editor editor = settings.edit();
+            if (account != null) {
+                editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, account);
+            } else {
+                editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
+            }
+            editor.commit();
+            setLastSyncTime(this, 0);
+            // 异步清除所有笔记的GTask ID和Sync ID
+            new Thread(new Runnable() {
+                public void run() {
+                    ContentValues values = new ContentValues();
+                    values.put(NoteColumns.GTASK_ID, "");
+                    values.put(NoteColumns.SYNC_ID, 0);
+                    getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
+                }
+            }).start();
+            Toast.makeText(NotesPreferenceActivity.this,
+                    getString(R.string.preferences_toast_success_set_accout, account),
+                    Toast.LENGTH_SHORT).show();
+        }
+    }
+
+    /**
+     * 移除同步账户
+     * 清除账户信息和同步时间，重置同步状态
+     */
+    private void removeSyncAccount() {
+        SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
+        SharedPreferences.Editor editor = settings.edit();
+        if (settings.contains(PREFERENCE_SYNC_ACCOUNT_NAME)) {
+            editor.remove(PREFERENCE_SYNC_ACCOUNT_NAME);
+        }
+        if (settings.contains(PREFERENCE_LAST_SYNC_TIME)) {
+            editor.remove(PREFERENCE_LAST_SYNC_TIME);
+        }
+        editor.commit();
+        // 异步清除所有笔记的GTask ID和Sync ID
+        new Thread(new Runnable() {
+            public void run() {
+                ContentValues values = new ContentValues();
+                values.put(NoteColumns.GTASK_ID, "");
+                values.put(NoteColumns.SYNC_ID, 0);
+                getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
+            }
+        }).start();
+    }
+
+    /**
+     * 静态方法：获取同步账户名称
+     * @param context 上下文对象
+     * @return 账户名称，未设置则返回空字符串
+     */
+    public static String getSyncAccountName(Context context) {
+        SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
+        return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
+    }
+
+    /**
+     * 静态方法：设置最后同步时间
+     * @param context 上下文对象
+     * @param time 同步时间戳
+     */
+    public static void setLastSyncTime(Context context, long time) {
+        SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
+        SharedPreferences.Editor editor = settings.edit();
+        editor.putLong(PREFERENCE_LAST_SYNC_TIME, time);
+        editor.commit();
+    }
+
+    /**
+     * 静态方法：获取最后同步时间
+     * @param context 上下文对象
+     * @return 同步时间戳，未同步过则返回0
+     */
+    public static long getLastSyncTime(Context context) {
+        SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
+        return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);
+    }
+
+    /**
+     * Google任务同步广播接收器
+     * 监听同步进度和状态变化
+     */
+    private class GTaskReceiver extends BroadcastReceiver {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            refreshUI();
+            if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {
+                TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
+                syncStatus.setText(intent.getStringExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_PROGRESS_MSG));
+            }
+        }
+    }
+
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+            case android.R.id.home:
+                // 返回首页
+                Intent intent = new Intent(this, NotesListActivity.class);
+                intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+                startActivity(intent);
+                return true;
+            default:
+                return false;
+        }
+    }
+}