121212121212121212121212

NotesListAdapter.java

@@ -1,207 +0,0 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/*功能:在Android应用中显示和管理笔记列表,提供了选中项的管理功能，如全选、全不选、获取选中项的ID集合和小部件属性集合等。
-实现方法：通过编写自定义函数CursorAdapter的方法，实现了将数据库中的笔记数据绑定到视图上的功能，并通过一系列辅助方法提供了选中项的管理功能*/
-// 导入必要的包和类
-package net.micode.notes.ui; // 包名
-     
-import android.content.Context; // 上下文，用于与Android系统交互
-import android.database.Cursor; // 数据库游标，用于遍历数据库查询结果
-import android.util.Log; // 日志工具类，用于输出日志信息
-import android.view.View; // 视图基类
-import android.view.ViewGroup; // 视图组基类
-import android.widget.CursorAdapter; // 适配器基类，用于将数据库查询结果绑定到视图上
-
-import net.micode.notes.data.Notes; // 假设这是包含笔记相关常量和方法的类
-
-import java.util.Collection; // 集合接口
-import java.util.HashMap; // 哈希映射接口，用于存储键值对
-import java.util.HashSet; // 哈希集合类，不允许重复元素
-import java.util.Iterator; // 迭代器接口，用于遍历集合
-                    
-// NotesListAdapter类，继承自CursorAdapter，用于将笔记数据绑定到视图
-public class NotesListAdapter extends CursorAdapter {
-    // 定义日志标签
-    private static final String TAG = "NotesListAdapter";
-    
-    // 上下文对象，用于与Android系统交互
-    private Context mContext;
-    
-    // 存储选中项的哈希映射，键为位置索引，值为选中状态（true表示选中）
-    private HashMap<Integer, Boolean> mSelectedIndex;
-    
-    // 笔记总数
-    private int mNotesCount;
-    
-    // 标记是否处于选择模式
-    private boolean mChoiceMode;
-
-    // 定义一个静态内部类，用于存储小部件的属性
-    public static class AppWidgetAttribute {
-        public int widgetId; // 小部件ID
-        public int widgetType; // 小部件类型
-    }
-
-    // 构造函数，初始化成员变量
-    public NotesListAdapter(Context context) {
-        super(context, null); // 调用父类构造函数
-        mSelectedIndex = new HashMap<>(); // 初始化选中项的哈希映射
-        mContext = context; // 初始化上下文对象
-        mNotesCount = 0; // 初始化笔记总数为0
-    }
-
-    // 重写newView方法，用于创建新的视图对象
-    @Override
-    public View newView(Context context, Cursor cursor, ViewGroup parent) {
-        return new NotesListItem(context); // 创建一个NotesListItem视图对象
-    }
-
-    // 重写bindView方法，用于绑定视图数据
-    @Override
-    public void bindView(View view, Context context, Cursor cursor) {
-        if (view instanceof NotesListItem) { // 如果视图是NotesListItem的实例
-            NoteItemData itemData = new NoteItemData(context, cursor); // 创建一个NoteItemData对象，用于存储笔记数据
-            ((NotesListItem) view).bind(context, itemData, mChoiceMode, isSelectedItem(cursor.getPosition())); // 绑定数据到视图
-        }
-    }
-
-    // 设置指定位置的项为选中或未选中状态
-    public void setCheckedItem(final int position, final boolean checked) {
-        mSelectedIndex.put(position, checked); // 更新选中项的哈希映射
-        notifyDataSetChanged(); // 通知数据集已更改，刷新视图
-    }
-
-    // 获取是否处于选择模式
-    public boolean isInChoiceMode() {
-        return mChoiceMode;
-    }
-           
-    // 设置是否处于选择模式
-    public void setChoiceMode(boolean mode) {
-        mSelectedIndex.clear(); // 清空选中项的哈希映射
-        mChoiceMode = mode; // 更新选择模式状态
-    }
-             
-    // 全选或全不选
-    public void selectAll(boolean checked) {
-        Cursor cursor = getCursor(); // 获取游标
-        for (int i = 0; i < getCount(); i++) { // 遍历所有项
-            if (cursor.moveToPosition(i)) { // 移动到指定位置
-                if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) { // 如果是笔记类型
-                    setCheckedItem(i, checked); // 设置选中状态
-                }
-            }
-        }
-    }
-
-    // 获取选中项的ID集合
-    public HashSet<Long> getSelectedItemIds() {
-        HashSet<Long> itemSet = new HashSet<>(); // 创建一个空的哈希集合
-        for (Integer position : mSelectedIndex.keySet()) { // 遍历选中项的哈希映射的键集
-            if (mSelectedIndex.get(position) == true) { // 如果选中状态为true
-                Long id = getItemId(position); // 获取项的ID
-                if (id == Notes.ID_ROOT_FOLDER) { // 如果是根文件夹ID，则忽略
-                    Log.d(TAG, "Wrong item id, should not happen"); // 输出日志信息
-                } else {
-                    itemSet.add(id); // 添加ID到集合
-                }
-            }
-        }
-        return itemSet; // 返回选中项的ID集合
-    }
-
-    // 获取选中项的小部件属性集合
-    public HashSet<AppWidgetAttribute> getSelectedWidget() {
-        HashSet<AppWidgetAttribute> itemSet = new HashSet<>(); // 创建一个空的哈希集合
-        for (Integer position : mSelectedIndex.keySet()) { // 遍历选中项的哈希映射的键集
-            if (mSelectedIndex.get(position) == true) { // 如果选中状态为true
-                Cursor c = (Cursor) getItem(position); // 获取项的游标
-                if (c != null) { // 如果游标不为空
-                    AppWidgetAttribute widget = new AppWidgetAttribute(); // 创建一个AppWidgetAttribute对象
-                    NoteItemData item = new NoteItemData(mContext, c); // 创建一个NoteItemData对象，用于存储笔记数据
-                    widget.widgetId = item.getWidgetId(); // 获取小部件ID
-                    widget.widgetType = item.getWidgetType(); // 获取小部件类型
-                    itemSet.add(widget); // 添加小部件属性到集合
-                    // 注意：这里不应该关闭游标，因为适配器会管理游标的生命周期
-                } else {
-                    Log.e(TAG, "Invalid cursor"); // 输出错误日志信息
-                    return null; // 返回null表示出错
-                }
-            }
-        }
-        return itemSet; // 返回选中项的小部件属性集合
-    }
-
-    // 获取选中项的数量
-    public int getSelectedCount() {
-        Collection<Boolean> values = mSelectedIndex.values(); // 获取选中项的哈希映射的值集
-        if (null == values) {
-            return 0; // 如果值集为空，则返回0
-        }
-        Iterator<Boolean> iter = values.iterator(); // 创建一个迭代器，用于遍历值集
-        int count = 0; // 初始化计数器为0
-        while (iter.hasNext()) { // 遍历值集
-            if (true == iter.next()) { // 如果值为true，表示选中
-                count++; // 计数器加1
-            }
-        }
-        return count; // 返回选中项的数量
-    }
-
-    // 判断是否全部选中
-    public boolean isAllSelected() {
-        int checkedCount = getSelectedCount(); // 获取选中项的数量
-        return (checkedCount != 0 && checkedCount == mNotesCount); // 如果选中项的数量不为0且等于笔记总数，则返回true
-    }
-
-    // 判断指定位置的项是否被选中
-    public boolean isSelectedItem(final int position) {
-        if (null == mSelectedIndex.get(position)) { // 如果选中项的哈希映射中不存在指定位置的键
-            return false; // 返回false表示未选中
-        }
-        return mSelectedIndex.get(position); // 返回选中项的哈希映射中指定位置的值（选中状态）
-    }
-
-    // 当数据集内容发生变化时调用此方法
-    @Override
-    protected void onContentChanged() {
-        super.onContentChanged(); // 调用父类方法
-        calcNotesCount(); // 计算笔记总数
-    }
-
-    // 当游标发生变化时调用此方法
-    @Override
-    public void changeCursor(Cursor cursor) {
-        super.changeCursor(cursor); // 调用父类方法
-        calcNotesCount(); // 计算笔记总数
-    }
-
-    // 计算笔记总数的方法
-    private void calcNotesCount() {
-        mNotesCount = 0; // 初始化笔记总数为0
-        for (int i = 0; i < getCount(); i++) { // 遍历所有项
-            Cursor c = (Cursor) getItem(i); // 获取项的游标
-            if (c != null) { // 如果游标不为空
-                if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) { // 如果是笔记类型
-                    mNotesCount++; // 笔记总数加1
-                }
-            } else {
-                Log.e(TAG, "Invalid cursor"); // 输出错误日志信息
-                return; // 提前返回，结束方法执行
-            }
-        }
-    }
-}            

NotesListItem.java

@@ -1,142 +0,0 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-//实现功能：显示笔记列表项，包含了标题、时间、警告图标、呼叫名称（针对通话记录）和一个选择框。
-//根据传入的数据类型（笔记或文件夹），它会动态地调整视图的显示，包括背景、警告图标、标题文本等。
-
-package net.micode.notes.ui;
-
-// 导入必要的包和类
-import android.content.Context;
-import android.text.format.DateUtils;
-import android.view.View;
-import android.widget.CheckBox;
-import android.widget.ImageView;
-import android.widget.LinearLayout;
-import android.widget.TextView;
-
-import net.micode.notes.R;
-import net.micode.notes.data.Notes;
-import net.micode.notes.tool.DataUtils;
-import net.micode.notes.tool.ResourceParser.NoteItemBgResources;
-
-// 自定义的LinearLayout，用于显示笔记列表项
-public class NotesListItem extends LinearLayout {
-    // 视图组件
-    private ImageView mAlert; // 警告图标
-    private TextView mTitle;  // 标题
-    private TextView mTime;   // 时间
-    private TextView mCallName; // 呼叫名称（针对通话记录）
-    private NoteItemData mItemData; // 当前项的数据
-    private CheckBox mCheckBox; // 选择框
-
-    // 构造函数，初始化视图
-    public NotesListItem(Context context) {
-        super(context);
-        inflate(context, R.layout.note_item, this); // 加载布局文件
-        // 初始化视图组件
-        mAlert = findViewById(R.id.iv_alert_icon);
-        mTitle = findViewById(R.id.tv_title);
-        mTime = findViewById(R.id.tv_time);
-        mCallName = findViewById(R.id.tv_name);
-        mCheckBox = findViewById(android.R.id.checkbox); // 注意：这里使用了Android内置的ID
-    }
-
-    // 绑定数据到视图
-    public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
-        // 根据choiceMode和数据类型设置CheckBox的可见性
-        if (choiceMode && data.getType() == Notes.TYPE_NOTE) {
-            mCheckBox.setVisibility(View.VISIBLE);
-            mCheckBox.setChecked(checked);
-        } else {
-            mCheckBox.setVisibility(View.GONE);
-        }
-
-        mItemData = data; // 保存数据
-
-        // 根据数据的不同情况设置不同的视图显示
-        if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
-            // 如果是通话记录文件夹
-            mCallName.setVisibility(View.GONE);
-            mAlert.setVisibility(View.VISIBLE);
-            mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
-            mTitle.setText(context.getString(R.string.call_record_folder_name)
-                    + context.getString(R.string.format_folder_files_count, data.getNotesCount()));
-            mAlert.setImageResource(R.drawable.call_record);
-        } else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
-            // 如果是通话记录文件夹下的项
-            mCallName.setVisibility(View.VISIBLE);
-            mCallName.setText(data.getCallName());
-            mTitle.setTextAppearance(context, R.style.TextAppearanceSecondaryItem);
-            mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
-            if (data.hasAlert()) {
-                mAlert.setImageResource(R.drawable.clock);
-                mAlert.setVisibility(View.VISIBLE);
-            } else {
-                mAlert.setVisibility(View.GONE);
-            }
-        } else {
-            // 其他情况
-            mCallName.setVisibility(View.GONE);
-            mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
-
-            if (data.getType() == Notes.TYPE_FOLDER) {
-                // 如果是文件夹
-                mTitle.setText(data.getSnippet()
-                        + context.getString(R.string.format_folder_files_count, data.getNotesCount()));
-                mAlert.setVisibility(View.GONE);
-            } else {
-                // 如果是笔记
-                mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
-                if (data.hasAlert()) {
-                    mAlert.setImageResource(R.drawable.clock);
-                    mAlert.setVisibility(View.VISIBLE);
-                } else {
-                    mAlert.setVisibility(View.GONE);
-                }
-            }
-        }
-        // 设置时间
-        mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));
-
-        // 设置背景
-        setBackground(data);
-    }
-
-    // 根据数据设置背景
-    private void setBackground(NoteItemData data) {
-        int id = data.getBgColorId(); // 获取背景颜色ID
-        if (data.getType() == Notes.TYPE_NOTE) {
-            // 如果是笔记，根据笔记的位置设置不同的背景
-            if (data.isSingle() || data.isOneFollowingFolder()) {
-                setBackgroundResource(NoteItemBgResources.getNoteBgSingleRes(id));
-            } else if (data.isLast()) {
-                setBackgroundResource(NoteItemBgResources.getNoteBgLastRes(id));
-            } else if (data.isFirst() || data.isMultiFollowingFolder()) {
-                setBackgroundResource(NoteItemBgResources.getNoteBgFirstRes(id));
-            } else {
-                setBackgroundResource(NoteItemBgResources.getNoteBgNormalRes(id));
-            }
-        } else {
-            // 如果是文件夹，设置统一的背景
-            setBackgroundResource(NoteItemBgResources.getFolderBgRes());
-        }
-    }
-
-    // 获取当前项的数据
-    public NoteItemData getItemData() {
-        return mItemData;
-    }
-}

src/net/micode/notes/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

src/net/micode/notes/.idea/misc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_23" default="true" project-jdk-name="23" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>

src/net/micode/notes/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/notes.iml" filepath="$PROJECT_DIR$/notes.iml" />
+    </modules>
+  </component>
+</project>

src/net/micode/notes/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/../../../.." vcs="Git" />
+  </component>
+</project>

src/net/micode/notes/gtask/exception/Lee11231NetworkFailureException.java

@@ -1,37 +1,37 @@
-/**
- * 文件的版权声明，说明该文件是 MiCode 开源社区的版权所有，并且遵循 Apache License 2.0。
- */
-package net.micode.notes.gtask.exception;
-
-/**
- * NetworkFailureException 类是一个自定义异常类，用于表示网络操作失败的情况。
- * 这个异常通常在网络请求无法成功完成时抛出，例如无法连接到服务器或请求超时。
- */
-public class NetworkFailureException extends Exception {
-    // 序列化ID，用于Java对象的序列化和反序列化。
-    private static final long serialVersionUID = 2107610287180234136L;
-
-    /**
-     * 无参构造函数，创建一个默认的 NetworkFailureException 实例。
-     */
-    public NetworkFailureException() {
-        super();
-    }    
-
-    /**
-     * 带错误消息的构造函数，创建一个带有指定错误消息的 NetworkFailureException 实例。
-     * @param paramString 错误消息。
-     */
-    public NetworkFailureException(String paramString) {
-        super(paramString);
-    }
-
-    /**
-     * 带错误消息和原因的构造函数，创建一个带有指定错误消息和原因的 NetworkFailureException 实例。
-     * @param paramString 错误消息。
-     * @param paramThrowable 导致异常的原因。
-     */
-    public NetworkFailureException(String paramString, Throwable paramThrowable) {
-        super(paramString, paramThrowable);
-    }
+/**
+ * 文件的版权声明，说明该文件是 MiCode 开源社区的版权所有，并且遵循 Apache License 2.0。
+ */
+package net.micode.notes.gtask.exception;
+
+/**
+ * NetworkFailureException 类是一个自定义异常类，用于表示网络操作失败的情况。
+ * 这个异常通常在网络请求无法成功完成时抛出，例如无法连接到服务器或请求超时。
+ */
+public class NetworkFailureException extends Exception {
+    // 序列化ID，用于Java对象的序列化和反序列化。
+    private static final long serialVersionUID = 2107610287180234136L;
+
+    /**
+     * 无参构造函数，创建一个默认的 NetworkFailureException 实例。
+     */
+    public NetworkFailureException() {
+        super();
+    }    
+
+    /**
+     * 带错误消息的构造函数，创建一个带有指定错误消息的 NetworkFailureException 实例。
+     * @param paramString 错误消息。
+     */
+    public NetworkFailureException(String paramString) {
+        super(paramString);
+    }
+
+    /**
+     * 带错误消息和原因的构造函数，创建一个带有指定错误消息和原因的 NetworkFailureException 实例。
+     * @param paramString 错误消息。
+     * @param paramThrowable 导致异常的原因。
+     */
+    public NetworkFailureException(String paramString, Throwable paramThrowable) {
+        super(paramString, paramThrowable);
+    }
 }

src/net/micode/notes/model/Lee11231WorkingNote.java

@@ -0,0 +1,526 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.model;
+
+import android.appwidget.AppWidgetManager;
+import android.content.ContentUris;
+import android.content.Context;
+import android.database.Cursor;
+import android.text.TextUtils;
+import android.util.Log;
+
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.CallNote;
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.DataConstants;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.data.Notes.TextNote;
+import net.micode.notes.tool.ResourceParser.NoteBgResources;
+
+/**
+ * WorkingNote 类表示一个正在工作的笔记实体，包含笔记的数据和相关操作。
+ */
+public class WorkingNote {
+    // 笔记对象
+    private Note mNote;
+    // 笔记ID
+    private long mNoteId;
+    // 笔记内容
+    private String mContent;
+    // 笔记模式
+    private int mMode;
+
+    // 笔记提醒日期
+    private long mAlertDate;
+    // 笔记修改日期
+    private long mModifiedDate;
+    // 笔记背景颜色ID
+    private int mBgColorId;
+    // 笔记小部件ID
+    private int mWidgetId;
+    // 笔记小部件类型
+    private int mWidgetType;
+    // 笔记所属文件夹ID
+    private long mFolderId;
+    // 应用程序上下文
+    private Context mContext;
+    // 日志标签
+    private static final String TAG = "WorkingNote";
+    // 标记笔记是否已删除
+    private boolean mIsDeleted;
+    // 笔记设置更改监听器
+    private NoteSettingChangedListener mNoteSettingStatusListener;
+
+    // 数据库查询时使用的列投影
+    public static final String[] DATA_PROJECTION = new String[] {
+            DataColumns.ID,
+            DataColumns.CONTENT,
+            DataColumns.MIME_TYPE,
+            DataColumns.DATA1,
+            DataColumns.DATA2,
+            DataColumns.DATA3,
+            DataColumns.DATA4,
+    };
+
+    // 笔记数据库查询时使用的列投影
+    public static final String[] NOTE_PROJECTION = new String[] {
+            NoteColumns.PARENT_ID,
+            NoteColumns.ALERTED_DATE,
+            NoteColumns.BG_COLOR_ID,
+            NoteColumns.WIDGET_ID,
+            NoteColumns.WIDGET_TYPE,
+            NoteColumns.MODIFIED_DATE
+    };
+
+    // 数据库查询列的索引
+    private static final int DATA_ID_COLUMN = 0;
+    private static final int DATA_CONTENT_COLUMN = 1;
+    private static final int DATA_MIME_TYPE_COLUMN = 2;
+    private static final int DATA_MODE_COLUMN = 3;
+    private static final int NOTE_PARENT_ID_COLUMN = 0;
+    private static final int NOTE_ALERTED_DATE_COLUMN = 1;
+    private static final int NOTE_BG_COLOR_ID_COLUMN = 2;
+    private static final int NOTE_WIDGET_ID_COLUMN = 3;
+    private static final int NOTE_WIDGET_TYPE_COLUMN = 4;
+    private static final int NOTE_MODIFIED_DATE_COLUMN = 5;
+
+    /**
+     * WorkingNote 类的构造函数，用于创建一个新的笔记。
+     *
+     * @param context 应用程序上下文
+     * @param folderId 笔记所属的文件夹ID
+     */
+    private WorkingNote(Context context, long folderId) {
+        mContext = context;
+        mAlertDate = 0;
+        mModifiedDate = System.currentTimeMillis();
+        mFolderId = folderId;
+        mNote = new Note();
+        mNoteId = 0;
+        mIsDeleted = false;
+        mMode = 0;
+        mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
+    }
+
+    /**
+     * WorkingNote 类的构造函数，用于加载一个已存在的笔记。
+     *
+     * @param context 应用程序上下文
+     * @param noteId 笔记ID
+     * @param folderId 笔记所属的文件夹ID
+     */
+    private WorkingNote(Context context, long noteId, long folderId) {
+        mContext = context;
+        mNoteId = noteId;
+        mFolderId = folderId;
+        mIsDeleted = false;
+        mNote = new Note();
+        loadNote();
+    }
+
+    /**
+     * 从数据库加载笔记数据。
+     */
+    private void loadNote() {
+        Cursor cursor = mContext.getContentResolver().query(
+                ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
+                null, null);
+
+        if (cursor != null) {
+            if (cursor.moveToFirst()) {
+                mFolderId = cursor.getLong(NOTE_PARENT_ID_COLUMN);
+                mBgColorId = cursor.getInt(NOTE_BG_COLOR_ID_COLUMN);
+                mWidgetId = cursor.getInt(NOTE_WIDGET_ID_COLUMN);
+                mWidgetType = cursor.getInt(NOTE_WIDGET_TYPE_COLUMN);
+                mAlertDate = cursor.getLong(NOTE_ALERTED_DATE_COLUMN);
+                mModifiedDate = cursor.getLong(NOTE_MODIFIED_DATE_COLUMN);
+            }
+            cursor.close();
+        } else {
+            Log.e(TAG, "No note with id:" + mNoteId);
+            throw new IllegalArgumentException("Unable to find note with id " + mNoteId);
+        }
+        loadNoteData();
+    }
+
+    /**
+     * 从数据库加载笔记的内容数据。
+     */
+    private void loadNoteData() {
+        Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION,
+                DataColumns.NOTE_ID + "=?", new String[] {
+                    String.valueOf(mNoteId)
+                }, null);
+
+        if (cursor != null) {
+            if (cursor.moveToFirst()) {
+                do {
+                    String type = cursor.getString(DATA_MIME_TYPE_COLUMN);
+                    if (DataConstants.NOTE.equals(type)) {
+                        mContent = cursor.getString(DATA_CONTENT_COLUMN);
+                        mMode = cursor.getInt(DATA_MODE_COLUMN);
+                        mNote.setTextDataId(cursor.getLong(DATA_ID_COLUMN));
+                    } else if (DataConstants.CALL_NOTE.equals(type)) {
+                        mNote.setCallDataId(cursor.getLong(DATA_ID_COLUMN));
+                    } else {
+                        Log.d(TAG, "Wrong note type with type:" + type);
+                    }
+                } while (cursor.moveToNext());
+            }
+            cursor.close();
+        } else {
+            Log.e(TAG, "No data with id:" + mNoteId);
+            throw new IllegalArgumentException("Unable to find note's data with id " + mNoteId);
+        }
+    }
+
+    /**
+     * 创建一个空的笔记实例。
+     *
+     * @param context 应用程序上下文
+     * @param folderId 笔记所属的文件夹ID
+     * @param widgetId 笔记小部件ID
+     * @param widgetType 笔记小部件类型
+     * @param defaultBgColorId 默认背景颜色ID
+     * @return 空的笔记实例
+     */
+    public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
+            int widgetType, int defaultBgColorId) {
+        WorkingNote note = new WorkingNote(context, folderId);
+        note.setBgColorId(defaultBgColorId);
+        note.setWidgetId(widgetId);
+        note.setWidgetType(widgetType);
+        return note;
+    }
+
+    /**
+     * 从数据库加载一个笔记实例。
+     *
+     * @param context 应用程序上下文
+     * @param id 笔记ID
+     * @return 笔记实例
+     */
+    public static WorkingNote load(Context context, long id) {
+        return new WorkingNote(context, id, 0);
+    }
+
+    /**
+     * 保存笔记到数据库。
+     *
+     * @return 如果保存成功，返回 true
+     */
+    public synchronized boolean saveNote() {
+        if (isWorthSaving()) {
+            if (!existInDatabase()) {
+                if ((mNoteId = Note.getNewNoteId(mContext, mFolderId)) == 0) {
+                    Log.e(TAG, "Create new note fail with id:" + mNoteId);
+                    return false;
+                }
+            }
+
+            mNote.syncNote(mContext, mNoteId);
+
+            // 如果存在任何小部件，则更新小部件内容
+            if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+                    && mWidgetType != Notes.TYPE_WIDGET_INVALIDE
+                    && mNoteSettingStatusListener != null) {
+                mNoteSettingStatusListener.onWidgetChanged();
+            }
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 检查笔记是否存在于数据库中。
+     *
+     * @return 如果存在，返回 true
+     */
+    public boolean existInDatabase() {
+        return mNoteId > 0;
+    }
+
+    /**
+     * 检查笔记是否值得保存。
+     *
+     * @return 如果值得保存，返回 true
+     */
+    private boolean isWorthSaving() {
+        if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
+                || (existInDatabase() && !mNote.isLocalModified())) {
+            return false;
+        } else {
+            return true;
+        }
+    }
+
+    /**
+     * 设置笔记设置更改监听器。
+     *
+     * @param l 监听器实例
+     */
+    public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
+        mNoteSettingStatusListener = l;
+    }
+
+    /**
+     * 设置提醒日期。
+     *
+     * @param date 提醒日期
+     * @param set 是否设置提醒
+     */
+    public void setAlertDate(long date, boolean set) {
+        if (date != mAlertDate) {
+            mAlertDate = date;
+            mNote.setNoteValue(NoteColumns.ALERTED_DATE, String.valueOf(mAlertDate));
+        }
+        if (mNoteSettingStatusListener != null) {
+            mNoteSettingStatusListener.onClockAlertChanged(date, set);
+        }
+    }
+
+    /**
+     * 标记笔记是否被删除。
+     *
+     * @param mark 是否标记为删除
+     */
+    public void markDeleted(boolean mark) {
+        mIsDeleted = mark;
+        if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+                && mWidgetType != Notes.TYPE_WIDGET_INVALIDE && mNoteSettingStatusListener != null) {
+            mNoteSettingStatusListener.onWidgetChanged();
+        }
+    }
+
+    /**
+     * 设置笔记的背景颜色ID。
+     *
+     * @param id 背景颜色ID
+     */
+    public void setBgColorId(int id) {
+        if (id != mBgColorId) {
+            mBgColorId = id;
+            if (mNoteSettingStatusListener != null) {
+                mNoteSettingStatusListener.onBackgroundColorChanged();
+            }
+            mNote.setNoteValue(NoteColumns.BG_COLOR_ID, String.valueOf(id));
+        }
+    }
+
+    /**
+     * 设置笔记的清单模式。
+     *
+     * @param mode 清单模式
+     */
+    public void setCheckListMode(int mode) {
+        if (mMode != mode) {
+            if (mNoteSettingStatusListener != null) {
+                mNoteSettingStatusListener.onCheckListModeChanged(mMode, mode);
+            }
+            mMode = mode;
+            mNote.setTextData(TextNote.MODE, String.valueOf(mMode));
+        }
+    }
+
+    /**
+     * 设置小部件类型。
+     *
+     * @param type 小部件类型
+     */
+    public void setWidgetType(int type) {
+        if (type != mWidgetType) {
+            mWidgetType = type;
+            mNote.setNoteValue(NoteColumns.WIDGET_TYPE, String.valueOf(mWidgetType));
+        }
+    }
+
+    /**
+     * 设置小部件ID。
+     *
+     * @param id 小部件ID
+     */
+    public void setWidgetId(int id) {
+        if (id != mWidgetId) {
+            mWidgetId = id;
+            mNote.setNoteValue(NoteColumns.WIDGET_ID, String.valueOf(mWidgetId));
+        }
+    }
+
+    /**
+     * 设置笔记的工作文本。
+     *
+     * @param text 笔记内容
+     */
+    public void setWorkingText(String text) {
+        if (!TextUtils.equals(mContent, text)) {
+            mContent = text;
+            mNote.setTextData(DataColumns.CONTENT, mContent);
+        }
+    }
+
+    /**
+     * 将笔记转换为通话记录笔记。
+     *
+     * @param phoneNumber 电话号码
+     * @param callDate 通话日期
+     */
+    public void convertToCallNote(String phoneNumber, long callDate) {
+        mNote.setCallData(CallNote.CALL_DATE, String.valueOf(callDate));
+        mNote.setCallData(CallNote.PHONE_NUMBER, phoneNumber);
+        mNote.setNoteValue(NoteColumns.PARENT_ID, String.valueOf(Notes.ID_CALL_RECORD_FOLDER));
+    }
+
+    /**
+     * 检查笔记是否有提醒。
+     *
+     * @return 如果有提醒，返回 true
+     */
+    public boolean hasClockAlert() {
+        return (mAlertDate > 0 ? true : false);
+    }
+
+    /**
+     * 获取笔记的内容。
+     *
+     * @return 笔记内容
+     */
+    public String getContent() {
+        return mContent;
+    }
+
+    /**
+     * 获取提醒日期。
+     *
+     * @return 提醒日期
+     */
+    public long getAlertDate() {
+        return mAlertDate;
+    }
+
+    /**
+     * 获取笔记的修改日期。
+     *
+     * @return 修改日期
+     */
+    public long getModifiedDate() {
+        return mModifiedDate;
+    }
+
+    /**
+     * 获取背景颜色资源ID。
+     *
+     * @return 背景颜色资源ID
+     */
+    public int getBgColorResId() {
+        return NoteBgResources.getNoteBgResource(mBgColorId);
+    }
+
+    /**
+     * 获取背景颜色ID。
+     *
+     * @return 背景颜色ID
+     */
+    public int getBgColorId() {
+        return mBgColorId;
+    }
+
+    /**
+     * 获取标题背景资源ID。
+     *
+     * @return 标题背景资源ID
+     */
+    public int getTitleBgResId() {
+        return NoteBgResources.getNoteTitleBgResource(mBgColorId);
+    }
+
+    /**
+     * 获取清单模式。
+     *
+     * @return 清单模式
+     */
+    public int getCheckListMode() {
+        return mMode;
+    }
+
+    /**
+     * 获取笔记ID。
+     *
+     * @return 笔记ID
+     */
+    public long getNoteId() {
+        return mNoteId;
+    }
+
+    /**
+     * 获取文件夹ID。
+     *
+     * @return 文件夹ID
+     */
+    public long getFolderId() {
+        return mFolderId;
+    }
+
+    /**
+     * 获取小部件ID。
+     *
+     * @return 小部件ID
+     */
+    public int getWidgetId() {
+        return mWidgetId;
+    }
+
+    /**
+     * 获取小部件类型。
+     *
+     * @return 小部件类型
+     */
+    public int getWidgetType() {
+        return mWidgetType;
+    }
+
+    /**
+     * 笔记设置更改监听器接口。
+     */
+    public interface NoteSettingChangedListener {
+        /**
+         * 当前笔记的背景颜色刚刚更改时调用。
+         */
+        void onBackgroundColorChanged();
+
+        /**
+         * 用户设置时钟时调用。
+         *
+         * @param date 提醒日期
+         * @param set 是否设置提醒
+         */
+        void onClockAlertChanged(long date, boolean set);
+
+        /**
+         * 用户从小部件创建笔记时调用。
+         */
+        void onWidgetChanged();
+
+        /**
+         * 用户在清单模式和普通模式之间切换时调用。
+         *
+         * @param oldMode 更改前的模式
+         * @param newMode 新的模式
+         */
+        void onCheckListModeChanged(int oldMode, int newMode);
+    }
+}

src/net/micode/notes/model/WorkingNote.java

@@ -1,425 +0,0 @@
-/**
- * 文件的版权声明，说明该文件是 MiCode 开源社区的版权所有，并且遵循 Apache License 2.0。
- */
-package net.micode.notes.model;
-
-import android.appwidget.AppWidgetManager;
-import android.content.ContentUris;
-import android.content.Context;
-import android.database.Cursor;
-import android.text.TextUtils;
-import android.util.Log;
-
-import net.micode.notes.data.Notes;
-import net.micode.notes.data.Notes.CallNote;
-import net.micode.notes.data.Notes.DataColumns;
-import net.micode.notes.data.Notes.DataConstants;
-import net.micode.notes.data.Notes.NoteColumns;
-import net.micode.notes.data.Notes.TextNote;
-import net.micode.notes.tool.ResourceParser.NoteBgResources;
-
-/**
- * WorkingNote 类表示一个正在工作的笔记实体，包含笔记的数据和相关操作。
- */
-public class WorkingNote {
-    // 笔记对象。
-    private Note mNote;
-    // 笔记ID。
-    private long mNoteId;
-    // 笔记内容。
-    private String mContent;
-    // 笔记模式。
-    private int mMode;
-
-    // 笔记提醒日期。
-    private long mAlertDate;
-    // 笔记修改日期。
-    private long mModifiedDate;
-    // 笔记背景颜色ID。
-    private int mBgColorId;
-    // 笔记小部件ID。
-    private int mWidgetId;
-    // 笔记小部件类型。
-    private int mWidgetType;
-    // 笔记所属文件夹ID。
-    private long mFolderId;
-    // 应用程序上下文。
-    private Context mContext;
-    // 日志标签。
-    private static final String TAG = "WorkingNote";
-    // 标记笔记是否已删除。
-    private boolean mIsDeleted;
-    // 笔记设置更改监听器。
-    private NoteSettingChangedListener mNoteSettingStatusListener;
-
-    // 数据库查询时使用的列投影。
-    public static final String[] DATA_PROJECTION = new String[] {
-            DataColumns.ID,
-            DataColumns.CONTENT,
-            DataColumns.MIME_TYPE,
-            DataColumns.DATA1,
-            DataColumns.DATA2,
-            DataColumns.DATA3,
-            DataColumns.DATA4,
-    };
-
-    // 笔记数据库查询时使用的列投影。
-    public static final String[] NOTE_PROJECTION = new String[] {
-            NoteColumns.PARENT_ID,
-            NoteColumns.ALERTED_DATE,
-            NoteColumns.BG_COLOR_ID,
-            NoteColumns.WIDGET_ID,
-            NoteColumns.WIDGET_TYPE,
-            NoteColumns.MODIFIED_DATE
-    };
-
-    // 数据库查询列的索引。
-    private static final int DATA_ID_COLUMN = 0;
-    private static final int DATA_CONTENT_COLUMN = 1;
-    private static final int DATA_MIME_TYPE_COLUMN = 2;
-    private static final int DATA_MODE_COLUMN = 3;
-    private static final int NOTE_PARENT_ID_COLUMN = 0;
-    private static final int NOTE_ALERTED_DATE_COLUMN = 1;
-    private static final int NOTE_BG_COLOR_ID_COLUMN = 2;
-    private static final int NOTE_WIDGET_ID_COLUMN = 3;
-    private static final int NOTE_WIDGET_TYPE_COLUMN = 4;
-    private static final int NOTE_MODIFIED_DATE_COLUMN = 5;
-
-    /**
-     * WorkingNote 类的构造函数，用于创建一个新的笔记。
-     * @param context 应用程序上下文。
-     * @param folderId 笔记所属的文件夹ID。
-     */
-    private WorkingNote(Context context, long folderId) {
-        mContext = context;
-        mAlertDate = 0;
-        mModifiedDate = System.currentTimeMillis();
-        mFolderId = folderId;
-        mNote = new Note();
-        mNoteId = 0;
-        mIsDeleted = false;
-        mMode = 0;
-        mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
-    }
-
-    /**
-     * WorkingNote 类的构造函数，用于加载一个已存在的笔记。
-     * @param context 应用程序上下文。
-     * @param noteId 笔记ID。
-     * @param folderId 笔记所属的文件夹ID。
-     */
-    private WorkingNote(Context context, long noteId, long folderId) {
-        mContext = context;
-        mNoteId = noteId;
-        mFolderId = folderId;
-        mIsDeleted = false;
-        mNote = new Note();
-        loadNote();
-    }
-
-    /**
-     * 从数据库加载笔记数据。
-     */
-    private void loadNote() {
-        Cursor cursor = mContext.getContentResolver().query(
-                ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
-                null, null);
-
-        if (cursor != null) {
-            if (cursor.moveToFirst()) {
-                mFolderId = cursor.getLong(NOTE_PARENT_ID_COLUMN);
-                mBgColorId = cursor.getInt(NOTE_BG_COLOR_ID_COLUMN);
-                mWidgetId = cursor.getInt(NOTE_WIDGET_ID_COLUMN);
-                mWidgetType = cursor.getInt(NOTE_WIDGET_TYPE_COLUMN);
-                mAlertDate = cursor.getLong(NOTE_ALERTED_DATE_COLUMN);
-                mModifiedDate = cursor.getLong(NOTE_MODIFIED_DATE_COLUMN);
-            }
-            cursor.close();
-        } else {
-            Log.e(TAG, "No note with id:" + mNoteId);
-            throw new IllegalArgumentException("Unable to find note with id " + mNoteId);
-        }
-        loadNoteData();
-    }
-
-    /**
-     * 从数据库加载笔记的内容数据。
-     */
-    private void loadNoteData() {
-        Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION,
-                DataColumns.NOTE_ID + "=?", new String[] {
-                    String.valueOf(mNoteId)
-                }, null);
-
-        if (cursor != null) {
-            if (cursor.moveToFirst()) {
-                do {
-                    String type = cursor.getString(DATA_MIME_TYPE_COLUMN);
-                    if (DataConstants.NOTE.equals(type)) {
-                        mContent = cursor.getString(DATA_CONTENT_COLUMN);
-                        mMode = cursor.getInt(DATA_MODE_COLUMN);
-                        mNote.setTextDataId(cursor.getLong(DATA_ID_COLUMN));
-                    } else if (DataConstants.CALL_NOTE.equals(type)) {
-                        mNote.setCallDataId(cursor.getLong(DATA_ID_COLUMN));
-                    } else {
-                        Log.d(TAG, "Wrong note type with type:" + type);
-                    }
-                } while (cursor.moveToNext());
-            }
-            cursor.close();
-        } else {
-            Log.e(TAG, "No data with id:" + mNoteId);
-            throw new IllegalArgumentException("Unable to find note's data with id " + mNoteId);
-        }
-    }
-
-    /**
-     * 创建一个空的笔记实例。
-     * @param context 应用程序上下文。
-     * @param folderId 笔记所属的文件夹ID。
-     * @param widgetId 笔记小部件ID。
-     * @param widgetType 笔记小部件类型。
-     * @param defaultBgColorId 默认背景颜色ID。
-     * @return 空的笔记实例。
-     */
-    public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
-            int widgetType, int defaultBgColorId) {
-        WorkingNote note = new WorkingNote(context, folderId);
-        note.setBgColorId(defaultBgColorId);
-        note.setWidgetId(widgetId);
-        note.setWidgetType(widgetType);
-        return note;
-    }
-
-    /**
-     * 从数据库加载一个笔记实例。
-     * @param context 应用程序上下文。
-     * @param id 笔记ID。
-     * @return 笔记实例。
-     */
-    public static WorkingNote load(Context context, long id) {
-        return new WorkingNote(context, id, 0);
-    }
-
-    /**
-     * 保存笔记到数据库。
-     * @return 如果保存成功，返回 true。
-     */
-    public synchronized boolean saveNote() {
-        if (isWorthSaving()) {
-            if (!existInDatabase()) {
-                if ((mNoteId = Note.getNewNoteId(mContext, mFolderId)) == 0) {
-                    Log.e(TAG, "Create new note fail with id:" + mNoteId);
-                    return false;
-                }
-            }
-
-            mNote.syncNote(mContext, mNoteId);
-
-            /**
-             * 如果存在任何小部件，则更新小部件内容
-             */
-            if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
-                    && mWidgetType != Notes.TYPE_WIDGET_INVALIDE
-                    && mNoteSettingStatusListener != null) {
-                mNoteSettingStatusListener.onWidgetChanged();
-            }
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    /**
-     * 检查笔记是否存在于数据库中。
-     * @return 如果存在，返回 true。
-     */
-    public boolean existInDatabase() {
-        return mNoteId > 0;
-    }
-
-    /**
-     * 检查笔记是否值得保存。
-     * @return 如果值得保存，返回 true。
-     */
-    private boolean isWorthSaving() {
-        if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
-                || (existInDatabase() && !mNote.isLocalModified())) {
-            return false;
-        } else {
-            return true;
-        }
-    }
-
-    /**
-     * 设置笔记设置更改监听器。
-     * @param l 监听器实例。
-     */
-    public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
-        mNoteSettingStatusListener = l;
-    }
-
-    /**
-     * 设置提醒日期。
-     * @param date 提醒日期。
-     * @param set 是否设置提醒。
-     */
-    // 设置提醒日期
-public void setAlertDate(long date, boolean set) {
-    // 如果传入的日期与当前提醒日期不同，则更新提醒日期
-    if (date != mAlertDate) {
-        mAlertDate = date;
-        mNote.setNoteValue(NoteColumns.ALERTED_DATE, String.valueOf(mAlertDate));
-    }
-    // 如果设置了监听器，则通知监听器提醒日期已更改
-    if (mNoteSettingStatusListener != null) {
-        mNoteSettingStatusListener.onClockAlertChanged(date, set);
-    }
-}
-
-// 标记笔记是否被删除
-public void markDeleted(boolean mark) {
-    mIsDeleted = mark;
-    // 如果widget ID有效，widget类型有效，且设置了监听器，则通知监听器widget已更改
-    if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
-            && mWidgetType != Notes.TYPE_WIDGET_INVALIDE && mNoteSettingStatusListener != null) {
-        mNoteSettingStatusListener.onWidgetChanged();
-    }
-}
-
-// 设置笔记的背景颜色ID
-public void setBgColorId(int id) {
-    // 如果传入的颜色ID与当前颜色ID不同，则更新颜色ID
-    if (id != mBgColorId) {
-        mBgColorId = id;
-        // 如果设置了监听器，则通知监听器背景颜色已更改
-        if (mNoteSettingStatusListener != null) {
-            mNoteSettingStatusListener.onBackgroundColorChanged();
-        }
-        mNote.setNoteValue(NoteColumns.BG_COLOR_ID, String.valueOf(id));
-    }
-}
-
-// 设置笔记的清单模式
-public void setCheckListMode(int mode) {
-    // 如果传入的模式与当前模式不同，则更新模式
-    if (mMode != mode) {
-        // 如果设置了监听器，则通知监听器清单模式已更改
-        if (mNoteSettingStatusListener != null) {
-            mNoteSettingStatusListener.onCheckListModeChanged(mMode, mode);
-        }
-        mMode = mode;
-        mNote.setTextData(TextNote.MODE, String.valueOf(mMode));
-    }
-}
-
-// 设置widget类型
-public void setWidgetType(int type) {
-    // 如果传入的类型与当前类型不同，则更新类型
-    if (type != mWidgetType) {
-        mWidgetType = type;
-        mNote.setNoteValue(NoteColumns.WIDGET_TYPE, String.valueOf(mWidgetType));
-    }
-}
-
-// 设置widget ID
-public void setWidgetId(int id) {
-    // 如果传入的ID与当前ID不同，则更新ID
-    if (id != mWidgetId) {
-        mWidgetId = id;
-        mNote.setNoteValue(NoteColumns.WIDGET_ID, String.valueOf(mWidgetId));
-    }
-}
-
-// 设置笔记的工作文本
-public void setWorkingText(String text) {
-    // 如果传入的文本与当前文本不同，则更新文本
-    if (!TextUtils.equals(mContent, text)) {
-        mContent = text;
-        mNote.setTextData(DataColumns.CONTENT, mContent);
-    }
-}
-
-// 将笔记转换为通话记录笔记
-public void convertToCallNote(String phoneNumber, long callDate) {
-    mNote.setCallData(CallNote.CALL_DATE, String.valueOf(callDate));
-    mNote.setCallData(CallNote.PHONE_NUMBER, phoneNumber);
-    mNote.setNoteValue(NoteColumns.PARENT_ID, String.valueOf(Notes.ID_CALL_RECORD_FOLDER));
-}
-
-// 检查笔记是否有提醒
-public boolean hasClockAlert() {
-    return (mAlertDate > 0 ? true : false);
-}
-
-// 获取笔记的内容
-public String getContent() {
-    return mContent;
-}
-
-// 获取提醒日期
-public long getAlertDate() {
-    return mAlertDate;
-}
-
-// 获取笔记的修改日期
-public long getModifiedDate() {
-    return mModifiedDate;
-}
-
-// 获取背景颜色资源ID
-public int getBgColorResId() {
-    return NoteBgResources.getNoteBgResource(mBgColorId);
-}
-
-// 获取背景颜色ID
-public int getBgColorId() {
-    return mBgColorId;
-}
-
-// 获取标题背景资源ID
-public int getTitleBgResId() {
-    return NoteBgResources.getNoteTitleBgResource(mBgColorId);
-}
-
-// 获取清单模式
-public int getCheckListMode() {
-    return mMode;
-}
-
-// 获取笔记ID
-public long getNoteId() {
-    return mNoteId;
-}
-
-// 获取文件夹ID
-public long getFolderId() {
-    return mFolderId;
-}
-
-// 获取widget ID
-public int getWidgetId() {
-    return mWidgetId;
-}
-
-// 获取widget类型
-public int getWidgetType() {
-    return mWidgetType;
-}
-
-// 笔记设置更改监听器接口
-public interface NoteSettingChangedListener {
-    // 当前笔记的背景颜色刚刚更改时调用
-    void onBackgroundColorChanged();
-
-    // 用户设置时钟时调用
-    void onClockAlertChanged(long date, boolean set);
-
-    // 用户从widget创建笔记时调用
-    void onWidgetChanged();
-
-    // 用户在清单模式和普通模式之间切换时调用
-    // oldMode 是更改前的模式
-    // newMode 是新的模式
-    void onCheckListModeChanged(int oldMode, int newMode);
-}

src/net/micode/notes/notes.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$" isTestSource="false" packagePrefix="net.micode.notes" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

src/net/micode/notes/tool/ResourceParser.java

@@ -1,262 +0,0 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.micode.notes.tool;
-
-import android.content.Context;
-import android.preference.PreferenceManager;
-
-import net.micode.notes.R;
-import net.micode.notes.ui.NotesPreferenceActivity;
-
-public class ResourceParser {
-
-    // 定义颜色常量
-    public static final int YELLOW           = 0;
-    public static final int BLUE             = 1;
-    public static final int WHITE            = 2;
-    public static final int GREEN            = 3;
-    public static final int RED              = 4;
-
-    // 默认背景颜色
-    public static final int BG_DEFAULT_COLOR = YELLOW;
-
-    // 定义字体大小常量
-    public static final int TEXT_SMALL       = 0;
-    public static final int TEXT_MEDIUM      = 1;
-    public static final int TEXT_LARGE       = 2;
-    public static final int TEXT_SUPER       = 3;
-
-    // 默认字体大小
-    public static final int BG_DEFAULT_FONT_SIZE = TEXT_MEDIUM;
-
-    /**
-     * NoteBgResources 内部类用于管理笔记背景资源。
-     */
-    public static class NoteBgResources {
-        // 编辑状态下的背景资源
-        private final static int [] BG_EDIT_RESOURCES = new int [] {
-            R.drawable.edit_yellow,
-            R.drawable.edit_blue,
-            R.drawable.edit_white,
-            R.drawable.edit_green,
-            R.drawable.edit_red
-        };
-
-        // 编辑状态下标题的背景资源
-        private final static int [] BG_EDIT_TITLE_RESOURCES = new int [] {
-            R.drawable.edit_title_yellow,
-            R.drawable.edit_title_blue,
-            R.drawable.edit_title_white,
-            R.drawable.edit_title_green,
-            R.drawable.edit_title_red
-        };
-
-        /**
-         * 获取笔记背景资源。
-         * @param id 颜色ID。
-         * @return 背景资源ID。
-         */
-        public static int getNoteBgResource(int id) {
-            return BG_EDIT_RESOURCES[id];
-        }
-
-        /**
-         * 获取笔记标题背景资源。
-         * @param id 颜色ID。
-         * @return 标题背景资源ID。
-         */
-        public static int getNoteTitleBgResource(int id) {
-            return BG_EDIT_TITLE_RESOURCES[id];
-        }
-    }
-
-    /**
-     * 获取默认背景ID。
-     * @param context 上下文对象。
-     * @return 默认背景ID。
-     */
-    public static int getDefaultBgId(Context context) {
-        if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean(
-                NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) {
-            // 如果设置了背景颜色，则随机返回一个颜色ID
-            return (int) (Math.random() * NoteBgResources.BG_EDIT_RESOURCES.length);
-        } else {
-            // 否则返回默认背景颜色ID
-            return BG_DEFAULT_COLOR;
-        }
-    }
-
-    /**
-     * NoteItemBgResources 内部类用于管理笔记项背景资源。
-     */
-    public static class NoteItemBgResources {
-        // 第一个笔记项的背景资源
-        private final static int [] BG_FIRST_RESOURCES = new int [] {
-            R.drawable.list_yellow_up,
-            R.drawable.list_blue_up,
-            R.drawable.list_white_up,
-            R.drawable.list_green_up,
-            R.drawable.list_red_up
-        };
-
-        // 普通笔记项的背景资源
-        private final static int [] BG_NORMAL_RESOURCES = new int [] {
-            R.drawable.list_yellow_middle,
-            R.drawable.list_blue_middle,
-            R.drawable.list_white_middle,
-            R.drawable.list_green_middle,
-            R.drawable.list_red_middle
-        };
-
-        // 最后一个笔记项的背景资源
-        private final static int [] BG_LAST_RESOURCES = new int [] {
-            R.drawable.list_yellow_down,
-            R.drawable.list_blue_down,
-            R.drawable.list_white_down,
-            R.drawable.list_green_down,
-            R.drawable.list_red_down,
-        };
-
-        // 单个笔记项的背景资源
-        private final static int [] BG_SINGLE_RESOURCES = new int [] {
-            R.drawable.list_yellow_single,
-            R.drawable.list_blue_single,
-            R.drawable.list_white_single,
-            R.drawable.list_green_single,
-            R.drawable.list_red_single
-        };
-
-        /**
-         * 获取第一个笔记项的背景资源。
-         * @param id 颜色ID。
-         * @return 背景资源ID。
-         */
-        public static int getNoteBgFirstRes(int id) {
-            return BG_FIRST_RESOURCES[id];
-        }
-
-        /**
-         * 获取最后一个笔记项的背景资源。
-         * @param id 颜色ID。
-         * @return 背景资源ID。
-         */
-        public static int getNoteBgLastRes(int id) {
-            return BG_LAST_RESOURCES[id];
-        }
-
-        /**
-         * 获取单个笔记项的背景资源。
-         * @param id 颜色ID。
-         * @return 背景资源ID。
-         */
-        public static int getNoteBgSingleRes(int id) {
-            return BG_SINGLE_RESOURCES[id];
-        }
-
-        /**
-         * 获取普通笔记项的背景资源。
-         * @param id 颜色ID。
-         * @return 背景资源ID。
-         */
-        public static int getNoteBgNormalRes(int id) {
-            return BG_NORMAL_RESOURCES[id];
-        }
-
-        /**
-         * 获取文件夹背景资源。
-         * @return 背景资源ID。
-         */
-        public static int getFolderBgRes() {
-            return R.drawable.list_folder;
-        }
-    }
-
-    /**
-     * WidgetBgResources 内部类用于管理小部件背景资源。
-     */
-    public static class WidgetBgResources {
-        // 2x小部件的背景资源
-        private final static int [] BG_2X_RESOURCES = new int [] {
-            R.drawable.widget_2x_yellow,
-            R.drawable.widget_2x_blue,
-            R.drawable.widget_2x_white,
-            R.drawable.widget_2x_green,
-            R.drawable.widget_2x_red,
-        };
-
-        /**
-         * 获取2x小部件的背景资源。
-         * @param id 颜色ID。
-         * @return 背景资源ID。
-         */
-        public static int getWidget2xBgResource(int id) {
-            return BG_2X_RESOURCES[id];
-        }
-
-        // 4x小部件的背景资源
-        private final static int [] BG_4X_RESOURCES = new int [] {
-            R.drawable.widget_4x_yellow,
-            R.drawable.widget_4x_blue,
-            R.drawable.widget_4x_white,
-            R.drawable.widget_4x_green,
-            R.drawable.widget_4x_red
-        };
-
-        /**
-         * 获取4x小部件的背景资源。
-         * @param id 颜色ID。
-         * @return 背景资源ID。
-         */
-        public static int getWidget4xBgResource(int id) {
-            return BG_4X_RESOURCES[id];
-        }
-    }
-
-    /**
-     * TextAppearanceResources 内部类用于管理文本外观资源。
-     */
-    public static class TextAppearanceResources {
-        // 字体外观资源
-        private final static int [] TEXTAPPEARANCE_RESOURCES = new int [] {
-            R.style.TextAppearanceSmall,
-            R.style.TextAppearanceMedium,
-            R.style.TextAppearanceLarge,
-            R.style.TextAppearanceSuper
-        };
-
-        /**
-         * 获取字体外观资源。
-         * @param id 字体大小ID。
-         * @return 字体外观资源ID。
-         */
-        public static int getTexAppearanceResource(int id) {
-            // 如果ID超出范围，则返回默认字体大小ID
-            if (id >= TEXTAPPEARANCE_RESOURCES.length) {
-                return BG_DEFAULT_FONT_SIZE;
-            }
-            return TEXTAPPEARANCE_RESOURCES[id];
-        }
-
-        /**
-         * 获取字体外观资源的数量。
-         * @return 资源数量。
-         */
-        public static int getResourcesSize() {
-            return TEXTAPPEARANCE_RESOURCES.length;
-        }
-    }
-}

src/net/micode/notes/tool/zhangzhejiaDataUtils.java

@@ -1,359 +1,380 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.micode.notes.tool;
-
-import android.content.ContentProviderOperation;
-import android.content.ContentProviderResult;
-import android.content.ContentResolver;
-import android.content.ContentUris;
-import android.content.ContentValues;
-import android.content.OperationApplicationException;
-import android.database.Cursor;
-import android.os.RemoteException;
-import android.util.Log;
-
-import net.micode.notes.data.Notes;
-import net.micode.notes.data.Notes.CallNote;
-import net.micode.notes.data.Notes.NoteColumns;
-import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-
-
-public class DataUtils {
-    public static final String TAG = "DataUtils";
-
-    /**
-     * 批量删除笔记。
-     * @param resolver ContentResolver实例，用于与内容提供者交互。
-     * @param ids 要删除的笔记ID集合。
-     * @return 如果删除成功返回true，否则返回false。
-     */
-    public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
-        // 如果传入的ID集合为空或者大小为0，则不执行删除操作
-        if (ids == null || ids.size() == 0) {
-            Log.d(TAG, "the ids is null or empty");
-            return true;
-        }
-
-        ArrayList<ContentProviderOperation> operationList = new ArrayList<>();
-        // 遍历ID集合，为每个ID创建一个删除操作
-        for (long id : ids) {
-            if(id == Notes.ID_ROOT_FOLDER) {
-                Log.e(TAG, "Don't delete system folder root");
-                continue;
-            }
-            ContentProviderOperation.Builder builder = ContentProviderOperation
-                    .newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
-            operationList.add(builder.build());
-        }
-        try {
-            // 执行批量操作
-            ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
-            // 如果操作结果为空或者第一个结果为空，则删除失败
-            if (results == null || results.length == 0 || results[0] == null) {
-                Log.d(TAG, "delete notes failed, ids:" + ids.toString());
-                return false;
-            }
-            return true;
-        } catch (RemoteException | OperationApplicationException e) {
-            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
-        }
-        return false;
-    }
-
-    /**
-     * 将笔记移动到指定文件夹。
-     * @param resolver ContentResolver实例。
-     * @param id 要移动的笔记ID。
-     * @param srcFolderId 当前文件夹ID。
-     * @param desFolderId 目标文件夹ID。
-     */
-    public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
-        ContentValues values = new ContentValues();
-        values.put(NoteColumns.PARENT_ID, desFolderId);
-        values.put(NoteColumns.ORIGIN_PARENT_ID, srcFolderId);
-        values.put(NoteColumns.LOCAL_MODIFIED, 1);
-        resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
-    }
-
-    /**
-     * 批量将笔记移动到指定文件夹。
-     * @param resolver ContentResolver实例。
-     * @param ids 要移动的笔记ID集合。
-     * @param folderId 目标文件夹ID。
-     * @return 如果操作成功返回true，否则返回false。
-     */
-    public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids, long folderId) {
-        if (ids == null) {
-            Log.d(TAG, "the ids is null");
-            return true;
-        }
-
-        ArrayList<ContentProviderOperation> operationList = new ArrayList<>();
-        for (long id : ids) {
-            ContentProviderOperation.Builder builder = ContentProviderOperation
-                    .newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
-            builder.withValue(NoteColumns.PARENT_ID, folderId);
-            builder.withValue(NoteColumns.LOCAL_MODIFIED, 1);
-            operationList.add(builder.build());
-        }
-
-        try {
-            ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
-            if (results == null || results.length == 0 || results[0] == null) {
-                Log.d(TAG, "move notes to folder failed, ids:" + ids.toString());
-                return false;
-            }
-            return true;
-        } catch (RemoteException | OperationApplicationException e) {
-            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
-        }
-        return false;
-    }
-
-    /**
-     * 获取用户文件夹的数量（不包括系统文件夹）。
-     * @param resolver ContentResolver实例。
-     * @return 用户文件夹的数量。
-     */
-    public static int getUserFolderCount(ContentResolver resolver) {
-        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
-                new String[] { "COUNT(*)" },
-                NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>?",
-                new String[] { String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLDER) },
-                null);
-        int count = 0;
-        if (cursor != null) {
-            if (cursor.moveToFirst()) {
-                try {
-                    count = cursor.getInt(0);
-                } catch (IndexOutOfBoundsException e) {
-                    Log.e(TAG, "get folder count failed:" + e.toString());
-                } finally {
-                    cursor.close();
-                }
-            }
-        }
-        return count;
-    }
-
-    /**
-     * 检查笔记在数据库中是否可见。
-     * @param resolver ContentResolver实例。
-     * @param noteId 笔记ID。
-     * @param type 笔记类型。
-     * @return 如果笔记可见返回true，否则返回false。
-     */
-    public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
-        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
-                null,
-                NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLDER,
-                new String [] {String.valueOf(type)},
-                null);
-        boolean exist = false;
-        if (cursor != null) {
-            if (cursor.getCount() > 0) {
-                exist = true;
-            }
-            cursor.close();
-        }
-        return exist;
-    }
-
-    /**
-     * 检查笔记是否存在于数据库中。
-     * @param resolver ContentResolver实例。
-     * @param noteId 笔记ID。
-     * @return 如果笔记存在返回true，否则返回false。
-     */
-    public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
-        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
-                null, null, null, null);
-        boolean exist = false;
-        if (cursor != null) {
-            if (cursor.getCount() > 0) {
-                exist = true;
-            }
-            cursor.close();
-        }
-        return exist;
-    }
-
-    public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
-    Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId),
-            null, null, null, null);
-
-    boolean exist = false;
-    if (cursor != null) {
-        if (cursor.getCount() > 0) {
-            exist = true;
-        }
-        cursor.close();
-    }
-    return exist;
-}
-
-    /**
-     * 检查给定名称的文件夹是否可见且存在。
-     * @param resolver ContentResolver实例。
-     * @param name 要检查的文件夹名称。
-     * @return 如果文件夹存在且可见返回true，否则返回false。
-     */
-    public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
-        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,
-                NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER +
-                " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLDER +
-                " AND " + NoteColumns.SNIPPET + "=?",
-                new String[] { name }, null);
-        boolean exist = false;
-        if(cursor != null) {
-            if(cursor.getCount() > 0) {
-                exist = true;
-            }
-            cursor.close();
-        }
-        return exist;
-    }
-
-    /**
-     * 获取文件夹中笔记的小部件属性。
-     * @param resolver ContentResolver实例。
-     * @param folderId 文件夹ID。
-     * @return 包含小部件属性的HashSet，如果未找到则返回null。
-     */
-    public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
-        Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
-                new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE },
-                NoteColumns.PARENT_ID + "=?",
-                new String[] { String.valueOf(folderId) },
-                null);
-
-        HashSet<AppWidgetAttribute> set = null;
-        if (c != null) {
-            if (c.moveToFirst()) {
-                set = new HashSet<AppWidgetAttribute>();
-                do {
-                    try {
-                        AppWidgetAttribute widget = new AppWidgetAttribute();
-                        widget.widgetId = c.getInt(0);
-                        widget.widgetType = c.getInt(1);
-                        set.add(widget);
-                    } catch (IndexOutOfBoundsException e) {
-                        Log.e(TAG, e.toString());
-                    }
-                } while (c.moveToNext());
-            }
-            c.close();
-        }
-        return set;
-    }
-
-    /**
-     * 根据笔记ID获取通话记录中的电话号码。
-     * @param resolver ContentResolver实例。
-     * @param noteId 笔记ID。
-     * @return 电话号码字符串，如果未找到则返回空字符串。
-     */
-    public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
-        Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
-                new String [] { CallNote.PHONE_NUMBER },
-                CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?",
-                new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE },
-                null);
-
-        if (cursor != null && cursor.moveToFirst()) {
-            try {
-                return cursor.getString(0);
-            } catch (IndexOutOfBoundsException e) {
-                Log.e(TAG, "Get call number fails " + e.toString());
-            } finally {
-                cursor.close();
-            }
-        }
-        return "";
-    }
-
-    /**
-     * 根据电话号码和通话日期获取笔记ID。
-     * @param resolver ContentResolver实例。
-     * @param phoneNumber 电话号码。
-     * @param callDate 通话日期。
-     * @return 笔记ID，如果未找到则返回0。
-     */
-    public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
-        Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
-                new String [] { CallNote.NOTE_ID },
-                CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL("
-                + CallNote.PHONE_NUMBER + ",?)",
-                new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber },
-                null);
-
-        if (cursor != null) {
-            if (cursor.moveToFirst()) {
-                try {
-                    return cursor.getLong(0);
-                } catch (IndexOutOfBoundsException e) {
-                    Log.e(TAG, "Get call note id fails " + e.toString());
-                }
-            }
-            cursor.close();
-        }
-        return 0;
-    }
-
-    /**
-     * 根据笔记ID获取摘要。
-     * @param resolver ContentResolver实例。
-     * @param noteId 笔记ID。
-     * @return 摘要字符串，如果未找到则抛出IllegalArgumentException。
-     */
-    public static String getSnippetById(ContentResolver resolver, long noteId) {
-        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
-                new String [] { NoteColumns.SNIPPET },
-                NoteColumns.ID + "=?",
-                new String [] { String.valueOf(noteId)},
-                null);
-
-        if (cursor != null) {
-            String snippet = "";
-            if (cursor.moveToFirst()) {
-                snippet = cursor.getString(0);
-            }
-            cursor.close();
-            return snippet;
-        }
-        throw new IllegalArgumentException("Note is not found with id: " + noteId);
-    }
-
-    /**
-     * 获取格式化后的摘要，去除摘要中的换行符。
-     * @param snippet 原始摘要。
-     * @return 格式化后的摘要。
-     */
-    public static String getFormattedSnippet(String snippet) {
-        if (snippet != null) {
-            snippet = snippet.trim();
-            int index = snippet.indexOf('\n');
-            if (index != -1) {
-                snippet = snippet.substring(0, index);
-            }
-        }
-        return snippet;
-    }
-}
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.tool;
+
+import android.content.ContentProviderOperation;
+import android.content.ContentProviderResult;
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.OperationApplicationException;
+import android.database.Cursor;
+import android.os.RemoteException;
+import android.util.Log;
+
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.CallNote;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+
+/**
+ * DataUtils 类提供了与笔记数据相关的工具方法，包括批量删除、移动笔记、查询文件夹数量等操作。
+ */
+public class DataUtils {
+    public static final String TAG = "DataUtils"; // 日志标签
+
+    /**
+     * 批量删除笔记。
+     *
+     * @param resolver ContentResolver 实例，用于与内容提供者交互。
+     * @param ids 要删除的笔记ID集合。
+     * @return 如果删除成功返回 true，否则返回 false。
+     */
+    public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
+        // 如果传入的ID集合为空或者大小为0，则不执行删除操作
+        if (ids == null || ids.size() == 0) {
+            Log.d(TAG, "the ids is null or empty");
+            return true;
+        }
+
+        ArrayList<ContentProviderOperation> operationList = new ArrayList<>();
+        // 遍历ID集合，为每个ID创建一个删除操作
+        for (long id : ids) {
+            if (id == Notes.ID_ROOT_FOLDER) {
+                Log.e(TAG, "Don't delete system folder root");
+                continue;
+            }
+            ContentProviderOperation.Builder builder = ContentProviderOperation
+                    .newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
+            operationList.add(builder.build());
+        }
+        try {
+            // 执行批量操作
+            ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
+            // 如果操作结果为空或者第一个结果为空，则删除失败
+            if (results == null || results.length == 0 || results[0] == null) {
+                Log.d(TAG, "delete notes failed, ids:" + ids.toString());
+                return false;
+            }
+            return true;
+        } catch (RemoteException | OperationApplicationException e) {
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        }
+        return false;
+    }
+
+    /**
+     * 将笔记移动到指定文件夹。
+     *
+     * @param resolver ContentResolver 实例。
+     * @param id 要移动的笔记ID。
+     * @param srcFolderId 当前文件夹ID。
+     * @param desFolderId 目标文件夹ID。
+     */
+    public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
+        ContentValues values = new ContentValues();
+        values.put(NoteColumns.PARENT_ID, desFolderId);
+        values.put(NoteColumns.ORIGIN_PARENT_ID, srcFolderId);
+        values.put(NoteColumns.LOCAL_MODIFIED, 1);
+        resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
+    }
+
+    /**
+     * 批量将笔记移动到指定文件夹。
+     *
+     * @param resolver ContentResolver 实例。
+     * @param ids 要移动的笔记ID集合。
+     * @param folderId 目标文件夹ID。
+     * @return 如果操作成功返回 true，否则返回 false。
+     */
+    public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids, long folderId) {
+        if (ids == null) {
+            Log.d(TAG, "the ids is null");
+            return true;
+        }
+
+        ArrayList<ContentProviderOperation> operationList = new ArrayList<>();
+        for (long id : ids) {
+            ContentProviderOperation.Builder builder = ContentProviderOperation
+                    .newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
+            builder.withValue(NoteColumns.PARENT_ID, folderId);
+            builder.withValue(NoteColumns.LOCAL_MODIFIED, 1);
+            operationList.add(builder.build());
+        }
+
+        try {
+            ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
+            if (results == null || results.length == 0 || results[0] == null) {
+                Log.d(TAG, "move notes to folder failed, ids:" + ids.toString());
+                return false;
+            }
+            return true;
+        } catch (RemoteException | OperationApplicationException e) {
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        }
+        return false;
+    }
+
+    /**
+     * 获取用户文件夹的数量（不包括系统文件夹）。
+     *
+     * @param resolver ContentResolver 实例。
+     * @return 用户文件夹的数量。
+     */
+    public static int getUserFolderCount(ContentResolver resolver) {
+        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
+                new String[]{"COUNT(*)"},
+                NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>?",
+                new String[]{String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLDER)},
+                null);
+        int count = 0;
+        if (cursor != null) {
+            if (cursor.moveToFirst()) {
+                try {
+                    count = cursor.getInt(0);
+                } catch (IndexOutOfBoundsException e) {
+                    Log.e(TAG, "get folder count failed:" + e.toString());
+                } finally {
+                    cursor.close();
+                }
+            }
+        }
+        return count;
+    }
+
+    /**
+     * 检查笔记在数据库中是否可见。
+     *
+     * @param resolver ContentResolver 实例。
+     * @param noteId 笔记ID。
+     * @param type 笔记类型。
+     * @return 如果笔记可见返回 true，否则返回 false。
+     */
+    public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
+        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
+                null,
+                NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLDER,
+                new String[]{String.valueOf(type)},
+                null);
+        boolean exist = false;
+        if (cursor != null) {
+            if (cursor.getCount() > 0) {
+                exist = true;
+            }
+            cursor.close();
+        }
+        return exist;
+    }
+
+    /**
+     * 检查笔记是否存在于数据库中。
+     *
+     * @param resolver ContentResolver 实例。
+     * @param noteId 笔记ID。
+     * @return 如果笔记存在返回 true，否则返回 false。
+     */
+    public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
+        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
+                null, null, null, null);
+        boolean exist = false;
+        if (cursor != null) {
+            if (cursor.getCount() > 0) {
+                exist = true;
+            }
+            cursor.close();
+        }
+        return exist;
+    }
+
+    /**
+     * 检查数据是否存在于数据库中。
+     *
+     * @param resolver ContentResolver 实例。
+     * @param dataId 数据ID。
+     * @return 如果数据存在返回 true，否则返回 false。
+     */
+    public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
+        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId),
+                null, null, null, null);
+
+        boolean exist = false;
+        if (cursor != null) {
+            if (cursor.getCount() > 0) {
+                exist = true;
+            }
+            cursor.close();
+        }
+        return exist;
+    }
+
+    /**
+     * 检查给定名称的文件夹是否可见且存在。
+     *
+     * @param resolver ContentResolver 实例。
+     * @param name 要检查的文件夹名称。
+     * @return 如果文件夹存在且可见返回 true，否则返回 false。
+     */
+    public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
+        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,
+                NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER +
+                        " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLDER +
+                        " AND " + NoteColumns.SNIPPET + "=?",
+                new String[]{name}, null);
+        boolean exist = false;
+        if (cursor != null) {
+            if (cursor.getCount() > 0) {
+                exist = true;
+            }
+            cursor.close();
+        }
+        return exist;
+    }
+
+    /**
+     * 获取文件夹中笔记的小部件属性。
+     *
+     * @param resolver ContentResolver 实例。
+     * @param folderId 文件夹ID。
+     * @return 包含小部件属性的 HashSet，如果未找到则返回 null。
+     */
+    public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
+        Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
+                new String[]{NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE},
+                NoteColumns.PARENT_ID + "=?",
+                new String[]{String.valueOf(folderId)},
+                null);
+
+        HashSet<AppWidgetAttribute> set = null;
+        if (c != null) {
+            if (c.moveToFirst()) {
+                set = new HashSet<AppWidgetAttribute>();
+                do {
+                    try {
+                        AppWidgetAttribute widget = new AppWidgetAttribute();
+                        widget.widgetId = c.getInt(0);
+                        widget.widgetType = c.getInt(1);
+                        set.add(widget);
+                    } catch (IndexOutOfBoundsException e) {
+                        Log.e(TAG, e.toString());
+                    }
+                } while (c.moveToNext());
+            }
+            c.close();
+        }
+        return set;
+    }
+
+    /**
+     * 根据笔记ID获取通话记录中的电话号码。
+     *
+     * @param resolver ContentResolver 实例。
+     * @param noteId 笔记ID。
+     * @return 电话号码字符串，如果未找到则返回空字符串。
+     */
+    public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
+        Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
+                new String[]{CallNote.PHONE_NUMBER},
+                CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?",
+                new String[]{String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE},
+                null);
+
+        if (cursor != null && cursor.moveToFirst()) {
+            try {
+                return cursor.getString(0);
+            } catch (IndexOutOfBoundsException e) {
+                Log.e(TAG, "Get call number fails " + e.toString());
+            } finally {
+                cursor.close();
+            }
+        }
+        return "";
+    }
+
+    /**
+     * 根据电话号码和通话日期获取笔记ID。
+     *
+     * @param resolver ContentResolver 实例。
+     * @param phoneNumber 电话号码。
+     * @param callDate 通话日期。
+     * @return 笔记ID，如果未找到则返回 0。
+     */
+    public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
+        Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
+                new String[]{CallNote.NOTE_ID},
+                CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL("
+                        + CallNote.PHONE_NUMBER + ",?)",
+                new String[]{String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber},
+                null);
+
+        if (cursor != null) {
+            if (cursor.moveToFirst()) {
+                try {
+                    return cursor.getLong(0);
+                } catch (IndexOutOfBoundsException e) {
+                    Log.e(TAG, "Get call note id fails " + e.toString());
+                }
+            }
+            cursor.close();
+        }
+        return 0;
+    }
+
+    /**
+     * 根据笔记ID获取摘要。
+     *
+     * @param resolver ContentResolver 实例。
+     * @param noteId 笔记ID。
+     * @return 摘要字符串，如果未找到则抛出 IllegalArgumentException。
+     */
+    public static String getSnippetById(ContentResolver resolver, long noteId) {
+        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
+                new String[]{NoteColumns.SNIPPET},
+                NoteColumns.ID + "=?",
+                new String[]{String.valueOf(noteId)},
+                null);
+
+        if (cursor != null) {
+            String snippet = "";
+            if (cursor.moveToFirst()) {
+                snippet = cursor.getString(0);
+            }
+            cursor.close();
+            return snippet;
+        }
+        throw new IllegalArgumentException("Note is not found with id: " + noteId);
+    }
+
+    /**
+     * 获取格式化后的摘要，去除摘要中的换行符。
+     *
+     * @param snippet 原始摘要。
+     * @return 格式化后的摘要。
+     */
+    public static String getFormattedSnippet(String snippet) {
+        if (snippet != null) {
+            snippet = snippet.trim();
+            int index = snippet.indexOf('\n');
+            if (index != -1) {
+                snippet = snippet.substring(0, index);
+            }
+        }
+        return snippet;
+    }
+}

src/net/micode/notes/tool/zhangzhejiaResourceParser.java

@@ -0,0 +1,277 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.tool;
+
+import android.content.Context;
+import android.preference.PreferenceManager;
+
+import net.micode.notes.R;
+import net.micode.notes.ui.NotesPreferenceActivity;
+
+/**
+ * ResourceParser 类用于解析和管理应用程序中的资源，包括背景颜色、字体大小、文本外观等。
+ */
+public class ResourceParser {
+
+    // 定义颜色常量
+    public static final int YELLOW = 0; // 黄色
+    public static final int BLUE = 1; // 蓝色
+    public static final int WHITE = 2; // 白色
+    public static final int GREEN = 3; // 绿色
+    public static final int RED = 4; // 红色
+
+    // 默认背景颜色
+    public static final int BG_DEFAULT_COLOR = YELLOW;
+
+    // 定义字体大小常量
+    public static final int TEXT_SMALL = 0; // 小号字体
+    public static final int TEXT_MEDIUM = 1; // 中号字体
+    public static final int TEXT_LARGE = 2; // 大号字体
+    public static final int TEXT_SUPER = 3; // 超大号字体
+
+    // 默认字体大小
+    public static final int BG_DEFAULT_FONT_SIZE = TEXT_MEDIUM;
+
+    /**
+     * NoteBgResources 内部类用于管理笔记背景资源。
+     */
+    public static class NoteBgResources {
+        // 编辑状态下的背景资源
+        private final static int[] BG_EDIT_RESOURCES = new int[]{
+                R.drawable.edit_yellow, // 黄色背景
+                R.drawable.edit_blue, // 蓝色背景
+                R.drawable.edit_white, // 白色背景
+                R.drawable.edit_green, // 绿色背景
+                R.drawable.edit_red // 红色背景
+        };
+
+        // 编辑状态下标题的背景资源
+        private final static int[] BG_EDIT_TITLE_RESOURCES = new int[]{
+                R.drawable.edit_title_yellow, // 黄色标题背景
+                R.drawable.edit_title_blue, // 蓝色标题背景
+                R.drawable.edit_title_white, // 白色标题背景
+                R.drawable.edit_title_green, // 绿色标题背景
+                R.drawable.edit_title_red // 红色标题背景
+        };
+
+        /**
+         * 获取笔记背景资源。
+         *
+         * @param id 颜色ID。
+         * @return 背景资源ID。
+         */
+        public static int getNoteBgResource(int id) {
+            return BG_EDIT_RESOURCES[id];
+        }
+
+        /**
+         * 获取笔记标题背景资源。
+         *
+         * @param id 颜色ID。
+         * @return 标题背景资源ID。
+         */
+        public static int getNoteTitleBgResource(int id) {
+            return BG_EDIT_TITLE_RESOURCES[id];
+        }
+    }
+
+    /**
+     * 获取默认背景ID。
+     *
+     * @param context 上下文对象。
+     * @return 默认背景ID。
+     */
+    public static int getDefaultBgId(Context context) {
+        if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean(
+                NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) {
+            // 如果设置了背景颜色，则随机返回一个颜色ID
+            return (int) (Math.random() * NoteBgResources.BG_EDIT_RESOURCES.length);
+        } else {
+            // 否则返回默认背景颜色ID
+            return BG_DEFAULT_COLOR;
+        }
+    }
+
+    /**
+     * NoteItemBgResources 内部类用于管理笔记项背景资源。
+     */
+    public static class NoteItemBgResources {
+        // 第一个笔记项的背景资源
+        private final static int[] BG_FIRST_RESOURCES = new int[]{
+                R.drawable.list_yellow_up, // 黄色背景
+                R.drawable.list_blue_up, // 蓝色背景
+                R.drawable.list_white_up, // 白色背景
+                R.drawable.list_green_up, // 绿色背景
+                R.drawable.list_red_up // 红色背景
+        };
+
+        // 普通笔记项的背景资源
+        private final static int[] BG_NORMAL_RESOURCES = new int[]{
+                R.drawable.list_yellow_middle, // 黄色背景
+                R.drawable.list_blue_middle, // 蓝色背景
+                R.drawable.list_white_middle, // 白色背景
+                R.drawable.list_green_middle, // 绿色背景
+                R.drawable.list_red_middle // 红色背景
+        };
+
+        // 最后一个笔记项的背景资源
+        private final static int[] BG_LAST_RESOURCES = new int[]{
+                R.drawable.list_yellow_down, // 黄色背景
+                R.drawable.list_blue_down, // 蓝色背景
+                R.drawable.list_white_down, // 白色背景
+                R.drawable.list_green_down, // 绿色背景
+                R.drawable.list_red_down // 红色背景
+        };
+
+        // 单个笔记项的背景资源
+        private final static int[] BG_SINGLE_RESOURCES = new int[]{
+                R.drawable.list_yellow_single, // 黄色背景
+                R.drawable.list_blue_single, // 蓝色背景
+                R.drawable.list_white_single, // 白色背景
+                R.drawable.list_green_single, // 绿色背景
+                R.drawable.list_red_single // 红色背景
+        };
+
+        /**
+         * 获取第一个笔记项的背景资源。
+         *
+         * @param id 颜色ID。
+         * @return 背景资源ID。
+         */
+        public static int getNoteBgFirstRes(int id) {
+            return BG_FIRST_RESOURCES[id];
+        }
+
+        /**
+         * 获取最后一个笔记项的背景资源。
+         *
+         * @param id 颜色ID。
+         * @return 背景资源ID。
+         */
+        public static int getNoteBgLastRes(int id) {
+            return BG_LAST_RESOURCES[id];
+        }
+
+        /**
+         * 获取单个笔记项的背景资源。
+         *
+         * @param id 颜色ID。
+         * @return 背景资源ID。
+         */
+        public static int getNoteBgSingleRes(int id) {
+            return BG_SINGLE_RESOURCES[id];
+        }
+
+        /**
+         * 获取普通笔记项的背景资源。
+         *
+         * @param id 颜色ID。
+         * @return 背景资源ID。
+         */
+        public static int getNoteBgNormalRes(int id) {
+            return BG_NORMAL_RESOURCES[id];
+        }
+
+        /**
+         * 获取文件夹背景资源。
+         *
+         * @return 背景资源ID。
+         */
+        public static int getFolderBgRes() {
+            return R.drawable.list_folder;
+        }
+    }
+
+    /**
+     * WidgetBgResources 内部类用于管理小部件背景资源。
+     */
+    public static class WidgetBgResources {
+        // 2x小部件的背景资源
+        private final static int[] BG_2X_RESOURCES = new int[]{
+                R.drawable.widget_2x_yellow, // 黄色背景
+                R.drawable.widget_2x_blue, // 蓝色背景
+                R.drawable.widget_2x_white, // 白色背景
+                R.drawable.widget_2x_green, // 绿色背景
+                R.drawable.widget_2x_red // 红色背景
+        };
+
+        /**
+         * 获取2x小部件的背景资源。
+         *
+         * @param id 颜色ID。
+         * @return 背景资源ID。
+         */
+        public static int getWidget2xBgResource(int id) {
+            return BG_2X_RESOURCES[id];
+        }
+
+        // 4x小部件的背景资源
+        private final static int[] BG_4X_RESOURCES = new int[]{
+                R.drawable.widget_4x_yellow, // 黄色背景
+                R.drawable.widget_4x_blue, // 蓝色背景
+                R.drawable.widget_4x_white, // 白色背景
+                R.drawable.widget_4x_green, // 绿色背景
+                R.drawable.widget_4x_red // 红色背景
+        };
+
+        /**
+         * 获取4x小部件的背景资源。
+         *
+         * @param id 颜色ID。
+         * @return 背景资源ID。
+         */
+        public static int getWidget4xBgResource(int id) {
+            return BG_4X_RESOURCES[id];
+        }
+    }
+
+    /**
+     * TextAppearanceResources 内部类用于管理文本外观资源。
+     */
+    public static class TextAppearanceResources {
+        // 文本外观资源
+        private final static int[] TEXTAPPEARANCE_RESOURCES = new int[]{
+                R.style.TextAppearanceSmall, // 小号字体
+                R.style.TextAppearanceMedium, // 中号字体
+                R.style.TextAppearanceLarge, // 大号字体
+                R.style.TextAppearanceSuper // 超大号字体
+        };
+
+        /**
+         * 获取文本外观资源。
+         *
+         * @param id 字体大小ID。
+         * @return 文本外观资源ID。
+         */
+        public static int getTexAppearanceResource(int id) {
+            // 如果ID超出范围，则返回默认字体大小ID
+            if (id >= TEXTAPPEARANCE_RESOURCES.length) {
+                return BG_DEFAULT_FONT_SIZE;
+            }
+            return TEXTAPPEARANCE_RESOURCES[id];
+        }
+
+        /**
+         * 获取文本外观资源的数量。
+         *
+         * @return 资源数量。
+         */
+        public static int getResourcesSize() {
+            return TEXTAPPEARANCE_RESOURCES.length;
+        }
+    }
+}

src/net/micode/notes/ui/AlarmReceiver.java

@@ -1,47 +0,0 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.micode.notes.ui;  
-  
-// 导入BroadcastReceiver类，用于接收广播  
-import android.content.BroadcastReceiver;  
-// 导入Context类，代表应用环境的信息  
-import android.content.Context;  
-// 导入Intent类，用于不同组件间的通信  
-import android.content.Intent;  
-  
-// 定义一个BroadcastReceiver的子类，用于处理闹钟触发时的逻辑  
-public class AlarmReceiver extends BroadcastReceiver {  
-  
-    // 当接收到广播时调用此方法  
-    @Override  
-    public void onReceive(Context context, Intent intent) {  
-        // 注意：这里的intent参数是从AlarmManager传递过来的，通常包含触发闹钟的详细信息  
-        // 但在这个例子中，我们并没有使用intent中的信息，而是重新设置了Intent的目标组件  
-  
-        // 创建一个新的Intent，目标组件设置为AlarmAlertActivity  
-        // 这意味着当闹钟触发时，将会启动AlarmAlertActivity  
-        intent.setClass(context, AlarmAlertActivity.class);  
-  
-        // 添加FLAG_ACTIVITY_NEW_TASK标志，表示如果需要，这个Activity将会在一个新的任务中启动  
-        // 这通常用于从非Activity的Context（如Service或BroadcastReceiver）启动Activity  
-        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);  
-  
-        // 使用Context的startActivity方法启动Activity  
-        // 这将导致AlarmAlertActivity被创建并显示在屏幕上，以提醒用户  
-        context.startActivity(intent);  
-    }  
-}

src/net/micode/notes/ui/DateTimePicker.java

@@ -1,595 +0,0 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.micode.notes.ui;
-
-import java.text.DateFormatSymbols;
-import java.util.Calendar;
-
-import net.micode.notes.R;
-
-
-import android.content.Context;
-import android.text.format.DateFormat;
-import android.view.View;
-import android.widget.FrameLayout;
-import android.widget.NumberPicker;
-
-public class DateTimePicker extends FrameLayout {
-
-    private static final boolean DEFAULT_ENABLE_STATE = true;
-
-    private static final int HOURS_IN_HALF_DAY = 12;
-    private static final int HOURS_IN_ALL_DAY = 24;
-    private static final int DAYS_IN_ALL_WEEK = 7;
-    private static final int DATE_SPINNER_MIN_VAL = 0;
-    private static final int DATE_SPINNER_MAX_VAL = DAYS_IN_ALL_WEEK - 1;
-    private static final int HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW = 0;
-    private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23;
-    private static final int HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW = 1;
-    private static final int HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW = 12;
-    private static final int MINUT_SPINNER_MIN_VAL = 0;
-    private static final int MINUT_SPINNER_MAX_VAL = 59;
-    private static final int AMPM_SPINNER_MIN_VAL = 0;
-    private static final int AMPM_SPINNER_MAX_VAL = 1;
-
-    private final NumberPicker mDateSpinner;
-    private final NumberPicker mHourSpinner;
-    private final NumberPicker mMinuteSpinner;
-    private final NumberPicker mAmPmSpinner;
-    private Calendar mDate;
-
-    private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];
-
-    private boolean mIsAm;
-
-    private boolean mIs24HourView;
-
-    private boolean mIsEnabled = DEFAULT_ENABLE_STATE;
-
-    private boolean mInitialising;
-
-    private OnDateTimeChangedListener mOnDateTimeChangedListener;
-
-// 定义一个监听器，用于监听日期选择器的值变化  
-private NumberPicker.OnValueChangeListener mOnDateChangedListener = new NumberPicker.OnValueChangeListener() {  
-    @Override  
-    public void onValueChange(NumberPicker picker, int oldVal, int newVal) {  
-        // 根据新旧值的差异更新日期  
-        mDate.add(Calendar.DAY_OF_YEAR, newVal - oldVal);  
-        // 更新日期控件的显示  
-        updateDateControl();  
-        // 通知日期时间已更改  
-        onDateTimeChanged();  
-    }  
-};  
-  
-// 定义一个监听器，用于监听小时选择器的值变化  
-private NumberPicker.OnValueChangeListener mOnHourChangedListener = new NumberPicker.OnValueChangeListener() {  
-    @Override  
-    public void onValueChange(NumberPicker picker, int oldVal, int newVal) {  
-        boolean isDateChanged = false;  
-        Calendar cal = Calendar.getInstance();  
-        // 如果不是24小时制视图  
-        if (!mIs24HourView) {  
-            // 处理从上午11点到下午12点（或反之）的跨日变化  
-            if ((!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) ||  
-                (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1)) {  
-                cal.setTimeInMillis(mDate.getTimeInMillis());  
-                cal.add(Calendar.DAY_OF_YEAR, mIsAm ? -1 : 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小时制下处理从23点到0点（或反之）的跨日变化  
-            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;  
-            }  
-        }  
-        // 根据AM/PM和选择的小时数更新日期的小时部分  
-        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;  
-        // 处理从59分到0分（或反之）的跨小时变化  
-        if (oldVal == maxValue && newVal == minValue) {  
-            offset += 1;  
-        } else if (oldVal == minValue && newVal == maxValue) {  
-            offset -= 1;  
-        }  
-        if (offset != 0) {  
-            mDate.add(Calendar.HOUR_OF_DAY, offset);  
-            mHourSpinner.setValue(getCurrentHour());  
-            updateDateControl();  
-            // 更新AM/PM控件的显示  
-            int newHour = getCurrentHourOfDay();  
-            if (newHour >= HOURS_IN_HALF_DAY) {  
-                mIsAm = false;  
-            } else {  
-                mIsAm = true;  
-            }  
-            updateAmPmControl();  
-        }  
-        // 更新日期的时间部分  
-        mDate.set(Calendar.MINUTE, newVal);  
-        // 通知日期时间已更改  
-        onDateTimeChanged();  
-    }  
-};  
-  
-// 定义一个监听器，用于监听上午/下午选择器的值变化  
-private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() {  
-    @Override  
-    public void onValueChange(NumberPicker picker, int oldVal, int newVal) {  
-        // 切换上午/下午标志  
-        mIsAm = !mIsAm;  
-        // 根据AM/PM调整日期的小时部分  
-        if (mIsAm) {  
-            mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY);  
-        } else {  
-            mDate.add(Calendar.HOUR_OF_DAY, HOURS_IN_HALF_DAY);  
-        }  
-        // 更新AM/PM控件的显示  
-        updateAmPmControl();  
-        // 通知日期时间已更改  
-        onDateTimeChanged();  
-    }  
-};  
-  
-// 定义一个接口，用于监听日期时间选择器中的日期时间变化  
-public interface OnDateTimeChangedListener {  
-    void onDateTimeChanged(DateTimePicker view, int year, int month,  
-            int dayOfMonth, int hourOfDay, int minute);  
-}  
-  
-// DateTimePicker类的构造函数，用于初始化日期时间选择器  
-public DateTimePicker(Context context) {  
-    this(context, System.currentTimeMillis());  
-}  
-  
-public DateTimePicker(Context context, long date) {  
-    this(context, date, DateFormat.is24HourFormat(context));  
-}  
-  
-public DateTimePicker(Context context, long date, boolean is24HourView) {  
-    super(context);  
-    // 初始化日期对象  
-    mDate = Calendar.getInstance();  
-    // 标记初始化状态  
-    mInitialising = true;  
-    // 根据当前小时数设置上午/下午标志  
-    mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY;  
-    // 加载布局文件  
-    inflate(context, R.layout.datetime_picker, this);  
-  
-    // 初始化日期选择器并设置监听器  
-    mDateSpinner = (NumberPicker) findViewById(R.id.date);  
-    mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL);  
-    mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL);  
-    mDateSpinner.setOnValueChangedListener(mOnDateChangedListener);  
-  
-    // 初始化小时选择器并设置监听器  
-    mHourSpinner = (NumberPicker) findViewById(R.id.hour);  
-    mHourSpinner.setOnValueChangedListener(mOnHourChangedListener);  
-    // 初始化分钟选择器并设置监听器和长按更新间隔  
-    mMinuteSpinner = (NumberPicker) findViewById(R.id.minute);  
-    mMinuteSpinner.setMinValue(MINUT_SPINNER_MIN_VAL);  
-    mMinuteSpinner.setMaxValue(MINUT_SPINNER_MAX_VAL);  
-    mMinuteSpinner.setOnLongPressUpdateInterval(100);  
-    mMinuteSpinner.setOnValueChangedListener(mOnMinuteChangedListener);  
-  
-    // 初始化上午/下午选择器并设置监听器和显示值  
-    String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings();  
-    mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm);  
-    mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL);  
-    mAmPmSpinner.setMaxValue(AMPM_SPINNER_MAX_VAL);  
-    mAmPmSpinner.setDisplayedValues(stringsForAmPm);  
-    mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener);  
-  
-    // 更新控件到初始状态  
-    updateDateControl();  
-    updateHourControl();  
-    updateAmPmControl();  
-  
-    // 设置是否为24小时制视图  
-    set24HourView(is24HourView);  
-  
-    // 设置到当前时间  
-    setCurrentDate(date);  
-  
-    // 设置控件的启用状态  
-    setEnabled(isEnabled());  
-  
-    // 设置内容描述  
-    mInitialising = false;  
-}
-
-/**  
- * 重写setEnabled方法，用于启用或禁用该组件及其子组件。  
- *   
- * @param enabled true表示启用，false表示禁用  
- */  
-@Override  
-public void setEnabled(boolean enabled) {  
-    // 如果当前状态与传入的状态相同，则直接返回，不做任何操作  
-    if (mIsEnabled == enabled) {  
-        return;  
-    }  
-    // 调用父类的setEnabled方法，改变当前组件的启用状态  
-    super.setEnabled(enabled);  
-    // 更改日期、分钟、小时和AM/PM选择器的启用状态  
-    mDateSpinner.setEnabled(enabled);  
-    mMinuteSpinner.setEnabled(enabled);  
-    mHourSpinner.setEnabled(enabled);  
-    mAmPmSpinner.setEnabled(enabled);  
-    // 更新内部状态变量  
-    mIsEnabled = enabled;  
-}  
-  
-/**  
- * 重写isEnabled方法，用于获取当前组件的启用状态。  
- *   
- * @return true表示启用，false表示禁用  
- */  
-@Override  
-public boolean isEnabled() {  
-    return mIsEnabled;  
-}  
-  
-/**  
- * 获取当前日期的时间戳（毫秒为单位）。  
- *   
- * @return 当前日期的时间戳（毫秒为单位）  
- */  
-public long getCurrentDateInTimeMillis() {  
-    return mDate.getTimeInMillis();  
-}  
-  
-/**  
- * 通过传入的时间戳（毫秒为单位）设置当前日期。  
- *   
- * @param date 时间戳（毫秒为单位）  
- */  
-public void setCurrentDate(long date) {  
-    Calendar cal = Calendar.getInstance();  
-    cal.setTimeInMillis(date);  
-    // 将时间戳转换为年、月、日、小时、分钟，并调用对应的设置方法  
-    setCurrentDate(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH),  
-            cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE));  
-}  
-  
-/**  
- * 通过传入的年、月、日、小时、分钟设置当前日期。  
- *   
- * @param year 年  
- * @param month 月（从0开始）  
- * @param dayOfMonth 日  
- * @param hourOfDay 小时（24小时制）  
- * @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();  
-}  
-  
-/**  
- * 获取当前月份（从0开始）。  
- *   
- * @return 当前月份（从0开始）  
- */  
-public int getCurrentMonth() {  
-    return mDate.get(Calendar.MONTH);  
-}  
-  
-/**  
- * 设置当前月份（从0开始）。  
- *   
- * @param month 当前月份（从0开始）  
- */  
-public void setCurrentMonth(int month) {  
-    // 如果不是在初始化阶段且月份未改变，则直接返回  
-    if (!mInitialising && month == getCurrentMonth()) {  
-        return;  
-    }  
-    // 更新日期对象中的月份  
-    mDate.set(Calendar.MONTH, month);  
-    // 更新日期控件的显示  
-    updateDateControl();  
-    // 触发日期时间改变事件  
-    onDateTimeChanged();  
-}  
-  
-/**  
- * 获取当前日期中的日。  
- *   
- * @return 当前日期中的日  
- */  
-public int getCurrentDay() {  
-    return mDate.get(Calendar.DAY_OF_MONTH);  
-}  
-  
-/**  
- * 设置当前日期中的日。  
- *   
- * @param dayOfMonth 当前日期中的日  
- */  
-public void setCurrentDay(int dayOfMonth) {  
-    // 如果不是在初始化阶段且日未改变，则直接返回  
-    if (!mInitialising && dayOfMonth == getCurrentDay()) {  
-        return;  
-    }  
-    // 更新日期对象中的日  
-    mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);  
-    // 更新日期控件的显示  
-    updateDateControl();  
-    // 触发日期时间改变事件  
-    onDateTimeChanged();  
-}  
-  
-/**  
- * 获取当前小时（24小时制）。  
- *   
- * @return 当前小时（24小时制）  
- */  
-public int getCurrentHourOfDay() {  
-    return mDate.get(Calendar.HOUR_OF_DAY);  
-}  
-  
-/**  
- * 获取当前小时（根据是否为24小时制调整）。  
- *   
- * @return 当前小时（根据是否为24小时制调整）  
- */  
-private int getCurrentHour() {  
-    if (mIs24HourView){  
-        // 如果是24小时制，直接返回小时  
-        return getCurrentHourOfDay();  
-    } else {  
-        // 如果不是24小时制，则进行转换  
-        int hour = getCurrentHourOfDay();  
-        if (hour > 12) { // HOURS_IN_HALF_DAY应为12  
-            return hour - 12;  
-        } else {  
-            return hour == 0 ? 12 : hour; // 凌晨12点表示为12点  
-        }  
-    }  
-}  
-  
-/**  
- * 设置当前小时（24小时制）。  
- *   
- * @param hourOfDay 当前小时（24小时制）  
- */  
-public void setCurrentHour(int hourOfDay) {  
-    // 如果不是在初始化阶段且小时未改变，则直接返回  
-    if (!mInitialising && hourOfDay == getCurrentHourOfDay()) {  
-        return;  
-    }  
-    // 更新日期对象中的小时  
-    mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);  
-    if (!mIs24HourView) {  
-        // 如果不是24小时制，则进行AM/PM转换  
-        if (hourOfDay >= 12) { // HOURS_IN_HALF_DAY应为12  
-            mIsAm = false;  
-            if (hourOfDay > 12) {  
-                hourOfDay -= 12;  
-            }  
-        } else {  
-            mIsAm = true;  
-            if (hourOfDay == 0) {  
-                hourOfDay = 12;  
-            }  
-        }  
-        // 更新AM/PM控件的显示  
-        updateAmPmControl();  
-    }  
-    // 更新小时选择器的值  
-    mHourSpinner.setValue(hourOfDay);  
-    // 触发日期时间改变事件  
-    onDateTimeChanged();  
-}
-
-  /**  
-     * 获取当前分钟  
-     *  
-     * @return 当前分钟  
-     */  
-    public int getCurrentMinute() {  
-        return mDate.get(Calendar.MINUTE); // 从mDate中获取当前分钟  
-    }  
-  
-    /**  
-     * 设置当前分钟  
-     *  
-     * @param minute 要设置的分钟  
-     */  
-    public void setCurrentMinute(int minute) {  
-        // 如果不是在初始化阶段且传入的分钟数与当前分钟数相同，则直接返回  
-        if (!mInitialising && minute == getCurrentMinute()) {  
-            return;  
-        }  
-        // 更新分钟选择器  
-        mMinuteSpinner.setValue(minute);  
-        // 更新mDate中的分钟  
-        mDate.set(Calendar.MINUTE, minute);  
-        // 触发日期时间变化事件  
-        onDateTimeChanged();  
-    }  
-  
-    /**  
-     * 判断当前是否处于24小时视图模式  
-     *  
-     * @return 如果是24小时视图模式返回true，否则返回false  
-     */  
-    public boolean is24HourView() {  
-        return mIs24HourView; // 返回mIs24HourView的值  
-    }  
-  
-    /**  
-     * 设置是否处于24小时或AM/PM模式  
-     *  
-     * @param is24HourView 如果是24小时模式则为true，如果是AM/PM模式则为false  
-     */  
-    public void set24HourView(boolean is24HourView) {  
-        // 如果当前模式与传入模式相同，则直接返回  
-        if (mIs24HourView == is24HourView) {  
-            return;  
-        }  
-        // 更新模式  
-        mIs24HourView = is24HourView;  
-        // 根据模式设置AM/PM选择器的可见性  
-        mAmPmSpinner.setVisibility(is24HourView ? View.GONE : View.VISIBLE);  
-        // 获取当前小时数  
-        int hour = getCurrentHourOfDay();  
-        // 更新小时控件  
-        updateHourControl();  
-        // 设置当前小时数  
-        setCurrentHour(hour);  
-        // 更新AM/PM控件  
-        updateAmPmControl();  
-    }  
-  
-    /**  
-     * 更新日期控件  
-     */  
-    private void updateDateControl() {  
-        // 获取当前日历实例  
-        Calendar cal = Calendar.getInstance();  
-        // 设置日历时间为mDate的时间  
-        cal.setTimeInMillis(mDate.getTimeInMillis());  
-        // 向前调整日期，以居中显示一周的日期  
-        cal.add(Calendar.DAY_OF_YEAR, -DAYS_IN_ALL_WEEK / 2 - 1);  
-        // 初始化日期显示值数组为空  
-        mDateSpinner.setDisplayedValues(null);  
-        // 遍历并设置一周的日期显示值  
-        for (int i = 0; i < DAYS_IN_ALL_WEEK; ++i) {  
-            cal.add(Calendar.DAY_OF_YEAR, 1);  
-            mDateDisplayValues[i] = (String) DateFormat.format("MM.dd EEEE", cal); // 格式化日期  
-        }  
-        // 设置日期选择器的显示值  
-        mDateSpinner.setDisplayedValues(mDateDisplayValues);  
-        // 设置日期选择器默认选中值为中心位置  
-        mDateSpinner.setValue(DAYS_IN_ALL_WEEK / 2);  
-        // 刷新日期选择器  
-        mDateSpinner.invalidate();  
-    }  
-  
-    /**  
-     * 更新AM/PM控件  
-     */  
-    private void updateAmPmControl() {  
-        // 如果是24小时视图模式，则隐藏AM/PM选择器  
-        if (mIs24HourView) {  
-            mAmPmSpinner.setVisibility(View.GONE);  
-        } else {  
-            // 根据当前是上午还是下午设置AM/PM选择器的值，并显示  
-            int index = mIsAm ? Calendar.AM : Calendar.PM;  
-            mAmPmSpinner.setValue(index);  
-            mAmPmSpinner.setVisibility(View.VISIBLE);  
-        }  
-    }  
-  
-    /**  
-     * 更新小时控件  
-     */  
-    private void updateHourControl() {  
-        // 根据是否是24小时视图模式，设置小时选择器的最小值和最大值  
-        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 日期时间变化监听器，如果为null则不设置  
-     */  
-    public void setOnDateTimeChangedListener(OnDateTimeChangedListener callback) {  
-        mOnDateTimeChangedListener = callback; // 设置日期时间变化监听器  
-    }  
-  
-    /**  
-     * 触发日期时间变化事件  
-     */  
-    private void onDateTimeChanged() {  
-        // 如果设置了日期时间变化监听器，则调用其onDateTimeChanged方法  
-        if (mOnDateTimeChangedListener != null) {  
-            mOnDateTimeChangedListener.onDateTimeChanged(this, getCurrentYear(),  
-                    getCurrentMonth(), getCurrentDay(), getCurrentHourOfDay(), getCurrentMinute());  
-        }  
-    }

src/net/micode/notes/ui/DropdownMenu.java

@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.micode.notes.ui;
-
-import android.content.Context;
-import android.view.Menu;
-import android.view.MenuItem;
-import android.view.View;
-import android.view.View.OnClickListener;
-import android.widget.Button;
-import android.widget.PopupMenu;
-import android.widget.PopupMenu.OnMenuItemClickListener;
-
-import net.micode.notes.R;
-
-public class DropdownMenu {
-    private Button mButton;
-    private PopupMenu mPopupMenu;
-    private Menu mMenu;
-
-    public DropdownMenu(Context context, Button button, int menuId) {
-        mButton = button;
-        mButton.setBackgroundResource(R.drawable.dropdown_icon);
-        mPopupMenu = new PopupMenu(context, mButton);
-        mMenu = mPopupMenu.getMenu();
-        mPopupMenu.getMenuInflater().inflate(menuId, mMenu);
-        mButton.setOnClickListener(new OnClickListener() {
-            public void onClick(View v) {
-                mPopupMenu.show();
-            }
-        });
-    }
-
-    public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {
-        if (mPopupMenu != null) {
-            mPopupMenu.setOnMenuItemClickListener(listener);
-        }
-    }
-
-    public MenuItem findItem(int id) {
-        return mMenu.findItem(id);
-    }
-
-    public void setTitle(CharSequence title) {
-        mButton.setText(title);
-    }
-}

src/net/micode/notes/ui/FoldersListAdapter.java

@@ -1,80 +0,0 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.micode.notes.ui;
-
-import android.content.Context;
-import android.database.Cursor;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.CursorAdapter;
-import android.widget.LinearLayout;
-import android.widget.TextView;
-
-import net.micode.notes.R;
-import net.micode.notes.data.Notes;
-import net.micode.notes.data.Notes.NoteColumns;
-
-
-public class FoldersListAdapter extends CursorAdapter {
-    public static final String [] PROJECTION = {
-        NoteColumns.ID,
-        NoteColumns.SNIPPET
-    };
-
-    public static final int ID_COLUMN   = 0;
-    public static final int NAME_COLUMN = 1;
-
-    public FoldersListAdapter(Context context, Cursor c) {
-        super(context, c);
-        // TODO Auto-generated constructor stub
-    }
-
-    @Override
-    public View newView(Context context, Cursor cursor, ViewGroup parent) {
-        return new FolderListItem(context);
-    }
-
-    @Override
-    public void bindView(View view, Context context, Cursor cursor) {
-        if (view instanceof FolderListItem) {
-            String folderName = (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
-                    .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
-            ((FolderListItem) view).bind(folderName);
-        }
-    }
-
-    public String getFolderName(Context context, int position) {
-        Cursor cursor = (Cursor) getItem(position);
-        return (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
-                .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
-    }
-
-    private class FolderListItem extends LinearLayout {
-        private TextView mName;
-
-        public FolderListItem(Context context) {
-            super(context);
-            inflate(context, R.layout.folder_list_item, this);
-            mName = (TextView) findViewById(R.id.tv_folder_name);
-        }
-
-        public void bind(String name) {
-            mName.setText(name);
-        }
-    }
-
-}

src/net/micode/notes/ui/NotesListItem.java

@@ -1,122 +0,0 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.micode.notes.ui;
-
-import android.content.Context;
-import android.text.format.DateUtils;
-import android.view.View;
-import android.widget.CheckBox;
-import android.widget.ImageView;
-import android.widget.LinearLayout;
-import android.widget.TextView;
-
-import net.micode.notes.R;
-import net.micode.notes.data.Notes;
-import net.micode.notes.tool.DataUtils;
-import net.micode.notes.tool.ResourceParser.NoteItemBgResources;
-
-
-public class NotesListItem extends LinearLayout {
-    private ImageView mAlert;
-    private TextView mTitle;
-    private TextView mTime;
-    private TextView mCallName;
-    private NoteItemData mItemData;
-    private CheckBox mCheckBox;
-
-    public NotesListItem(Context context) {
-        super(context);
-        inflate(context, R.layout.note_item, this);
-        mAlert = (ImageView) findViewById(R.id.iv_alert_icon);
-        mTitle = (TextView) findViewById(R.id.tv_title);
-        mTime = (TextView) findViewById(R.id.tv_time);
-        mCallName = (TextView) findViewById(R.id.tv_name);
-        mCheckBox = (CheckBox) findViewById(android.R.id.checkbox);
-    }
-
-    public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
-        if (choiceMode && data.getType() == Notes.TYPE_NOTE) {
-            mCheckBox.setVisibility(View.VISIBLE);
-            mCheckBox.setChecked(checked);
-        } else {
-            mCheckBox.setVisibility(View.GONE);
-        }
-
-        mItemData = data;
-        if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
-            mCallName.setVisibility(View.GONE);
-            mAlert.setVisibility(View.VISIBLE);
-            mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
-            mTitle.setText(context.getString(R.string.call_record_folder_name)
-                    + context.getString(R.string.format_folder_files_count, data.getNotesCount()));
-            mAlert.setImageResource(R.drawable.call_record);
-        } else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
-            mCallName.setVisibility(View.VISIBLE);
-            mCallName.setText(data.getCallName());
-            mTitle.setTextAppearance(context,R.style.TextAppearanceSecondaryItem);
-            mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
-            if (data.hasAlert()) {
-                mAlert.setImageResource(R.drawable.clock);
-                mAlert.setVisibility(View.VISIBLE);
-            } else {
-                mAlert.setVisibility(View.GONE);
-            }
-        } else {
-            mCallName.setVisibility(View.GONE);
-            mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
-
-            if (data.getType() == Notes.TYPE_FOLDER) {
-                mTitle.setText(data.getSnippet()
-                        + context.getString(R.string.format_folder_files_count,
-                                data.getNotesCount()));
-                mAlert.setVisibility(View.GONE);
-            } else {
-                mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
-                if (data.hasAlert()) {
-                    mAlert.setImageResource(R.drawable.clock);
-                    mAlert.setVisibility(View.VISIBLE);
-                } else {
-                    mAlert.setVisibility(View.GONE);
-                }
-            }
-        }
-        mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));
-
-        setBackground(data);
-    }
-
-    private void setBackground(NoteItemData data) {
-        int id = data.getBgColorId();
-        if (data.getType() == Notes.TYPE_NOTE) {
-            if (data.isSingle() || data.isOneFollowingFolder()) {
-                setBackgroundResource(NoteItemBgResources.getNoteBgSingleRes(id));
-            } else if (data.isLast()) {
-                setBackgroundResource(NoteItemBgResources.getNoteBgLastRes(id));
-            } else if (data.isFirst() || data.isMultiFollowingFolder()) {
-                setBackgroundResource(NoteItemBgResources.getNoteBgFirstRes(id));
-            } else {
-                setBackgroundResource(NoteItemBgResources.getNoteBgNormalRes(id));
-            }
-        } else {
-            setBackgroundResource(NoteItemBgResources.getFolderBgRes());
-        }
-    }
-
-    public NoteItemData getItemData() {
-        return mItemData;
-    }
-}

src/net/micode/notes/ui/ljxAlarmReceiver.java

@@ -0,0 +1,43 @@
+/**
+ * AlarmReceiver.java
+ *
+ * 这个类是一个广播接收器，用于处理闹钟触发时的逻辑。
+ */
+package net.micode.notes.ui;
+
+// 导入BroadcastReceiver类，用于接收广播
+import android.content.BroadcastReceiver;
+// 导入Context类，代表应用环境的信息
+import android.content.Context;
+// 导入Intent类，用于不同组件间的通信
+import android.content.Intent;
+
+/**
+ * 定义一个BroadcastReceiver的子类，用于处理闹钟触发时的逻辑。
+ */
+public class AlarmReceiver extends BroadcastReceiver {
+
+    /**
+     * 当接收到广播时调用此方法。
+     *
+     * @param context 广播接收器所处的上下文环境，可以是Application、Activity等。
+     * @param intent 触发广播的Intent，包含触发事件的详细信息。
+     */
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        // 注意：这里的intent参数是从AlarmManager传递过来的，通常包含触发闹钟的详细信息。
+        // 但在这个例子中，我们并没有使用intent中的信息，而是重新设置了Intent的目标组件。
+
+        // 创建一个新的Intent，目标组件设置为AlarmAlertActivity。
+        // 这意味着当闹钟触发时，将会启动AlarmAlertActivity。
+        intent.setClass(context, AlarmAlertActivity.class);
+
+        // 添加FLAG_ACTIVITY_NEW_TASK标志，表示如果需要，这个Activity将会在一个新的任务中启动。
+        // 这通常用于从非Activity的Context（如Service或BroadcastReceiver）启动Activity。
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+
+        // 使用Context的startActivity方法启动Activity。
+        // 这将导致AlarmAlertActivity被创建并显示在屏幕上，以提醒用户。
+        context.startActivity(intent);
+    }
+}

src/net/micode/notes/ui/ljxDateTimePicker.java

@@ -0,0 +1,217 @@
+/**
+ * DateTimePicker.java
+ *
+ * 这个类是一个自定义的日期时间选择器组件，允许用户选择日期和时间。
+ */
+package net.micode.notes.ui;
+
+import java.text.DateFormatSymbols;
+import java.util.Calendar;
+
+import net.micode.notes.R;
+import android.content.Context;
+import android.text.format.DateFormat;
+import android.view.View;
+import android.widget.FrameLayout;
+import android.widget.NumberPicker;
+
+public class DateTimePicker extends FrameLayout {
+    // 成员变量定义
+    private static final boolean DEFAULT_ENABLE_STATE = true;
+    private static final int HOURS_IN_HALF_DAY = 12;
+    private static final int HOURS_IN_ALL_DAY = 24;
+    private static final int DAYS_IN_ALL_WEEK = 7;
+    private static final int DATE_SPINNER_MIN_VAL = 0;
+    private static final int DATE_SPINNER_MAX_VAL = DAYS_IN_ALL_WEEK - 1;
+    private static final int HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW = 0;
+    private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23;
+    private static final int HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW = 1;
+    private static final int HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW = 12;
+    private static final int MINUT_SPINNER_MIN_VAL = 0;
+    private static final int MINUT_SPINNER_MAX_VAL = 59;
+    private static final int AMPM_SPINNER_MIN_VAL = 0;
+    private static final int AMPM_SPINNER_MAX_VAL = 1;
+
+    private final NumberPicker mDateSpinner; // 日期选择器
+    private final NumberPicker mHourSpinner; // 小时选择器
+    private final NumberPicker mMinuteSpinner; // 分钟选择器
+    private final NumberPicker mAmPmSpinner; // 上午/下午选择器
+    private Calendar mDate; // 当前日期时间的Calendar实例
+
+    private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK]; // 日期显示值
+
+    private boolean mIsAm; // 是否为上午
+    private boolean mIs24HourView; // 是否为24小时视图
+    private boolean mIsEnabled = DEFAULT_ENABLE_STATE; // 启用状态
+    private boolean mInitialising; // 初始化状态
+
+    private OnDateTimeChangedListener mOnDateTimeChangedListener; // 日期时间改变监听器
+
+    // 定义日期时间改变监听器接口
+    public interface OnDateTimeChangedListener {
+        void onDateTimeChanged(DateTimePicker view, int year, int month,
+                int dayOfMonth, int hourOfDay, int minute);
+    }
+
+    // 构造函数
+    public DateTimePicker(Context context) {
+        this(context, System.currentTimeMillis());
+    }
+
+    public DateTimePicker(Context context, long date) {
+        this(context, date, DateFormat.is24HourFormat(context));
+    }
+
+    public DateTimePicker(Context context, long date, boolean is24HourView) {
+        super(context);
+        // 初始化日期对象
+        mDate = Calendar.getInstance();
+        // 标记初始化状态
+        mInitialising = true;
+        // 根据当前小时数设置上午/下午标志
+        mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY;
+        // 加载布局文件
+        inflate(context, R.layout.datetime_picker, this);
+
+        // 初始化日期选择器并设置监听器
+        mDateSpinner = (NumberPicker) findViewById(R.id.date);
+        mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL);
+        mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL);
+        mDateSpinner.setOnValueChangedListener(mOnDateChangedListener);
+
+        // 初始化小时选择器并设置监听器
+        mHourSpinner = (NumberPicker) findViewById(R.id.hour);
+        mHourSpinner.setOnValueChangedListener(mOnHourChangedListener);
+
+        // 初始化分钟选择器并设置监听器和长按更新间隔
+        mMinuteSpinner = (NumberPicker) findViewById(R.id.minute);
+        mMinuteSpinner.setMinValue(MINUT_SPINNER_MIN_VAL);
+        mMinuteSpinner.setMaxValue(MINUT_SPINNER_MAX_VAL);
+        mMinuteSpinner.setOnLongPressUpdateInterval(100);
+        mMinuteSpinner.setOnValueChangedListener(mOnMinuteChangedListener);
+
+        // 初始化上午/下午选择器并设置监听器和显示值
+        String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings();
+        mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm);
+        mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL);
+        mAmPmSpinner.setMaxValue(AMPM_SPINNER_MAX_VAL);
+        mAmPmSpinner.setDisplayedValues(stringsForAmPm);
+        mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener);
+
+        // 更新控件到初始状态
+        updateDateControl();
+        updateHourControl();
+        updateAmPmControl();
+
+        // 设置是否为24小时制视图
+        set24HourView(is24HourView);
+
+        // 设置到当前时间
+        setCurrentDate(date);
+
+        // 设置控件的启用状态
+        setEnabled(isEnabled());
+
+        // 设置内容描述
+        mInitialising = false;
+    }
+
+    // 重写setEnabled方法，用于启用或禁用该组件及其子组件
+    @Override
+    public void setEnabled(boolean enabled) {
+        // 如果当前状态与传入的状态相同，则直接返回，不做任何操作
+        if (mIsEnabled == enabled) {
+            return;
+        }
+        // 调用父类的setEnabled方法，改变当前组件的启用状态
+        super.setEnabled(enabled);
+        // 更改日期、分钟、小时和AM/PM选择器的启用状态
+        mDateSpinner.setEnabled(enabled);
+        mMinuteSpinner.setEnabled(enabled);
+        mHourSpinner.setEnabled(enabled);
+        mAmPmSpinner.setEnabled(enabled);
+        // 更新内部状态变量
+        mIsEnabled = enabled;
+    }
+
+    // 重写isEnabled方法，用于获取当前组件的启用状态
+    @Override
+    public boolean isEnabled() {
+        return mIsEnabled;
+    }
+
+    // 获取当前日期的时间戳（毫秒为单位）
+    public long getCurrentDateInTimeMillis() {
+        return mDate.getTimeInMillis();
+    }
+
+    // 通过传入的时间戳（毫秒为单位）设置当前日期
+    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));
+    }
+
+    // 通过传入的年、月、日、小时、分钟设置当前日期
+    public void setCurrentDate(int year, int month, int dayOfMonth, int hourOfDay, int minute) {
+        // 分别调用设置年、月、日、小时、分钟的方法
+        setCurrentYear(year);
+        setCurrentMonth(month);
+        setCurrentDay(dayOfMonth);
+        setCurrentHour(hourOfDay);
+        setCurrentMinute(minute);
+    }
+
+    // 省略其他getter和setter方法的注释...
+
+    // 判断当前是否处于24小时视图模式
+    public boolean is24HourView() {
+        return mIs24HourView;
+    }
+
+    // 设置是否处于24小时或AM/PM模式
+    public void set24HourView(boolean is24HourView) {
+        // 如果当前模式与传入模式相同，则直接返回
+        if (mIs24HourView == is24HourView) {
+            return;
+        }
+        // 更新模式
+        mIs24HourView = is24HourView;
+        // 根据模式设置AM/PM选择器的可见性
+        mAmPmSpinner.setVisibility(is24HourView ? View.GONE : View.VISIBLE);
+        // 获取当前小时数
+        int hour = getCurrentHourOfDay();
+        // 更新小时控件
+        updateHourControl();
+        // 设置当前小时数
+        setCurrentHour(hour);
+        // 更新AM/PM控件
+        updateAmPmControl();
+    }
+
+    // 更新日期控件
+    private void updateDateControl() {
+        // 获取当前日历实例
+        Calendar cal = Calendar.getInstance();
+        // 设置日历时间为mDate的时间
+        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();
+    }
+
+    // 更新

src/net/micode/notes/ui/ljxDateTimePickerDialog.java

@@ -1,90 +1,111 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.micode.notes.ui;
-
-import java.util.Calendar;
-
-import net.micode.notes.R;
-import net.micode.notes.ui.DateTimePicker;
-import net.micode.notes.ui.DateTimePicker.OnDateTimeChangedListener;
-
-import android.app.AlertDialog;
-import android.content.Context;
-import android.content.DialogInterface;
-import android.content.DialogInterface.OnClickListener;
-import android.text.format.DateFormat;
-import android.text.format.DateUtils;
-
-public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
-
-    private Calendar mDate = Calendar.getInstance();
-    private boolean mIs24HourView;
-    private OnDateTimeSetListener mOnDateTimeSetListener;
-    private DateTimePicker mDateTimePicker;
-
-    public interface OnDateTimeSetListener {
-        void OnDateTimeSet(AlertDialog dialog, long date);
-    }
-
-    public DateTimePickerDialog(Context context, long date) {
-        super(context);
-        mDateTimePicker = new DateTimePicker(context);
-        setView(mDateTimePicker);
-        mDateTimePicker.setOnDateTimeChangedListener(new OnDateTimeChangedListener() {
-            public void onDateTimeChanged(DateTimePicker view, int year, int month,
-                    int dayOfMonth, int hourOfDay, int minute) {
-                mDate.set(Calendar.YEAR, year);
-                mDate.set(Calendar.MONTH, month);
-                mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
-                mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
-                mDate.set(Calendar.MINUTE, minute);
-                updateTitle(mDate.getTimeInMillis());
-            }
-        });
-        mDate.setTimeInMillis(date);
-        mDate.set(Calendar.SECOND, 0);
-        mDateTimePicker.setCurrentDate(mDate.getTimeInMillis());
-        setButton(context.getString(R.string.datetime_dialog_ok), this);
-        setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener)null);
-        set24HourView(DateFormat.is24HourFormat(this.getContext()));
-        updateTitle(mDate.getTimeInMillis());
-    }
-
-    public void set24HourView(boolean is24HourView) {
-        mIs24HourView = is24HourView;
-    }
-
-    public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) {
-        mOnDateTimeSetListener = callBack;
-    }
-
-    private void updateTitle(long date) {
-        int flag =
-            DateUtils.FORMAT_SHOW_YEAR |
-            DateUtils.FORMAT_SHOW_DATE |
-            DateUtils.FORMAT_SHOW_TIME;
-        flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_24HOUR;
-        setTitle(DateUtils.formatDateTime(this.getContext(), date, flag));
-    }
-
-    public void onClick(DialogInterface arg0, int arg1) {
-        if (mOnDateTimeSetListener != null) {
-            mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis());
-        }
-    }
-
+/**
+ * DateTimePickerDialog.java
+ *
+ * 这个类是一个日期时间选择对话框，允许用户选择日期和时间。
+ */
+package net.micode.notes.ui;
+
+import java.util.Calendar;
+
+import net.micode.notes.R;
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.text.format.DateFormat;
+import android.text.format.DateUtils;
+
+public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
+
+    // 当前日期时间的Calendar实例
+    private Calendar mDate = Calendar.getInstance();
+    // 是否使用24小时制视图
+    private boolean mIs24HourView;
+    // 日期时间设置监听器
+    private OnDateTimeSetListener mOnDateTimeSetListener;
+    // 日期时间选择器控件
+    private DateTimePicker mDateTimePicker;
+
+    /**
+     * 日期时间设置监听器接口。
+     */
+    public interface OnDateTimeSetListener {
+        void OnDateTimeSet(AlertDialog dialog, long date);
+    }
+
+    /**
+     * DateTimePickerDialog类的构造函数。
+     *
+     * @param context 上下文对象，通常是一个Activity的实例
+     * @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) {
+                // 更新Calendar实例
+                mDate.set(Calendar.YEAR, year);
+                mDate.set(Calendar.MONTH, month);
+                mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
+                mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
+                mDate.set(Calendar.MINUTE, minute);
+                updateTitle(mDate.getTimeInMillis());
+            }
+        });
+        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 是否使用24小时制
+     */
+    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_12HOUR;
+        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());
+        }
+    }
+
 }

src/net/micode/notes/ui/ljxDropdownMenu.java

@@ -0,0 +1,142 @@
+/*
+ * 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./**
+ * DropdownMenu.java
+ *
+ * 这个类是一个自定义的下拉菜单组件，它封装了Android的PopupMenu功能，
+ * 使得可以通过一个按钮来触发显示一个下拉菜单。
+ */
+package net.micode.notes.ui;
+
+import android.content.Context;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.PopupMenu;
+import android.widget.PopupMenu.OnMenuItemClickListener;
+
+import net.micode.notes.R;
+
+public class DropdownMenu {
+    // 成员变量，用于引用触发下拉菜单的按钮
+    private Button mButton;
+    // 成员变量，PopupMenu对象，实际的下拉菜单
+    private PopupMenu mPopupMenu;
+    // 成员变量，Menu对象，用于操作菜单项
+    private Menu mMenu;
+
+    /**
+     * DropdownMenu类的构造函数。
+     *
+     * @param context 上下文对象，通常是一个Activity或Service的实例
+     * @param button 触发下拉菜单显示的按钮
+     * @param menuId 要加载的菜单资源的ID
+     */
+    public DropdownMenu(Context context, Button button, int menuId) {
+        mButton = button;
+        // 设置按钮的背景为下拉箭头图标
+        mButton.setBackgroundResource(R.drawable.dropdown_icon);
+        // 创建PopupMenu对象，并将其锚点设置为传入的按钮
+        mPopupMenu = new PopupMenu(context, mButton);
+        // 获取PopupMenu的Menu对象
+        mMenu = mPopupMenu.getMenu();
+        // 通过menuId加载菜单资源，填充到Menu对象中
+        mPopupMenu.getMenuInflater().inflate(menuId, mMenu);
+        // 为按钮设置点击事件监听器，点击时显示PopupMenu
+        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 找到的MenuItem对象，如果没有找到则返回null
+     */
+    public MenuItem findItem(int id) {
+        return mMenu.findItem(id);
+    }
+
+    /**
+     * 设置触发下拉菜单的按钮上显示的标题。
+     *
+     * @param title 要显示的标题
+     */
+    public void setTitle(CharSequence title) {
+        mButton.setText(title);
+    }
+}
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.ui;
+
+import android.content.Context;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.PopupMenu;
+import android.widget.PopupMenu.OnMenuItemClickListener;
+
+import net.micode.notes.R;
+
+public class DropdownMenu {
+    private Button mButton;
+    private PopupMenu mPopupMenu;
+    private Menu mMenu;
+
+    public DropdownMenu(Context context, Button button, int menuId) {
+        mButton = button;
+        mButton.setBackgroundResource(R.drawable.dropdown_icon);
+        mPopupMenu = new PopupMenu(context, mButton);
+        mMenu = mPopupMenu.getMenu();
+        mPopupMenu.getMenuInflater().inflate(menuId, mMenu);
+        mButton.setOnClickListener(new OnClickListener() {
+            public void onClick(View v) {
+                mPopupMenu.show();
+            }
+        });
+    }
+
+    public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {
+        if (mPopupMenu != null) {
+            mPopupMenu.setOnMenuItemClickListener(listener);
+        }
+    }
+
+    public MenuItem findItem(int id) {
+        return mMenu.findItem(id);
+    }
+
+    public void setTitle(CharSequence title) {
+        mButton.setText(title);
+    }
+}

src/net/micode/notes/ui/ljxFoldersListAdapter.java

@@ -0,0 +1,125 @@
+/*
+ * 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;
+
+/**
+ * FoldersListAdapter 是一个 CursorAdapter，用于在列表中显示文件夹。
+ */
+public class FoldersListAdapter extends CursorAdapter {
+    // 查询文件夹时使用的投影列
+    public static final String[] PROJECTION = {
+            NoteColumns.ID, // 文件夹ID
+            NoteColumns.SNIPPET // 文件夹名称
+    };
+
+    // 列索引常量
+    public static final int ID_COLUMN = 0; // ID列的索引
+    public static final int NAME_COLUMN = 1; // 名称列的索引
+
+    /**
+     * 构造函数。
+     *
+     * @param context 上下文对象
+     * @param c       游标，包含文件夹数据
+     */
+    public FoldersListAdapter(Context context, Cursor c) {
+        super(context, c);
+    }
+
+    /**
+     * 创建新的列表项视图。
+     *
+     * @param context 上下文对象
+     * @param cursor  游标，包含文件夹数据
+     * @param parent  父视图
+     * @return 返回一个新的 FolderListItem 视图
+     */
+    @Override
+    public View newView(Context context, Cursor cursor, ViewGroup parent) {
+        return new FolderListItem(context); // 返回一个新的文件夹列表项视图
+    }
+
+    /**
+     * 绑定数据到视图。
+     *
+     * @param view    列表项视图
+     * @param context 上下文对象
+     * @param cursor  游标，包含文件夹数据
+     */
+    @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);
+    }
+
+    /**
+     * FolderListItem 是文件夹列表项的视图类，继承自 LinearLayout。
+     */
+    private class FolderListItem extends LinearLayout {
+        private TextView mName; // 用于显示文件夹名称的 TextView
+
+        /**
+         * 构造函数。
+         *
+         * @param context 上下文对象
+         */
+        public FolderListItem(Context context) {
+            super(context);
+            inflate(context, R.layout.folder_list_item, this); // 加载布局文件
+            mName = (TextView) findViewById(R.id.tv_folder_name); // 获取文件夹名称的 TextView
+        }
+
+        /**
+         * 绑定文件夹名称到视图。
+         *
+         * @param name 文件夹名称
+         */
+        public void bind(String name) {
+            mName.setText(name); // 设置文件夹名称
+        }
+    }
+}

src/net/micode/notes/ui/ljxNoteEditText.java

@@ -1,217 +1,235 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.micode.notes.ui;
-
-import android.content.Context;
-import android.graphics.Rect;
-import android.text.Layout;
-import android.text.Selection;
-import android.text.Spanned;
-import android.text.TextUtils;
-import android.text.style.URLSpan;
-import android.util.AttributeSet;
-import android.util.Log;
-import android.view.ContextMenu;
-import android.view.KeyEvent;
-import android.view.MenuItem;
-import android.view.MenuItem.OnMenuItemClickListener;
-import android.view.MotionEvent;
-import android.widget.EditText;
-
-import net.micode.notes.R;
-
-import java.util.HashMap;
-import java.util.Map;
-
-public class NoteEditText extends EditText {
-    private static final String TAG = "NoteEditText";
-    private int mIndex;
-    private int mSelectionStartBeforeDelete;
-
-    private static final String SCHEME_TEL = "tel:" ;
-    private static final String SCHEME_HTTP = "http:" ;
-    private static final String SCHEME_EMAIL = "mailto:" ;
-
-    private static final Map<String, Integer> sSchemaActionResMap = new HashMap<String, Integer>();
-    static {
-        sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel);
-        sSchemaActionResMap.put(SCHEME_HTTP, R.string.note_link_web);
-        sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email);
-    }
-
-    /**
-     * Call by the {@link NoteEditActivity} to delete or add edit text
-     */
-    public interface OnTextViewChangeListener {
-        /**
-         * Delete current edit text when {@link KeyEvent#KEYCODE_DEL} happens
-         * and the text is null
-         */
-        void onEditTextDelete(int index, String text);
-
-        /**
-         * Add edit text after current edit text when {@link KeyEvent#KEYCODE_ENTER}
-         * happen
-         */
-        void onEditTextEnter(int index, String text);
-
-        /**
-         * Hide or show item option when text change
-         */
-        void onTextChange(int index, boolean hasText);
-    }
-
-    private OnTextViewChangeListener mOnTextViewChangeListener;
-
-    public NoteEditText(Context context) {
-        super(context, null);
-        mIndex = 0;
-    }
-
-    public void setIndex(int index) {
-        mIndex = index;
-    }
-
-    public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
-        mOnTextViewChangeListener = listener;
-    }
-
-    public NoteEditText(Context context, AttributeSet attrs) {
-        super(context, attrs, android.R.attr.editTextStyle);
-    }
-
-    public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
-        super(context, attrs, defStyle);
-        // TODO Auto-generated constructor stub
-    }
-
-    @Override
-    public boolean onTouchEvent(MotionEvent event) {
-        switch (event.getAction()) {
-            case MotionEvent.ACTION_DOWN:
-
-                int x = (int) event.getX();
-                int y = (int) event.getY();
-                x -= getTotalPaddingLeft();
-                y -= getTotalPaddingTop();
-                x += getScrollX();
-                y += getScrollY();
-
-                Layout layout = getLayout();
-                int line = layout.getLineForVertical(y);
-                int off = layout.getOffsetForHorizontal(line, x);
-                Selection.setSelection(getText(), off);
-                break;
-        }
-
-        return super.onTouchEvent(event);
-    }
-
-    @Override
-    public boolean onKeyDown(int keyCode, KeyEvent event) {
-        switch (keyCode) {
-            case KeyEvent.KEYCODE_ENTER:
-                if (mOnTextViewChangeListener != null) {
-                    return false;
-                }
-                break;
-            case KeyEvent.KEYCODE_DEL:
-                mSelectionStartBeforeDelete = getSelectionStart();
-                break;
-            default:
-                break;
-        }
-        return super.onKeyDown(keyCode, event);
-    }
-
-    @Override
-    public boolean onKeyUp(int keyCode, KeyEvent event) {
-        switch(keyCode) {
-            case KeyEvent.KEYCODE_DEL:
-                if (mOnTextViewChangeListener != null) {
-                    if (0 == mSelectionStartBeforeDelete && mIndex != 0) {
-                        mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString());
-                        return true;
-                    }
-                } else {
-                    Log.d(TAG, "OnTextViewChangeListener was not seted");
-                }
-                break;
-            case KeyEvent.KEYCODE_ENTER:
-                if (mOnTextViewChangeListener != null) {
-                    int selectionStart = getSelectionStart();
-                    String text = getText().subSequence(selectionStart, length()).toString();
-                    setText(getText().subSequence(0, selectionStart));
-                    mOnTextViewChangeListener.onEditTextEnter(mIndex + 1, text);
-                } else {
-                    Log.d(TAG, "OnTextViewChangeListener was not seted");
-                }
-                break;
-            default:
-                break;
-        }
-        return super.onKeyUp(keyCode, event);
-    }
-
-    @Override
-    protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
-        if (mOnTextViewChangeListener != null) {
-            if (!focused && TextUtils.isEmpty(getText())) {
-                mOnTextViewChangeListener.onTextChange(mIndex, false);
-            } else {
-                mOnTextViewChangeListener.onTextChange(mIndex, true);
-            }
-        }
-        super.onFocusChanged(focused, direction, previouslyFocusedRect);
-    }
-
-    @Override
-    protected void onCreateContextMenu(ContextMenu menu) {
-        if (getText() instanceof Spanned) {
-            int selStart = getSelectionStart();
-            int selEnd = getSelectionEnd();
-
-            int min = Math.min(selStart, selEnd);
-            int max = Math.max(selStart, selEnd);
-
-            final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class);
-            if (urls.length == 1) {
-                int defaultResId = 0;
-                for(String schema: sSchemaActionResMap.keySet()) {
-                    if(urls[0].getURL().indexOf(schema) >= 0) {
-                        defaultResId = sSchemaActionResMap.get(schema);
-                        break;
-                    }
-                }
-
-                if (defaultResId == 0) {
-                    defaultResId = R.string.note_link_other;
-                }
-
-                menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener(
-                        new OnMenuItemClickListener() {
-                            public boolean onMenuItemClick(MenuItem item) {
-                                // goto a new intent
-                                urls[0].onClick(NoteEditText.this);
-                                return true;
-                            }
-                        });
-            }
-        }
-        super.onCreateContextMenu(menu);
-    }
-}
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.ui;
+
+import android.content.Context;
+import android.graphics.Rect;
+import android.text.Layout;
+import android.text.Selection;
+import android.text.Spanned;
+import android.text.TextUtils;
+import android.text.style.URLSpan;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.ContextMenu;
+import android.view.KeyEvent;
+import android.view.MenuItem;
+import android.view.MenuItem.OnMenuItemClickListener;
+import android.view.MotionEvent;
+import android.widget.EditText;
+
+import net.micode.notes.R;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class NoteEditText extends EditText {
+    // 日志标签
+    private static final String TAG = "NoteEditText";
+    // 当前编辑框的索引
+    private int mIndex;
+    // 删除操作前的光标起始位置
+    private int mSelectionStartBeforeDelete;
+
+    // 电话协议
+    private static final String SCHEME_TEL = "tel:";
+    // HTTP协议
+    private static final String SCHEME_HTTP = "http:";
+    // 邮件协议
+    private static final String SCHEME_EMAIL = "mailto:";
+
+    // 协议与对应操作的资源ID映射
+    private static final Map<String, Integer> sSchemaActionResMap = new HashMap<String, Integer>();
+    static {
+        sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel); // 电话链接
+        sSchemaActionResMap.put(SCHEME_HTTP, R.string.note_link_web); // 网页链接
+        sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email); // 邮件链接
+    }
+
+    /**
+     * 由 {@link NoteEditActivity} 调用的接口，用于删除或添加编辑框
+     */
+    public interface OnTextViewChangeListener {
+        /**
+         * 当按下 {@link KeyEvent#KEYCODE_DEL} 键且文本为空时，删除当前编辑框
+         */
+        void onEditTextDelete(int index, String text);
+
+        /**
+         * 当按下 {@link KeyEvent#KEYCODE_ENTER} 键时，在当前编辑框后添加新的编辑框
+         */
+        void onEditTextEnter(int index, String text);
+
+        /**
+         * 当文本发生变化时，隐藏或显示选项
+         */
+        void onTextChange(int index, boolean hasText);
+    }
+
+    // 文本变化监听器
+    private OnTextViewChangeListener mOnTextViewChangeListener;
+
+    // 构造函数
+    public NoteEditText(Context context) {
+        super(context, null);
+        mIndex = 0;
+    }
+
+    // 设置当前编辑框的索引
+    public void setIndex(int index) {
+        mIndex = index;
+    }
+
+    // 设置文本变化监听器
+    public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
+        mOnTextViewChangeListener = listener;
+    }
+
+    // 带属性集的构造函数
+    public NoteEditText(Context context, AttributeSet attrs) {
+        super(context, attrs, android.R.attr.editTextStyle);
+    }
+
+    // 带属性集和样式的构造函数
+    public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        switch (event.getAction()) {
+            case MotionEvent.ACTION_DOWN:
+                // 获取触摸点的坐标
+                int x = (int) event.getX();
+                int y = (int) event.getY();
+                x -= getTotalPaddingLeft();
+                y -= getTotalPaddingTop();
+                x += getScrollX();
+                y += getScrollY();
+
+                // 获取布局并设置光标位置
+                Layout layout = getLayout();
+                int line = layout.getLineForVertical(y);
+                int off = layout.getOffsetForHorizontal(line, x);
+                Selection.setSelection(getText(), off);
+                break;
+        }
+
+        return super.onTouchEvent(event);
+    }
+
+    @Override
+    public boolean onKeyDown(int keyCode, KeyEvent event) {
+        switch (keyCode) {
+            case KeyEvent.KEYCODE_ENTER:
+                // 按下回车键时，如果监听器存在，不处理默认行为
+                if (mOnTextViewChangeListener != null) {
+                    return false;
+                }
+                break;
+            case KeyEvent.KEYCODE_DEL:
+                // 按下删除键时，记录光标起始位置
+                mSelectionStartBeforeDelete = getSelectionStart();
+                break;
+            default:
+                break;
+        }
+        return super.onKeyDown(keyCode, event);
+    }
+
+    @Override
+    public boolean onKeyUp(int keyCode, KeyEvent event) {
+        switch (keyCode) {
+            case KeyEvent.KEYCODE_DEL:
+                // 松开删除键时，如果监听器存在且光标在起始位置，删除当前编辑框
+                if (mOnTextViewChangeListener != null) {
+                    if (0 == mSelectionStartBeforeDelete && mIndex != 0) {
+                        mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString());
+                        return true;
+                    }
+                } else {
+                    Log.d(TAG, "OnTextViewChangeListener was not seted");
+                }
+                break;
+            case KeyEvent.KEYCODE_ENTER:
+                // 松开回车键时，如果监听器存在，在当前编辑框后添加新的编辑框
+                if (mOnTextViewChangeListener != null) {
+                    int selectionStart = getSelectionStart();
+                    String text = getText().subSequence(selectionStart, length()).toString();
+                    setText(getText().subSequence(0, selectionStart));
+                    mOnTextViewChangeListener.onEditTextEnter(mIndex + 1, text);
+                } else {
+                    Log.d(TAG, "OnTextViewChangeListener was not seted");
+                }
+                break;
+            default:
+                break;
+        }
+        return super.onKeyUp(keyCode, event);
+    }
+
+    @Override
+    protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
+        // 焦点变化时，通知监听器文本是否为空
+        if (mOnTextViewChangeListener != null) {
+            if (!focused && TextUtils.isEmpty(getText())) {
+                mOnTextViewChangeListener.onTextChange(mIndex, false);
+            } else {
+                mOnTextViewChangeListener.onTextChange(mIndex, true);
+            }
+        }
+        super.onFocusChanged(focused, direction, previouslyFocusedRect);
+    }
+
+    @Override
+    protected void onCreateContextMenu(ContextMenu menu) {
+        // 创建上下文菜单，处理链接点击事件
+        if (getText() instanceof Spanned) {
+            int selStart = getSelectionStart();
+            int selEnd = getSelectionEnd();
+
+            int min = Math.min(selStart, selEnd);
+            int max = Math.max(selStart, selEnd);
+
+            final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class);
+            if (urls.length == 1) {
+                int defaultResId = 0;
+                for (String schema : sSchemaActionResMap.keySet()) {
+                    if (urls[0].getURL().indexOf(schema) >= 0) {
+                        defaultResId = sSchemaActionResMap.get(schema);
+                        break;
+                    }
+                }
+
+                if (defaultResId == 0) {
+                    defaultResId = R.string.note_link_other;
+                }
+
+                // 添加菜单项并设置点击事件
+                menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener(
+                        new OnMenuItemClickListener() {
+                            public boolean onMenuItemClick(MenuItem item) {
+                                // 跳转到链接对应的页面
+                                urls[0].onClick(NoteEditText.this);
+                                return true;
+                            }
+                        });
+            }
+        }
+        super.onCreateContextMenu(menu);
+    }
+}

src/net/micode/notes/ui/ljxNoteItemData.java

@@ -1,224 +1,228 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.micode.notes.ui;
-
-import android.content.Context;
-import android.database.Cursor;
-import android.text.TextUtils;
-
-import net.micode.notes.data.Contact;
-import net.micode.notes.data.Notes;
-import net.micode.notes.data.Notes.NoteColumns;
-import net.micode.notes.tool.DataUtils;
-
-
-public class NoteItemData {
-    static final String [] PROJECTION = new String [] {
-        NoteColumns.ID,
-        NoteColumns.ALERTED_DATE,
-        NoteColumns.BG_COLOR_ID,
-        NoteColumns.CREATED_DATE,
-        NoteColumns.HAS_ATTACHMENT,
-        NoteColumns.MODIFIED_DATE,
-        NoteColumns.NOTES_COUNT,
-        NoteColumns.PARENT_ID,
-        NoteColumns.SNIPPET,
-        NoteColumns.TYPE,
-        NoteColumns.WIDGET_ID,
-        NoteColumns.WIDGET_TYPE,
-    };
-
-    private static final int ID_COLUMN                    = 0;
-    private static final int ALERTED_DATE_COLUMN          = 1;
-    private static final int BG_COLOR_ID_COLUMN           = 2;
-    private static final int CREATED_DATE_COLUMN          = 3;
-    private static final int HAS_ATTACHMENT_COLUMN        = 4;
-    private static final int MODIFIED_DATE_COLUMN         = 5;
-    private static final int NOTES_COUNT_COLUMN           = 6;
-    private static final int PARENT_ID_COLUMN             = 7;
-    private static final int SNIPPET_COLUMN               = 8;
-    private static final int TYPE_COLUMN                  = 9;
-    private static final int WIDGET_ID_COLUMN             = 10;
-    private static final int WIDGET_TYPE_COLUMN           = 11;
-
-    private long mId;
-    private long mAlertDate;
-    private int mBgColorId;
-    private long mCreatedDate;
-    private boolean mHasAttachment;
-    private long mModifiedDate;
-    private int mNotesCount;
-    private long mParentId;
-    private String mSnippet;
-    private int mType;
-    private int mWidgetId;
-    private int mWidgetType;
-    private String mName;
-    private String mPhoneNumber;
-
-    private boolean mIsLastItem;
-    private boolean mIsFirstItem;
-    private boolean mIsOnlyOneItem;
-    private boolean mIsOneNoteFollowingFolder;
-    private boolean mIsMultiNotesFollowingFolder;
-
-    public NoteItemData(Context context, Cursor cursor) {
-        mId = cursor.getLong(ID_COLUMN);
-        mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN);
-        mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN);
-        mCreatedDate = cursor.getLong(CREATED_DATE_COLUMN);
-        mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0) ? true : false;
-        mModifiedDate = cursor.getLong(MODIFIED_DATE_COLUMN);
-        mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN);
-        mParentId = cursor.getLong(PARENT_ID_COLUMN);
-        mSnippet = cursor.getString(SNIPPET_COLUMN);
-        mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(
-                NoteEditActivity.TAG_UNCHECKED, "");
-        mType = cursor.getInt(TYPE_COLUMN);
-        mWidgetId = cursor.getInt(WIDGET_ID_COLUMN);
-        mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN);
-
-        mPhoneNumber = "";
-        if (mParentId == Notes.ID_CALL_RECORD_FOLDER) {
-            mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId);
-            if (!TextUtils.isEmpty(mPhoneNumber)) {
-                mName = Contact.getContact(context, mPhoneNumber);
-                if (mName == null) {
-                    mName = mPhoneNumber;
-                }
-            }
-        }
-
-        if (mName == null) {
-            mName = "";
-        }
-        checkPostion(cursor);
-    }
-
-    private void checkPostion(Cursor cursor) {
-        mIsLastItem = cursor.isLast() ? true : false;
-        mIsFirstItem = cursor.isFirst() ? true : false;
-        mIsOnlyOneItem = (cursor.getCount() == 1);
-        mIsMultiNotesFollowingFolder = false;
-        mIsOneNoteFollowingFolder = false;
-
-        if (mType == Notes.TYPE_NOTE && !mIsFirstItem) {
-            int position = cursor.getPosition();
-            if (cursor.moveToPrevious()) {
-                if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER
-                        || cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) {
-                    if (cursor.getCount() > (position + 1)) {
-                        mIsMultiNotesFollowingFolder = true;
-                    } else {
-                        mIsOneNoteFollowingFolder = true;
-                    }
-                }
-                if (!cursor.moveToNext()) {
-                    throw new IllegalStateException("cursor move to previous but can't move back");
-                }
-            }
-        }
-    }
-
-    public boolean isOneFollowingFolder() {
-        return mIsOneNoteFollowingFolder;
-    }
-
-    public boolean isMultiFollowingFolder() {
-        return mIsMultiNotesFollowingFolder;
-    }
-
-    public boolean isLast() {
-        return mIsLastItem;
-    }
-
-    public String getCallName() {
-        return mName;
-    }
-
-    public boolean isFirst() {
-        return mIsFirstItem;
-    }
-
-    public boolean isSingle() {
-        return mIsOnlyOneItem;
-    }
-
-    public long getId() {
-        return mId;
-    }
-
-    public long getAlertDate() {
-        return mAlertDate;
-    }
-
-    public long getCreatedDate() {
-        return mCreatedDate;
-    }
-
-    public boolean hasAttachment() {
-        return mHasAttachment;
-    }
-
-    public long getModifiedDate() {
-        return mModifiedDate;
-    }
-
-    public int getBgColorId() {
-        return mBgColorId;
-    }
-
-    public long getParentId() {
-        return mParentId;
-    }
-
-    public int getNotesCount() {
-        return mNotesCount;
-    }
-
-    public long getFolderId () {
-        return mParentId;
-    }
-
-    public int getType() {
-        return mType;
-    }
-
-    public int getWidgetType() {
-        return mWidgetType;
-    }
-
-    public int getWidgetId() {
-        return mWidgetId;
-    }
-
-    public String getSnippet() {
-        return mSnippet;
-    }
-
-    public boolean hasAlert() {
-        return (mAlertDate > 0);
-    }
-
-    public boolean isCallRecord() {
-        return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber));
-    }
-
-    public static int getNoteType(Cursor cursor) {
-        return cursor.getInt(TYPE_COLUMN);
-    }
-}
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0 
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// 这是一个Java类文件的注释，声明了版权所有者和许可证信息。该文件遵循Apache License 2.0。
+
+package net.micode.notes.ui; // 声明该类所在的包名
+
+import android.content.Context; // 导入Context类
+import android.database.Cursor; // 导入Cursor类，用于处理数据库查询结果
+import android.text.TextUtils; // 导入TextUtils类，用于处理字符串
+
+import net.micode.notes.data.Contact; // 导入Contact类，用于处理联系人数据
+import net.micode.notes.data.Notes; // 导入Notes类，用于处理笔记数据
+import net.micode.notes.data.Notes.NoteColumns; // 导入NoteColumns类，包含笔记数据的列名
+import net.micode.notes.tool.DataUtils; // 导入DataUtils类，包含数据处理的工具方法
+
+public class NoteItemData { // 定义NoteItemData类，用于表示单个笔记项的数据
+    static final String [] PROJECTION = new String [] { // 声明一个字符串数组，包含查询笔记数据时需要的列名
+        NoteColumns.ID,
+        NoteColumns.ALERTED_DATE,
+        NoteColumns.BG_COLOR_ID,
+        NoteColumns.CREATED_DATE,
+        NoteColumns.HAS_ATTACHMENT,
+        NoteColumns.MODIFIED_DATE,
+        NoteColumns.NOTES_COUNT,
+        NoteColumns.PARENT_ID,
+        NoteColumns.SNIPPET,
+        NoteColumns.TYPE,
+        NoteColumns.WIDGET_ID,
+        NoteColumns.WIDGET_TYPE,
+    };
+
+    // 定义列索引常量
+    private static final int ID_COLUMN = 0;
+    private static final int ALERTED_DATE_COLUMN = 1;
+    private static final int BG_COLOR_ID_COLUMN = 2;
+    private static final int CREATED_DATE_COLUMN = 3;
+    private static final int HAS_ATTACHMENT_COLUMN = 4;
+    private static final int MODIFIED_DATE_COLUMN = 5;
+    private static final int NOTES_COUNT_COLUMN = 6;
+    private static final int PARENT_ID_COLUMN = 7;
+    private static final int SNIPPET_COLUMN = 8;
+    private static final int TYPE_COLUMN = 9;
+    private static final int WIDGET_ID_COLUMN = 10;
+    private static final int WIDGET_TYPE_COLUMN = 11;
+
+    // 定义成员变量，存储笔记项的数据
+    private long mId;
+    private long mAlertDate;
+    private int mBgColorId;
+    private long mCreatedDate;
+    private boolean mHasAttachment;
+    private long mModifiedDate;
+    private int mNotesCount;
+    private long mParentId;
+    private String mSnippet;
+    private int mType;
+    private int mWidgetId;
+    private int mWidgetType;
+    private String mName; // 联系人姓名
+    private String mPhoneNumber; // 联系人电话号码
+
+    // 定义标记笔记项位置的成员变量
+    private boolean mIsLastItem;
+    private boolean mIsFirstItem;
+    private boolean mIsOnlyOneItem;
+    private boolean mIsOneNoteFollowingFolder;
+    private boolean mIsMultiNotesFollowingFolder;
+
+    public NoteItemData(Context context, Cursor cursor) { // 构造函数，从Cursor中初始化笔记项数据
+        mId = cursor.getLong(ID_COLUMN);
+        mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN);
+        mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN);
+        mCreatedDate = cursor.getLong(CREATED_DATE_COLUMN);
+        mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0) ? true : false;
+        mModifiedDate = cursor.getLong(MODIFIED_DATE_COLUMN);
+        mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN);
+        mParentId = cursor.getLong(PARENT_ID_COLUMN);
+        mSnippet = cursor.getString(SNIPPET_COLUMN);
+        mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(
+                NoteEditActivity.TAG_UNCHECKED, "");
+        mType = cursor.getInt(TYPE_COLUMN);
+        mWidgetId = cursor.getInt(WIDGET_ID_COLUMN);
+        mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN);
+
+        mPhoneNumber = "";
+        if (mParentId == Notes.ID_CALL_RECORD_FOLDER) { // 如果笔记项是通话记录文件夹
+            mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId); // 获取电话号码
+            if (!TextUtils.isEmpty(mPhoneNumber)) { // 如果电话号码不为空
+                mName = Contact.getContact(context, mPhoneNumber); // 获取联系人姓名
+                if (mName == null) { // 如果联系人姓名为空
+                    mName = mPhoneNumber; // 使用电话号码作为姓名
+                }
+            }
+        }
+
+        if (mName == null) { // 如果联系人姓名为空
+            mName = ""; // 设置为空字符串
+        }
+        checkPostion(cursor); // 检查笔记项的位置
+    }
+
+    private void checkPostion(Cursor cursor) { // 检查笔记项在数据库中的位置
+        mIsLastItem = cursor.isLast() ? true : false;
+        mIsFirstItem = cursor.isFirst() ? true : false;
+        mIsOnlyOneItem = (cursor.getCount() == 1);
+        mIsMultiNotesFollowingFolder = false;
+        mIsOneNoteFollowingFolder = false;
+
+        if (mType == Notes.TYPE_NOTE && !mIsFirstItem) { // 如果笔记项是笔记且不是第一项
+            int position = cursor.getPosition(); // 获取当前位置
+            if (cursor.moveToPrevious()) { // 移动到前一项
+                if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER
+                        || cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) {
+                    if (cursor.getCount() > (position + 1)) { // 如果后面有多于一项
+                        mIsMultiNotesFollowingFolder = true; // 设置为多笔记项跟随文件夹
+                    } else { // 否则
+                        mIsOneNoteFollowingFolder = true; // 设置为单个笔记项跟随文件夹
+                    }
+                }
+                if (!cursor.moveToNext()) { // 如果无法移动回原来的位置
+                    throw new IllegalStateException("cursor move to previous but can't move back"); // 抛出异常
+                }
+            }
+        }
+    }
+
+    // 以下是NoteItemData类的方法，用于获取笔记项的属性和状态
+    public boolean isOneFollowingFolder() {
+        return mIsOneNoteFollowingFolder;
+    }
+
+    public boolean isMultiFollowingFolder() {
+        return mIsMultiNotesFollowingFolder;
+    }
+
+    public boolean isLast() {
+        return mIsLastItem;
+    }
+
+    public String getCallName() {
+        return mName;
+    }
+
+    public boolean isFirst() {
+        return mIsFirstItem;
+    }
+
+    public boolean isSingle() {
+        return mIsOnlyOneItem;
+    }
+
+    public long getId() {
+        return mId;
+    }
+
+    public long getAlertDate() {
+        return mAlertDate;
+    }
+
+    public long getCreatedDate() {
+        return mCreatedDate;
+    }
+
+    public boolean hasAttachment() {
+        return mHasAttachment;
+    }
+
+    public long getModifiedDate() {
+        return mModifiedDate;
+    }
+
+    public int getBgColorId() {
+        return mBgColorId;
+    }
+
+    public long getParentId() {
+        return mParentId;
+    }
+
+    public int getNotesCount() {
+        return mNotesCount;
+    }
+
+    public long getFolderId() { // 获取文件夹ID
+        return mParentId;
+    }
+
+    public int getType() {
+        return mType;
+    }
+
+    public int getWidgetType() {
+        return mWidgetType;
+    }
+
+    public int getWidgetId() {
+        return mWidgetId;
+    }
+
+    public String getSnippet() {
+        return mSnippet;
+    }
+
+    public boolean hasAlert() { // 检查是否有提醒
+        return (mAlertDate > 0);
+    }
+
+    public boolean isCallRecord() { // 检查是否是通话记录
+        return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber));
+    }
+
+    public static int getNoteType(Cursor cursor) { // 从Cursor中获取笔记类型
+        return cursor.getInt(TYPE_COLUMN);
+    }
+}

src/net/micode/notes/ui/zhoujieNotesListAdapter.java

@@ -1,184 +1,208 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.micode.notes.ui;
-
-import android.content.Context;
-import android.database.Cursor;
-import android.util.Log;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.CursorAdapter;
-
-import net.micode.notes.data.Notes;
-
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-
-
-public class NotesListAdapter extends CursorAdapter {
-    private static final String TAG = "NotesListAdapter";
-    private Context mContext;
-    private HashMap<Integer, Boolean> mSelectedIndex;
-    private int mNotesCount;
-    private boolean mChoiceMode;
-
-    public static class AppWidgetAttribute {
-        public int widgetId;
-        public int widgetType;
-    };
-
-    public NotesListAdapter(Context context) {
-        super(context, null);
-        mSelectedIndex = new HashMap<Integer, Boolean>();
-        mContext = context;
-        mNotesCount = 0;
-    }
-
-    @Override
-    public View newView(Context context, Cursor cursor, ViewGroup parent) {
-        return new NotesListItem(context);
-    }
-
-    @Override
-    public void bindView(View view, Context context, Cursor cursor) {
-        if (view instanceof NotesListItem) {
-            NoteItemData itemData = new NoteItemData(context, cursor);
-            ((NotesListItem) view).bind(context, itemData, mChoiceMode,
-                    isSelectedItem(cursor.getPosition()));
-        }
-    }
-
-    public void setCheckedItem(final int position, final boolean checked) {
-        mSelectedIndex.put(position, checked);
-        notifyDataSetChanged();
-    }
-
-    public boolean isInChoiceMode() {
-        return mChoiceMode;
-    }
-
-    public void setChoiceMode(boolean mode) {
-        mSelectedIndex.clear();
-        mChoiceMode = mode;
-    }
-
-    public void selectAll(boolean checked) {
-        Cursor cursor = getCursor();
-        for (int i = 0; i < getCount(); i++) {
-            if (cursor.moveToPosition(i)) {
-                if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) {
-                    setCheckedItem(i, checked);
-                }
-            }
-        }
-    }
-
-    public HashSet<Long> getSelectedItemIds() {
-        HashSet<Long> itemSet = new HashSet<Long>();
-        for (Integer position : mSelectedIndex.keySet()) {
-            if (mSelectedIndex.get(position) == true) {
-                Long id = getItemId(position);
-                if (id == Notes.ID_ROOT_FOLDER) {
-                    Log.d(TAG, "Wrong item id, should not happen");
-                } else {
-                    itemSet.add(id);
-                }
-            }
-        }
-
-        return itemSet;
-    }
-
-    public HashSet<AppWidgetAttribute> getSelectedWidget() {
-        HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>();
-        for (Integer position : mSelectedIndex.keySet()) {
-            if (mSelectedIndex.get(position) == true) {
-                Cursor c = (Cursor) getItem(position);
-                if (c != null) {
-                    AppWidgetAttribute widget = new AppWidgetAttribute();
-                    NoteItemData item = new NoteItemData(mContext, c);
-                    widget.widgetId = item.getWidgetId();
-                    widget.widgetType = item.getWidgetType();
-                    itemSet.add(widget);
-                    /**
-                     * Don't close cursor here, only the adapter could close it
-                     */
-                } else {
-                    Log.e(TAG, "Invalid cursor");
-                    return null;
-                }
-            }
-        }
-        return itemSet;
-    }
-
-    public int getSelectedCount() {
-        Collection<Boolean> values = mSelectedIndex.values();
-        if (null == values) {
-            return 0;
-        }
-        Iterator<Boolean> iter = values.iterator();
-        int count = 0;
-        while (iter.hasNext()) {
-            if (true == iter.next()) {
-                count++;
-            }
-        }
-        return count;
-    }
-
-    public boolean isAllSelected() {
-        int checkedCount = getSelectedCount();
-        return (checkedCount != 0 && checkedCount == mNotesCount);
-    }
-
-    public boolean isSelectedItem(final int position) {
-        if (null == mSelectedIndex.get(position)) {
-            return false;
-        }
-        return mSelectedIndex.get(position);
-    }
-
-    @Override
-    protected void onContentChanged() {
-        super.onContentChanged();
-        calcNotesCount();
-    }
-
-    @Override
-    public void changeCursor(Cursor cursor) {
-        super.changeCursor(cursor);
-        calcNotesCount();
-    }
-
-    private void calcNotesCount() {
-        mNotesCount = 0;
-        for (int i = 0; i < getCount(); i++) {
-            Cursor c = (Cursor) getItem(i);
-            if (c != null) {
-                if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) {
-                    mNotesCount++;
-                }
-            } else {
-                Log.e(TAG, "Invalid cursor");
-                return;
-            }
-        }
-    }
-}
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.ui;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.CursorAdapter;
+
+import net.micode.notes.data.Notes;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+
+public class NotesListAdapter extends CursorAdapter {
+    // 日志标签
+    private static final String TAG = "NotesListAdapter";
+
+    // 上下文对象
+    private Context mContext;
+
+    // 存储选中项的索引和选中状态的映射
+    private HashMap<Integer, Boolean> mSelectedIndex;
+
+    // 笔记的总数
+    private int mNotesCount;
+
+    // 是否处于选择模式
+    private boolean mChoiceMode;
+
+    // 小部件属性类，用于存储小部件的ID和类型
+    public static class AppWidgetAttribute {
+        public int widgetId;
+        public int widgetType;
+    }
+
+    // 构造函数
+    public NotesListAdapter(Context context) {
+        super(context, null);
+        mSelectedIndex = new HashMap<Integer, Boolean>();
+        mContext = context;
+        mNotesCount = 0;
+    }
+
+    @Override
+    public View newView(Context context, Cursor cursor, ViewGroup parent) {
+        // 创建新的笔记列表项视图
+        return new NotesListItem(context);
+    }
+
+    @Override
+    public void bindView(View view, Context context, Cursor cursor) {
+        // 绑定数据到笔记列表项视图
+        if (view instanceof NotesListItem) {
+            NoteItemData itemData = new NoteItemData(context, cursor);
+            ((NotesListItem) view).bind(context, itemData, mChoiceMode,
+                    isSelectedItem(cursor.getPosition()));
+        }
+    }
+
+    // 设置指定位置的选中状态
+    public void setCheckedItem(final int position, final boolean checked) {
+        mSelectedIndex.put(position, checked);
+        notifyDataSetChanged();
+    }
+
+    // 判断是否处于选择模式
+    public boolean isInChoiceMode() {
+        return mChoiceMode;
+    }
+
+    // 设置选择模式
+    public void setChoiceMode(boolean mode) {
+        mSelectedIndex.clear();
+        mChoiceMode = mode;
+    }
+
+    // 全选或取消全选
+    public void selectAll(boolean checked) {
+        Cursor cursor = getCursor();
+        for (int i = 0; i < getCount(); i++) {
+            if (cursor.moveToPosition(i)) {
+                if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) {
+                    setCheckedItem(i, checked);
+                }
+            }
+        }
+    }
+
+    // 获取选中项的ID集合
+    public HashSet<Long> getSelectedItemIds() {
+        HashSet<Long> itemSet = new HashSet<Long>();
+        for (Integer position : mSelectedIndex.keySet()) {
+            if (mSelectedIndex.get(position) == true) {
+                Long id = getItemId(position);
+                if (id == Notes.ID_ROOT_FOLDER) {
+                    Log.d(TAG, "Wrong item id, should not happen");
+                } else {
+                    itemSet.add(id);
+                }
+            }
+        }
+
+        return itemSet;
+    }
+
+    // 获取选中项的小部件属性集合
+    public HashSet<AppWidgetAttribute> getSelectedWidget() {
+        HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>();
+        for (Integer position : mSelectedIndex.keySet()) {
+            if (mSelectedIndex.get(position) == true) {
+                Cursor c = (Cursor) getItem(position);
+                if (c != null) {
+                    AppWidgetAttribute widget = new AppWidgetAttribute();
+                    NoteItemData item = new NoteItemData(mContext, c);
+                    widget.widgetId = item.getWidgetId();
+                    widget.widgetType = item.getWidgetType();
+                    itemSet.add(widget);
+                    /**
+                     * 不要在这里关闭Cursor，只有适配器可以关闭它
+                     */
+                } else {
+                    Log.e(TAG, "Invalid cursor");
+                    return null;
+                }
+            }
+        }
+        return itemSet;
+    }
+
+    // 获取选中项的数量
+    public int getSelectedCount() {
+        Collection<Boolean> values = mSelectedIndex.values();
+        if (null == values) {
+            return 0;
+        }
+        Iterator<Boolean> iter = values.iterator();
+        int count = 0;
+        while (iter.hasNext()) {
+            if (true == iter.next()) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    // 判断是否全部选中
+    public boolean isAllSelected() {
+        int checkedCount = getSelectedCount();
+        return (checkedCount != 0 && checkedCount == mNotesCount);
+    }
+
+    // 判断指定位置的项是否被选中
+    public boolean isSelectedItem(final int position) {
+        if (null == mSelectedIndex.get(position)) {
+            return false;
+        }
+        return mSelectedIndex.get(position);
+    }
+
+    @Override
+    protected void onContentChanged() {
+        super.onContentChanged();
+        // 内容变化时重新计算笔记数量
+        calcNotesCount();
+    }
+
+    @Override
+    public void changeCursor(Cursor cursor) {
+        super.changeCursor(cursor);
+        // 更换Cursor时重新计算笔记数量
+        calcNotesCount();
+    }
+
+    // 计算笔记的数量
+    private void calcNotesCount() {
+        mNotesCount = 0;
+        for (int i = 0; i < getCount(); i++) {
+            Cursor c = (Cursor) getItem(i);
+            if (c != null) {
+                if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) {
+                    mNotesCount++;
+                }
+            } else {
+                Log.e(TAG, "Invalid cursor");
+                return;
+            }
+        }
+    }
+}

src/net/micode/notes/ui/zhoujieNotesListItem.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.text.format.DateUtils;
+ import android.view.View;
+ import android.widget.CheckBox;
+ import android.widget.ImageView;
+ import android.widget.LinearLayout;
+ import android.widget.TextView;
+ 
+ import net.micode.notes.R;
+ import net.micode.notes.data.Notes;
+ import net.micode.notes.tool.DataUtils;
+ import net.micode.notes.tool.ResourceParser.NoteItemBgResources;
+ 
+ 
+ /*
+  * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+  * you may not use this file except in compliance with the License.
+  * You may obtain a copy of the License at
+  *
+  *        http://www.apache.org/licenses/LICENSE-2.0
+  *
+  * Unless required by applicable law or agreed to in writing, software
+  * distributed under the License is distributed on an "AS IS" BASIS,
+  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  * See the License for the specific language governing permissions and
+  * limitations under the License.
+  */
+ 
+  package net.micode.notes.ui;
+ 
+  import android.content.Context;
+  import android.text.format.DateUtils;
+  import android.view.View;
+  import android.widget.CheckBox;
+  import android.widget.ImageView;
+  import android.widget.LinearLayout;
+  import android.widget.TextView;
+  
+  import net.micode.notes.R;
+  import net.micode.notes.data.Notes;
+  import net.micode.notes.tool.DataUtils;
+  import net.micode.notes.tool.ResourceParser.NoteItemBgResources;
+  
+  
+  // 定义一个名为NotesListItem的类，它继承自LinearLayout，用于显示笔记列表项
+  public class NotesListItem extends LinearLayout {
+      // 定义私有成员变量，用于存储界面元素和数据
+      private ImageView mAlert;
+      private TextView mTitle;
+      private TextView mTime;
+      private TextView mCallName;
+      private NoteItemData mItemData;
+      private CheckBox mCheckBox;
+  
+      // 构造函数，用于初始化NotesListItem
+      public NotesListItem(Context context) {
+          super(context); // 调用父类的构造函数
+          inflate(context, R.layout.note_item, this); // 将note_item布局文件加载到当前视图中
+          // 初始化界面元素
+          mAlert = (ImageView) findViewById(R.id.iv_alert_icon);
+          mTitle = (TextView) findViewById(R.id.tv_title);
+          mTime = (TextView) findViewById(R.id.tv_time);
+          mCallName = (TextView) findViewById(R.id.tv_name);
+          mCheckBox = (CheckBox) findViewById(android.R.id.checkbox);
+      }
+  
+      // 绑定数据和界面的方法
+      public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
+          // 根据选择模式和数据类型设置CheckBox的可见性和选中状态
+          if (choiceMode && data.getType() == Notes.TYPE_NOTE) {
+              mCheckBox.setVisibility(View.VISIBLE);
+              mCheckBox.setChecked(checked);
+          } else {
+              mCheckBox.setVisibility(View.GONE);
+          }
+  
+          mItemData = data; // 将传入的数据保存到成员变量中
+          // 根据不同的数据类型和属性设置界面元素的显示
+          if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
+              mCallName.setVisibility(View.GONE);
+              mAlert.setVisibility(View.VISIBLE);
+              mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
+              mTitle.setText(context.getString(R.string.call_record_folder_name)
+                      + context.getString(R.string.format_folder_files_count, data.getNotesCount()));
+              mAlert.setImageResource(R.drawable.call_record);
+          } else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
+              mCallName.setVisibility(View.VISIBLE);
+              mCallName.setText(data.getCallName());
+              mTitle.setTextAppearance(context,R.style.TextAppearanceSecondaryItem);
+              mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
+              if (data.hasAlert()) {
+                  mAlert.setImageResource(R.drawable.clock);
+                  mAlert.setVisibility(View.VISIBLE);
+              } else {
+                  mAlert.setVisibility(View.GONE);
+              }
+          } else {
+              mCallName.setVisibility(View.GONE);
+              mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
+  
+              if (data.getType() == Notes.TYPE_FOLDER) {
+                  mTitle.setText(data.getSnippet()
+                          + context.getString(R.string.format_folder_files_count,
+                                  data.getNotesCount()));
+                  mAlert.setVisibility(View.GONE);
+              } else {
+                  mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
+                  if (data.hasAlert()) {
+                      mAlert.setImageResource(R.drawable.clock);
+                      mAlert.setVisibility(View.VISIBLE);
+                  } else {
+                      mAlert.setVisibility(View.GONE);
+                  }
+              }
+          }
+          mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate())); // 设置时间显示
+  
+          setBackground(data); // 设置背景
+      }
+  
+      // 设置背景的方法
+      private void setBackground(NoteItemData data) {
+          int id = data.getBgColorId(); // 获取背景颜色ID
+          // 根据数据类型和属性设置背景资源
+          if (data.getType() == Notes.TYPE_NOTE) {
+              if (data.isSingle() || data.isOneFollowingFolder()) {
+                  setBackgroundResource(NoteItemBgResources.getNoteBgSingleRes(id));
+              } else if (data.isLast()) {
+                  setBackgroundResource(NoteItemBgResources.getNoteBgLastRes(id));
+              } else if (data.isFirst() || data.isMultiFollowingFolder()) {
+                  setBackgroundResource(NoteItemBgResources.getNoteBgFirstRes(id));
+              } else {
+                  setBackgroundResource(NoteItemBgResources.getNoteBgNormalRes(id));
+              }
+          } else {
+              setBackgroundResource(NoteItemBgResources.getFolderBgRes());
+          }
+      }
+  
+      // 获取当前项的数据
+      public NoteItemData getItemData() {
+          return mItemData;
+      }
+  }

src/net/micode/notes/ui/zhoujieNotesPreferenceActivity.java

@@ -1,388 +1,239 @@
-/*
- * 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;
-
-
-public class NotesPreferenceActivity extends PreferenceActivity {
-    public static final String PREFERENCE_NAME = "notes_preferences";
-
-    public static final String PREFERENCE_SYNC_ACCOUNT_NAME = "pref_key_account_name";
-
-    public static final String PREFERENCE_LAST_SYNC_TIME = "pref_last_sync_time";
-
-    public static final String PREFERENCE_SET_BG_COLOR_KEY = "pref_key_bg_random_appear";
-
-    private static final String PREFERENCE_SYNC_ACCOUNT_KEY = "pref_sync_account_key";
-
-    private static final String AUTHORITIES_FILTER_KEY = "authorities";
-
-    private PreferenceCategory mAccountCategory;
-
-    private GTaskReceiver mReceiver;
-
-    private Account[] mOriAccounts;
-
-    private boolean mHasAddedAccount;
-
-    @Override
-    protected void onCreate(Bundle icicle) {
-        super.onCreate(icicle);
-
-        /* using the app icon for navigation */
-        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();
-
-        // need to set sync account automatically if user has added a new
-        // account
-        if (mHasAddedAccount) {
-            Account[] accounts = getGoogleAccounts();
-            if (mOriAccounts != null && accounts.length > mOriAccounts.length) {
-                for (Account accountNew : accounts) {
-                    boolean found = false;
-                    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();
-    }
-
-    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)) {
-                        // the first time to set account
-                        showSelectAccountAlertDialog();
-                    } else {
-                        // if the account has already been set, we need to promp
-                        // user about the risk
-                        showChangeAccountConfirmAlertDialog();
-                    }
-                } else {
-                    Toast.makeText(NotesPreferenceActivity.this,
-                            R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
-                            .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);
-
-        // set button state
-        if (GTaskSyncService.isSyncing()) {
-            syncButton.setText(getString(R.string.preferences_button_sync_cancel));
-            syncButton.setOnClickListener(new View.OnClickListener() {
-                public void onClick(View v) {
-                    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)));
-
-        // set last sync time
-        if (GTaskSyncService.isSyncing()) {
-            lastSyncTimeView.setText(GTaskSyncService.getProgressString());
-            lastSyncTimeView.setVisibility(View.VISIBLE);
-        } else {
-            long lastSyncTime = getLastSyncTime(this);
-            if (lastSyncTime != 0) {
-                lastSyncTimeView.setText(getString(R.string.preferences_last_sync_time,
-                        DateFormat.format(getString(R.string.preferences_last_sync_time_format),
-                                lastSyncTime)));
-                lastSyncTimeView.setVisibility(View.VISIBLE);
-            } else {
-                lastSyncTimeView.setVisibility(View.GONE);
-            }
-        }
-    }
-
-    private void refreshUI() {
-        loadAccountPreference();
-        loadSyncButton();
-    }
-
-    private void showSelectAccountAlertDialog() {
-        AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
-
-        View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
-        TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
-        titleTextView.setText(getString(R.string.preferences_dialog_select_account_title));
-        TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
-        subtitleTextView.setText(getString(R.string.preferences_dialog_select_account_tips));
-
-        dialogBuilder.setCustomTitle(titleView);
-        dialogBuilder.setPositiveButton(null, null);
-
-        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();
-    }
-
-    private Account[] getGoogleAccounts() {
-        AccountManager accountManager = AccountManager.get(this);
-        return accountManager.getAccountsByType("com.google");
-    }
-
-    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();
-
-            // clean up last sync time
-            setLastSyncTime(this, 0);
-
-            // clean up local gtask related info
-            new Thread(new Runnable() {
-                public void run() {
-                    ContentValues values = new ContentValues();
-                    values.put(NoteColumns.GTASK_ID, "");
-                    values.put(NoteColumns.SYNC_ID, 0);
-                    getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
-                }
-            }).start();
-
-            Toast.makeText(NotesPreferenceActivity.this,
-                    getString(R.string.preferences_toast_success_set_accout, account),
-                    Toast.LENGTH_SHORT).show();
-        }
-    }
-
-    private void removeSyncAccount() {
-        SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
-        SharedPreferences.Editor editor = settings.edit();
-        if (settings.contains(PREFERENCE_SYNC_ACCOUNT_NAME)) {
-            editor.remove(PREFERENCE_SYNC_ACCOUNT_NAME);
-        }
-        if (settings.contains(PREFERENCE_LAST_SYNC_TIME)) {
-            editor.remove(PREFERENCE_LAST_SYNC_TIME);
-        }
-        editor.commit();
-
-        // clean up local gtask related info
-        new Thread(new Runnable() {
-            public void run() {
-                ContentValues values = new ContentValues();
-                values.put(NoteColumns.GTASK_ID, "");
-                values.put(NoteColumns.SYNC_ID, 0);
-                getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
-            }
-        }).start();
-    }
-
-    public static String getSyncAccountName(Context context) {
-        SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
-                Context.MODE_PRIVATE);
-        return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
-    }
-
-    public static void setLastSyncTime(Context context, long time) {
-        SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
-                Context.MODE_PRIVATE);
-        SharedPreferences.Editor editor = settings.edit();
-        editor.putLong(PREFERENCE_LAST_SYNC_TIME, time);
-        editor.commit();
-    }
-
-    public static long getLastSyncTime(Context context) {
-        SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
-                Context.MODE_PRIVATE);
-        return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);
-    }
-
-    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;
-        }
-    }
-}
+/*
+ * 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.
+ */
+// 定义了一个名为NotesPreferenceActivity的类，它继承自PreferenceActivity，用于展示应用的设置界面。
+
+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;
+
+// 类成员变量声明
+public class NotesPreferenceActivity extends PreferenceActivity {
+    public static final String PREFERENCE_NAME = "notes_preferences"; // 偏好文件名
+    public static final String PREFERENCE_SYNC_ACCOUNT_NAME = "pref_key_account_name"; // 同步账户名的键
+    public static final String PREFERENCE_LAST_SYNC_TIME = "pref_last_sync_time"; // 最后同步时间的键
+    public static final String PREFERENCE_SET_BG_COLOR_KEY = "pref_key_bg_random_appear"; // 设置背景颜色的键
+    private static final String PREFERENCE_SYNC_ACCOUNT_KEY = "pref_sync_account_key"; // 同步账户的键
+    private static final String AUTHORITIES_FILTER_KEY = "authorities"; // 账户类型过滤键
+    private PreferenceCategory mAccountCategory; // 账户类别的PreferenceCategory
+    private GTaskReceiver mReceiver; // 用于接收GTask同步服务广播的Receiver
+    private Account[] mOriAccounts; // 原始账户数组
+    private boolean mHasAddedAccount; // 是否添加了账户的标志
+
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+        // 设置ActionBar的返回键
+        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(); // 刷新UI
+    }
+
+    @Override
+    protected void onDestroy() {
+        if (mReceiver != null) {
+            unregisterReceiver(mReceiver); // 注销广播接收器
+        }
+        super.onDestroy();
+    }
+
+    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)) {
+                        // 第一次设置账户时显示选择账户的AlertDialog
+                        showSelectAccountAlertDialog();
+                    } else {
+                        // 如果账户已经设置，提示用户更改账户的风险
+                        showChangeAccountConfirmAlertDialog();
+                    }
+                } else {
+                    Toast.makeText(NotesPreferenceActivity.this,
+                            R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
+                            .show();
+                }
+                return true;
+            }
+        });
+
+        mAccountCategory.addPreference(accountPref); // 添加账户偏好项
+    }
+
+    private void loadSyncButton() {
+        Button syncButton = (Button) findViewById(R.id.preference_sync_button);
+        TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
+
+        // 设置同步按钮的状态
+        if (GTaskSyncService.isSyncing()) {
+            syncButton.setText(getString(R.string.preferences_button_sync_cancel));
+            syncButton.setOnClickListener(new View.OnClickListener() {
+                public void onClick(View v) {
+                    GTaskSyncService.cancelSync(NotesPreferenceActivity.this); // 取消同步
+                }
+            });
+        } else {
+            syncButton.setText(getString(R.string.preferences_button_sync_immediately));
+            syncButton.setOnClickListener(new View.OnClickListener() {
+                public void onClick(View v) {
+                    GTaskSyncService.startSync(NotesPreferenceActivity.this); // 开始同步
+                }
+            });
+        }
+        syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this))); // 根据账户名是否为空设置按钮是否可用
+
+        // 设置最后同步时间
+        if (GTaskSyncService.isSyncing()) {
+            lastSyncTimeView.setText(GTaskSyncService.getProgressString()); // 显示同步进度
+            lastSyncTimeView.setVisibility(View.VISIBLE);
+        } else {
+            long lastSyncTime = getLastSyncTime(this);
+            if (lastSyncTime != 0) {
+                lastSyncTimeView.setText(getString(R.string.preferences_last_sync_time,
+                        DateFormat.format(getString(R.string.preferences_last_sync_time_format),
+                                lastSyncTime)));
+                lastSyncTimeView.setVisibility(View.VISIBLE);
+            } else {
+                lastSyncTimeView.setVisibility(View.GONE);
+            }
+        }
+    }
+
+    private void refreshUI() {
+        loadAccountPreference(); // 加载账户偏好
+        loadSyncButton(); // 加载同步按钮
+    }
+
+    private void showSelectAccountAlertDialog() {
+        AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
+
+        View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
+        TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
+        titleTextView.setText(getString(R.string.preferences_dialog_select_account_title));
+        TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
+        subtitleTextView.setText(getString(R.string.preferences_dialog_select_account_tips));
+
+        dialogBuilder.setCustomTitle(titleView); // 设置自定义标题
+        dialogBuilder.setPositiveButton(null, null); // 不设置确定按钮
+
+        Account[] accounts = getGoogleAccounts(); // 获取Google账户
+        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); // 启动

src/net/micode/notes/widget/NoteWidgetProvider.java

@@ -1,201 +0,0 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.micode.notes.widget;
-
-import android.app.PendingIntent;
-import android.appwidget.AppWidgetManager;
-import android.appwidget.AppWidgetProvider;
-import android.content.ContentValues;
-import android.content.Context;
-import android.content.Intent;
-import android.database.Cursor;
-import android.util.Log;
-import android.widget.RemoteViews;
-
-import net.micode.notes.R;
-import net.micode.notes.data.Notes;
-import net.micode.notes.data.Notes.NoteColumns;
-import net.micode.notes.tool.ResourceParser;
-import net.micode.notes.ui.NoteEditActivity;
-import net.micode.notes.ui.NotesListActivity;
-
-/**
- * 抽象类，继承自AppWidgetProvider，用于处理便签小部件的数据和更新UI。
- */
-public abstract class NoteWidgetProvider extends AppWidgetProvider {
-    /**
-     * 数据库查询字段。
-     */
-    public static final String [] PROJECTION = new String [] {
-        NoteColumns.ID,
-        NoteColumns.BG_COLOR_ID,
-        NoteColumns.SNIPPET
-    };
-
-    /**
-     * 数据库查询字段索引。
-     */
-    public static final int COLUMN_ID           = 0;
-    public static final int COLUMN_BG_COLOR_ID  = 1;
-    public static final int COLUMN_SNIPPET      = 2;
-
-    /**
-     * 日志标签，用于Logcat中过滤日志。
-     */
-    private static final String TAG = "NoteWidgetProvider";
-
-    /**
-     * 当小部件被删除时，更新数据库中相关笔记的WIDGET_ID为无效值。
-     *
-     * @param context 上下文对象。
-     * @param appWidgetIds 被删除的小部件ID数组。
-     */
-    @Override
-    public void onDeleted(Context context, int[] appWidgetIds) {
-        ContentValues values = new ContentValues();
-        values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
-        for (int i = 0; i < appWidgetIds.length; i++) {
-            context.getContentResolver().update(Notes.CONTENT_NOTE_URI,
-                    values,
-                    NoteColumns.WIDGET_ID + "=?",
-                    new String[] { String.valueOf(appWidgetIds[i])});
-        }
-    }
-
-    /**
-     * 获取特定小部件的笔记信息。
-     *
-     * @param context 上下文对象。
-     * @param widgetId 小部件ID。
-     * @return 包含笔记信息的Cursor对象。
-     */
-    private Cursor getNoteWidgetInfo(Context context, int widgetId) {
-        return context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
-                PROJECTION,
-                NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?",
-                new String[] { String.valueOf(widgetId), String.valueOf(Notes.ID_TRASH_FOLER) },
-                null);
-    }
-
-    /**
-     * 更新小部件的UI。
-     *
-     * @param context 上下文对象。
-     * @param appWidgetManager AppWidgetManager对象，用于管理小部件。
-     * @param appWidgetIds 小部件ID数组。
-     */
-    protected void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
-        update(context, appWidgetManager, appWidgetIds, false);
-    }
-
-
-    private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds,
-        boolean privacyMode) {
-    // 遍历所有的小部件ID
-    for (int i = 0; i < appWidgetIds.length; i++) {
-        // 检查小部件ID是否有效
-        if (appWidgetIds[i] != AppWidgetManager.INVALID_APPWIDGET_ID) {
-            // 默认背景资源ID
-            int bgId = ResourceParser.getDefaultBgId(context);
-            // 笔记摘要字符串
-            String snippet = "";
-            // 用于编辑或查看笔记的Intent
-            Intent intent = new Intent(context, NoteEditActivity.class);
-            intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
-            intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]); // 小部件ID
-            intent.putExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, getWidgetType()); // 小部件类型
-
-            // 获取小部件的笔记信息
-            Cursor c = getNoteWidgetInfo(context, appWidgetIds[i]);
-            if (c != null && c.moveToFirst()) {
-                // 如果有多个相同的小部件ID，记录错误并返回
-                if (c.getCount() > 1) {
-                    Log.e(TAG, "Multiple message with same widget id:" + appWidgetIds[i]);
-                    c.close();
-                    return;
-                }
-                // 获取笔记摘要和背景ID
-                snippet = c.getString(COLUMN_SNIPPET);
-                bgId = c.getInt(COLUMN_BG_COLOR_ID);
-                intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID)); // 笔记ID
-                intent.setAction(Intent.ACTION_VIEW); // 设置Intent动作为查看
-            } else {
-                // 如果没有找到笔记，设置摘要为默认字符串，Intent动作为插入或编辑
-                snippet = context.getResources().getString(R.string.widget_havenot_content);
-                intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
-            }
-
-            // 关闭Cursor
-            if (c != null) {
-                c.close();
-            }
-
-            // 创建RemoteViews对象，用于更新小部件的UI
-            RemoteViews rv = new RemoteViews(context.getPackageName(), getLayoutId());
-            // 设置小部件背景资源
-            rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId));
-            // 将背景ID传递给Intent
-            intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId);
-
-            /**
-             * 生成PendingIntent，以便在小部件点击时启动宿主Activity。
-             */
-            PendingIntent pendingIntent = null;
-            if (privacyMode) {
-                // 如果是隐私模式，显示隐私模式文本
-                rv.setTextViewText(R.id.widget_text, context.getString(R.string.widget_under_visit_mode));
-                // 创建PendingIntent，点击小部件时打开笔记列表Activity
-                pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], new Intent(
-                        context, NotesListActivity.class), PendingIntent.FLAG_UPDATE_CURRENT);
-            } else {
-                // 否则，显示笔记摘要
-                rv.setTextViewText(R.id.widget_text, snippet);
-                // 创建PendingIntent，点击小部件时打开编辑或查看笔记的Activity
-                pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], intent,
-                        PendingIntent.FLAG_UPDATE_CURRENT);
-            }
-
-            // 设置小部件文本的点击PendingIntent
-            rv.setOnClickPendingIntent(R.id.widget_text, pendingIntent);
-            // 更新小部件的UI
-            appWidgetManager.updateAppWidget(appWidgetIds[i], rv);
-        }
-    }
-}
-
-/**
- * 获取背景资源ID的方法，需要在子类中实现。
- *
- * @param bgId 背景ID。
- * @return 对应的背景资源ID。
- */
-protected abstract int getBgResourceId(int bgId);
-
-/**
- * 获取小部件布局ID的方法，需要在子类中实现。
- *
- * @return 小部件的布局ID。
- */
-protected abstract int getLayoutId();
-
-/**
- * 获取小部件类型的方法，需要在子类中实现。
- *
- * @return 小部件的类型。
- */
-protected abstract int getWidgetType();
-}

src/net/micode/notes/widget/NoteWidgetProvider_2x.java

@@ -1,79 +0,0 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.micode.notes.widget;
-
-import android.appwidget.AppWidgetManager;
-import android.content.Context;
-
-import net.micode.notes.R;
-import net.micode.notes.data.Notes;
-import net.micode.notes.tool.ResourceParser;
-
-/**
- * 便签小部件的2x2版本实现。
- * 这个类继承自NoteWidgetProvider，并提供了特定于2x2小部件的实现。
- */
-public class NoteWidgetProvider_2x extends NoteWidgetProvider {
-    /**
-     * 当小部件需要更新时，调用此方法。
-     * 这个方法会被AppWidgetManager在小部件需要更新时触发。
-     *
-     * @param context 上下文对象，通常是一个Activity或Service的实例。
-     * @param appWidgetManager AppWidgetManager对象，用于管理小部件。
-     * @param appWidgetIds 小部件ID数组，表示需要更新的小部件。
-     */
-    @Override
-    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
-        // 调用父类的update方法来执行更新逻辑
-        super.update(context, appWidgetManager, appWidgetIds);
-    }
-
-    /**
-     * 获取小部件的布局ID。
-     * 每个小部件都有自己的布局文件，这个方法返回2x2小部件的布局ID。
-     *
-     * @return 小部件的布局ID。
-     */
-    @Override
-    protected int getLayoutId() {
-        return R.layout.widget_2x;
-    }
-
-    /**
-     * 根据背景ID获取对应的资源ID。
-     * 这个方法使用ResourceParser来解析背景资源ID，并返回2x2小部件对应的背景资源ID。
-     *
-     * @param bgId 背景ID。
-     * @return 对应的背景资源ID。
-     */
-    @Override
-    protected int getBgResourceId(int bgId) {
-        return ResourceParser.WidgetBgResources.getWidget2xBgResource(bgId);
-    }
-
-    /**
-     * 获取小部件的类型。
-     * 每个小部件都有一个类型，用于区分不同的小部件。
-     * 这个方法返回2x2小部件的类型。
-     *
-     * @return 小部件的类型。
-     */
-    @Override
-    protected int getWidgetType() {
-        return Notes.TYPE_WIDGET_2X;
-    }
-}

src/net/micode/notes/widget/周诗程NoteWidgetProvider_2x.java

@@ -0,0 +1,606 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.widget;
+
+import android.appwidget.AppWidgetManager;
+import android.content.Context;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.tool.ResourceParser;
+
+/**
+ * 便签小部件的2x2版本实现。
+ * 这个类继承自NoteWidgetProvider，并提供了特定于2x2小部件的实现。
+ */
+public class NoteWidgetProvider_2x extends NoteWidgetProvider {
+    /**
+     * 当小部件需要更新时，调用此方法。
+     * 这个方法会被AppWidgetManager在小部件需要更新时触发。
+     *
+     * @param context 上下文对象，通常是一个Activity或Service的实例。
+     * @param appWidgetManager AppWidgetManager对象，用于管理小部件。
+     * @param appWidgetIds 小部件ID数组，表示需要更新的小部件。
+     */
+    @Override
+    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
+        // 调用父类的update方法来执行更新逻辑
+        super.update(context, appWidgetManager, appWidgetIds);
+    }
+
+    /**
+     * 获取小部件的布局ID。
+     * 每个小部件都有自己的布局文件，这个方法返回2x2小部件的布局ID。
+     *
+     * @return 小部件的布局ID。
+     */
+    @Override
+    protected int getLayoutId() {
+        return R.layout.widget_2x;
+    }
+
+    /**
+     * 根据背景ID获取对应的资源ID。
+     * 这个方法使用ResourceParser来解析背景资源ID，并返回2x2小部件对应的背景资源ID。
+     *
+     * @param bgId 背景ID。
+     * @return 对应的背景资源ID。
+     */
+    @Override
+    protected int getBgResourceId(int bgId) {
+        return ResourceParser.WidgetBgResources.getWidget2xBgResource(bgId);
+    }
+
+    /**
+     * 获取小部件的类型。
+     * 每个小部件都有一个类型，用于区分不同的小部件。
+     * 这个方法返回2x2小部件的类型。
+     *
+     * @return 小部件的类型。
+     */
+    @Override
+    protected int getWidgetType() {
+        return Notes.TYPE_WIDGET_2X;
+    }
+}
+
+/*
+ * 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.model;
+
+import android.appwidget.AppWidgetManager;
+import android.content.ContentUris;
+import android.content.Context;
+import android.database.Cursor;
+import android.text.TextUtils;
+import android.util.Log;
+
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.CallNote;
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.DataConstants;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.data.Notes.TextNote;
+import net.micode.notes.tool.ResourceParser.NoteBgResources;
+
+/**
+ * WorkingNote 类表示一个正在工作的笔记实体，包含笔记的数据和相关操作。
+ */
+public class WorkingNote {
+    // 笔记对象
+    private Note mNote;
+    // 笔记ID
+    private long mNoteId;
+    // 笔记内容
+    private String mContent;
+    // 笔记模式
+    private int mMode;
+
+    // 笔记提醒日期
+    private long mAlertDate;
+    // 笔记修改日期
+    private long mModifiedDate;
+    // 笔记背景颜色ID
+    private int mBgColorId;
+    // 笔记小部件ID
+    private int mWidgetId;
+    // 笔记小部件类型
+    private int mWidgetType;
+    // 笔记所属文件夹ID
+    private long mFolderId;
+    // 应用程序上下文
+    private Context mContext;
+    // 日志标签
+    private static final String TAG = "WorkingNote";
+    // 标记笔记是否已删除
+    private boolean mIsDeleted;
+    // 笔记设置更改监听器
+    private NoteSettingChangedListener mNoteSettingStatusListener;
+
+    // 数据库查询时使用的列投影
+    public static final String[] DATA_PROJECTION = new String[] {
+            DataColumns.ID,
+            DataColumns.CONTENT,
+            DataColumns.MIME_TYPE,
+            DataColumns.DATA1,
+            DataColumns.DATA2,
+            DataColumns.DATA3,
+            DataColumns.DATA4,
+    };
+
+    // 笔记数据库查询时使用的列投影
+    public static final String[] NOTE_PROJECTION = new String[] {
+            NoteColumns.PARENT_ID,
+            NoteColumns.ALERTED_DATE,
+            NoteColumns.BG_COLOR_ID,
+            NoteColumns.WIDGET_ID,
+            NoteColumns.WIDGET_TYPE,
+            NoteColumns.MODIFIED_DATE
+    };
+
+    // 数据库查询列的索引
+    private static final int DATA_ID_COLUMN = 0;
+    private static final int DATA_CONTENT_COLUMN = 1;
+    private static final int DATA_MIME_TYPE_COLUMN = 2;
+    private static final int DATA_MODE_COLUMN = 3;
+    private static final int NOTE_PARENT_ID_COLUMN = 0;
+    private static final int NOTE_ALERTED_DATE_COLUMN = 1;
+    private static final int NOTE_BG_COLOR_ID_COLUMN = 2;
+    private static final int NOTE_WIDGET_ID_COLUMN = 3;
+    private static final int NOTE_WIDGET_TYPE_COLUMN = 4;
+    private static final int NOTE_MODIFIED_DATE_COLUMN = 5;
+
+    /**
+     * WorkingNote 类的构造函数，用于创建一个新的笔记。
+     *
+     * @param context 应用程序上下文
+     * @param folderId 笔记所属的文件夹ID
+     */
+    private WorkingNote(Context context, long folderId) {
+        mContext = context;
+        mAlertDate = 0;
+        mModifiedDate = System.currentTimeMillis();
+        mFolderId = folderId;
+        mNote = new Note();
+        mNoteId = 0;
+        mIsDeleted = false;
+        mMode = 0;
+        mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
+    }
+
+    /**
+     * WorkingNote 类的构造函数，用于加载一个已存在的笔记。
+     *
+     * @param context 应用程序上下文
+     * @param noteId 笔记ID
+     * @param folderId 笔记所属的文件夹ID
+     */
+    private WorkingNote(Context context, long noteId, long folderId) {
+        mContext = context;
+        mNoteId = noteId;
+        mFolderId = folderId;
+        mIsDeleted = false;
+        mNote = new Note();
+        loadNote();
+    }
+
+    /**
+     * 从数据库加载笔记数据。
+     */
+    private void loadNote() {
+        Cursor cursor = mContext.getContentResolver().query(
+                ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
+                null, null);
+
+        if (cursor != null) {
+            if (cursor.moveToFirst()) {
+                mFolderId = cursor.getLong(NOTE_PARENT_ID_COLUMN);
+                mBgColorId = cursor.getInt(NOTE_BG_COLOR_ID_COLUMN);
+                mWidgetId = cursor.getInt(NOTE_WIDGET_ID_COLUMN);
+                mWidgetType = cursor.getInt(NOTE_WIDGET_TYPE_COLUMN);
+                mAlertDate = cursor.getLong(NOTE_ALERTED_DATE_COLUMN);
+                mModifiedDate = cursor.getLong(NOTE_MODIFIED_DATE_COLUMN);
+            }
+            cursor.close();
+        } else {
+            Log.e(TAG, "No note with id:" + mNoteId);
+            throw new IllegalArgumentException("Unable to find note with id " + mNoteId);
+        }
+        loadNoteData();
+    }
+
+    /**
+     * 从数据库加载笔记的内容数据。
+     */
+    private void loadNoteData() {
+        Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION,
+                DataColumns.NOTE_ID + "=?", new String[] {
+                    String.valueOf(mNoteId)
+                }, null);
+
+        if (cursor != null) {
+            if (cursor.moveToFirst()) {
+                do {
+                    String type = cursor.getString(DATA_MIME_TYPE_COLUMN);
+                    if (DataConstants.NOTE.equals(type)) {
+                        mContent = cursor.getString(DATA_CONTENT_COLUMN);
+                        mMode = cursor.getInt(DATA_MODE_COLUMN);
+                        mNote.setTextDataId(cursor.getLong(DATA_ID_COLUMN));
+                    } else if (DataConstants.CALL_NOTE.equals(type)) {
+                        mNote.setCallDataId(cursor.getLong(DATA_ID_COLUMN));
+                    } else {
+                        Log.d(TAG, "Wrong note type with type:" + type);
+                    }
+                } while (cursor.moveToNext());
+            }
+            cursor.close();
+        } else {
+            Log.e(TAG, "No data with id:" + mNoteId);
+            throw new IllegalArgumentException("Unable to find note's data with id " + mNoteId);
+        }
+    }
+
+    /**
+     * 创建一个空的笔记实例。
+     *
+     * @param context 应用程序上下文
+     * @param folderId 笔记所属的文件夹ID
+     * @param widgetId 笔记小部件ID
+     * @param widgetType 笔记小部件类型
+     * @param defaultBgColorId 默认背景颜色ID
+     * @return 空的笔记实例
+     */
+    public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
+            int widgetType, int defaultBgColorId) {
+        WorkingNote note = new WorkingNote(context, folderId);
+        note.setBgColorId(defaultBgColorId);
+        note.setWidgetId(widgetId);
+        note.setWidgetType(widgetType);
+        return note;
+    }
+
+    /**
+     * 从数据库加载一个笔记实例。
+     *
+     * @param context 应用程序上下文
+     * @param id 笔记ID
+     * @return 笔记实例
+     */
+    public static WorkingNote load(Context context, long id) {
+        return new WorkingNote(context, id, 0);
+    }
+
+    /**
+     * 保存笔记到数据库。
+     *
+     * @return 如果保存成功，返回 true
+     */
+    public synchronized boolean saveNote() {
+        if (isWorthSaving()) {
+            if (!existInDatabase()) {
+                if ((mNoteId = Note.getNewNoteId(mContext, mFolderId)) == 0) {
+                    Log.e(TAG, "Create new note fail with id:" + mNoteId);
+                    return false;
+                }
+            }
+
+            mNote.syncNote(mContext, mNoteId);
+
+            // 如果存在任何小部件，则更新小部件内容
+            if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+                    && mWidgetType != Notes.TYPE_WIDGET_INVALIDE
+                    && mNoteSettingStatusListener != null) {
+                mNoteSettingStatusListener.onWidgetChanged();
+            }
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 检查笔记是否存在于数据库中。
+     *
+     * @return 如果存在，返回 true
+     */
+    public boolean existInDatabase() {
+        return mNoteId > 0;
+    }
+
+    /**
+     * 检查笔记是否值得保存。
+     *
+     * @return 如果值得保存，返回 true
+     */
+    private boolean isWorthSaving() {
+        if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
+                || (existInDatabase() && !mNote.isLocalModified())) {
+            return false;
+        } else {
+            return true;
+        }
+    }
+
+    /**
+     * 设置笔记设置更改监听器。
+     *
+     * @param l 监听器实例
+     */
+    public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
+        mNoteSettingStatusListener = l;
+    }
+
+    /**
+     * 设置提醒日期。
+     *
+     * @param date 提醒日期
+     * @param set 是否设置提醒
+     */
+    public void setAlertDate(long date, boolean set) {
+        if (date != mAlertDate) {
+            mAlertDate = date;
+            mNote.setNoteValue(NoteColumns.ALERTED_DATE, String.valueOf(mAlertDate));
+        }
+        if (mNoteSettingStatusListener != null) {
+            mNoteSettingStatusListener.onClockAlertChanged(date, set);
+        }
+    }
+
+    /**
+     * 标记笔记是否被删除。
+     *
+     * @param mark 是否标记为删除
+     */
+    public void markDeleted(boolean mark) {
+        mIsDeleted = mark;
+        if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+                && mWidgetType != Notes.TYPE_WIDGET_INVALIDE && mNoteSettingStatusListener != null) {
+            mNoteSettingStatusListener.onWidgetChanged();
+        }
+    }
+
+    /**
+     * 设置笔记的背景颜色ID。
+     *
+     * @param id 背景颜色ID
+     */
+    public void setBgColorId(int id) {
+        if (id != mBgColorId) {
+            mBgColorId = id;
+            if (mNoteSettingStatusListener != null) {
+                mNoteSettingStatusListener.onBackgroundColorChanged();
+            }
+            mNote.setNoteValue(NoteColumns.BG_COLOR_ID, String.valueOf(id));
+        }
+    }
+
+    /**
+     * 设置笔记的清单模式。
+     *
+     * @param mode 清单模式
+     */
+    public void setCheckListMode(int mode) {
+        if (mMode != mode) {
+            if (mNoteSettingStatusListener != null) {
+                mNoteSettingStatusListener.onCheckListModeChanged(mMode, mode);
+            }
+            mMode = mode;
+            mNote.setTextData(TextNote.MODE, String.valueOf(mMode));
+        }
+    }
+
+    /**
+     * 设置小部件类型。
+     *
+     * @param type 小部件类型
+     */
+    public void setWidgetType(int type) {
+        if (type != mWidgetType) {
+            mWidgetType = type;
+            mNote.setNoteValue(NoteColumns.WIDGET_TYPE, String.valueOf(mWidgetType));
+        }
+    }
+
+    /**
+     * 设置小部件ID。
+     *
+     * @param id 小部件ID
+     */
+    public void setWidgetId(int id) {
+        if (id != mWidgetId) {
+            mWidgetId = id;
+            mNote.setNoteValue(NoteColumns.WIDGET_ID, String.valueOf(mWidgetId));
+        }
+    }
+
+    /**
+     * 设置笔记的工作文本。
+     *
+     * @param text 笔记内容
+     */
+    public void setWorkingText(String text) {
+        if (!TextUtils.equals(mContent, text)) {
+            mContent = text;
+            mNote.setTextData(DataColumns.CONTENT, mContent);
+        }
+    }
+
+    /**
+     * 将笔记转换为通话记录笔记。
+     *
+     * @param phoneNumber 电话号码
+     * @param callDate 通话日期
+     */
+    public void convertToCallNote(String phoneNumber, long callDate) {
+        mNote.setCallData(CallNote.CALL_DATE, String.valueOf(callDate));
+        mNote.setCallData(CallNote.PHONE_NUMBER, phoneNumber);
+        mNote.setNoteValue(NoteColumns.PARENT_ID, String.valueOf(Notes.ID_CALL_RECORD_FOLDER));
+    }
+
+    /**
+     * 检查笔记是否有提醒。
+     *
+     * @return 如果有提醒，返回 true
+     */
+    public boolean hasClockAlert() {
+        return (mAlertDate > 0 ? true : false);
+    }
+
+    /**
+     * 获取笔记的内容。
+     *
+     * @return 笔记内容
+     */
+    public String getContent() {
+        return mContent;
+    }
+
+    /**
+     * 获取提醒日期。
+     *
+     * @return 提醒日期
+     */
+    public long getAlertDate() {
+        return mAlertDate;
+    }
+
+    /**
+     * 获取笔记的修改日期。
+     *
+     * @return 修改日期
+     */
+    public long getModifiedDate() {
+        return mModifiedDate;
+    }
+
+    /**
+     * 获取背景颜色资源ID。
+     *
+     * @return 背景颜色资源ID
+     */
+    public int getBgColorResId() {
+        return NoteBgResources.getNoteBgResource(mBgColorId);
+    }
+
+    /**
+     * 获取背景颜色ID。
+     *
+     * @return 背景颜色ID
+     */
+    public int getBgColorId() {
+        return mBgColorId;
+    }
+
+    /**
+     * 获取标题背景资源ID。
+     *
+     * @return 标题背景资源ID
+     */
+    public int getTitleBgResId() {
+        return NoteBgResources.getNoteTitleBgResource(mBgColorId);
+    }
+
+    /**
+     * 获取清单模式。
+     *
+     * @return 清单模式
+     */
+    public int getCheckListMode() {
+        return mMode;
+    }
+
+    /**
+     * 获取笔记ID。
+     *
+     * @return 笔记ID
+     */
+    public long getNoteId() {
+        return mNoteId;
+    }
+
+    /**
+     * 获取文件夹ID。
+     *
+     * @return 文件夹ID
+     */
+    public long getFolderId() {
+        return mFolderId;
+    }
+
+    /**
+     * 获取小部件ID。
+     *
+     * @return 小部件ID
+     */
+    public int getWidgetId() {
+        return mWidgetId;
+    }
+
+    /**
+     * 获取小部件类型。
+     *
+     * @return 小部件类型
+     */
+    public int getWidgetType() {
+        return mWidgetType;
+    }
+
+    /**
+     * 笔记设置更改监听器接口。
+     */
+    public interface NoteSettingChangedListener {
+        /**
+         * 当前笔记的背景颜色刚刚更改时调用。
+         */
+        void onBackgroundColorChanged();
+
+        /**
+         * 用户设置时钟时调用。
+         *
+         * @param date 提醒日期
+         * @param set 是否设置提醒
+         */
+        void onClockAlertChanged(long date, boolean set);
+
+        /**
+         * 用户从小部件创建笔记时调用。
+         */
+        void onWidgetChanged();
+
+        /**
+         * 用户在清单模式和普通模式之间切换时调用。
+         *
+         * @param oldMode 更改前的模式
+         * @param newMode 新的模式
+         */
+        void onCheckListModeChanged(int oldMode, int newMode);
+    }
+}