小米便签model文件和tool文件的java代码注释

小米便签model文件和tool文件的java代码注释

TEST.txt

@@ -1 +1,2 @@
-第一步21312213cccc
+第一步21312213cccc666611111
+dhjebjc

doc/解析文档.txt

@@ -0,0 +1 @@
+213wqe1231111

pyx_gitpractice

@@ -0,0 +1 @@
+Subproject commit 87902d310e6c672d3d3a95ead30c1beb0754068f

src%2Ftool/DataUtils.java

@@ -0,0 +1,295 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.tool;
+
+import android.content.ContentProviderOperation;
+import android.content.ContentProviderResult;
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.OperationApplicationException;
+import android.database.Cursor;
+import android.os.RemoteException;
+import android.util.Log;
+
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.CallNote;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+
+
+public class DataUtils {
+    public static final String TAG = "DataUtils";
+    public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
+        if (ids == null) {
+            Log.d(TAG, "the ids is null");
+            return true;
+        }
+        if (ids.size() == 0) {
+            Log.d(TAG, "no id is in the hashset");
+            return true;
+        }
+
+        ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
+        for (long id : ids) {
+            if(id == Notes.ID_ROOT_FOLDER) {
+                Log.e(TAG, "Don't delete system folder root");
+                continue;
+            }
+            ContentProviderOperation.Builder builder = ContentProviderOperation
+                    .newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
+            operationList.add(builder.build());
+        }
+        try {
+            ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
+            if (results == null || results.length == 0 || results[0] == null) {
+                Log.d(TAG, "delete notes failed, ids:" + ids.toString());
+                return false;
+            }
+            return true;
+        } catch (RemoteException e) {
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        } catch (OperationApplicationException e) {
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        }
+        return false;
+    }
+
+    public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
+        ContentValues values = new ContentValues();
+        values.put(NoteColumns.PARENT_ID, desFolderId);
+        values.put(NoteColumns.ORIGIN_PARENT_ID, srcFolderId);
+        values.put(NoteColumns.LOCAL_MODIFIED, 1);
+        resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
+    }
+
+    public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids,
+            long folderId) {
+        if (ids == null) {
+            Log.d(TAG, "the ids is null");
+            return true;
+        }
+
+        ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
+        for (long id : ids) {
+            ContentProviderOperation.Builder builder = ContentProviderOperation
+                    .newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
+            builder.withValue(NoteColumns.PARENT_ID, folderId);
+            builder.withValue(NoteColumns.LOCAL_MODIFIED, 1);
+            operationList.add(builder.build());
+        }
+
+        try {
+            ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
+            if (results == null || results.length == 0 || results[0] == null) {
+                Log.d(TAG, "delete notes failed, ids:" + ids.toString());
+                return false;
+            }
+            return true;
+        } catch (RemoteException e) {
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        } catch (OperationApplicationException e) {
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        }
+        return false;
+    }
+
+    /**
+     * Get the all folder count except system folders {@link Notes#TYPE_SYSTEM}}
+     */
+    public static int getUserFolderCount(ContentResolver resolver) {
+        Cursor cursor =resolver.query(Notes.CONTENT_NOTE_URI,
+                new String[] { "COUNT(*)" },
+                NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>?",
+                new String[] { String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER)},
+                null);
+
+        int count = 0;
+        if(cursor != null) {
+            if(cursor.moveToFirst()) {
+                try {
+                    count = cursor.getInt(0);
+                } catch (IndexOutOfBoundsException e) {
+                    Log.e(TAG, "get folder count failed:" + e.toString());
+                } finally {
+                    cursor.close();
+                }
+            }
+        }
+        return count;
+    }
+
+    public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
+        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
+                null,
+                NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER,
+                new String [] {String.valueOf(type)},
+                null);
+
+        boolean exist = false;
+        if (cursor != null) {
+            if (cursor.getCount() > 0) {
+                exist = true;
+            }
+            cursor.close();
+        }
+        return exist;
+    }
+
+    public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
+        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
+                null, null, null, null);
+
+        boolean exist = false;
+        if (cursor != null) {
+            if (cursor.getCount() > 0) {
+                exist = true;
+            }
+            cursor.close();
+        }
+        return exist;
+    }
+
+    public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
+        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId),
+                null, null, null, null);
+
+        boolean exist = false;
+        if (cursor != null) {
+            if (cursor.getCount() > 0) {
+                exist = true;
+            }
+            cursor.close();
+        }
+        return exist;
+    }
+
+    public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
+        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,
+                NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER +
+                " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER +
+                " AND " + NoteColumns.SNIPPET + "=?",
+                new String[] { name }, null);
+        boolean exist = false;
+        if(cursor != null) {
+            if(cursor.getCount() > 0) {
+                exist = true;
+            }
+            cursor.close();
+        }
+        return exist;
+    }
+
+    public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
+        Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
+                new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE },
+                NoteColumns.PARENT_ID + "=?",
+                new String[] { String.valueOf(folderId) },
+                null);
+
+        HashSet<AppWidgetAttribute> set = null;
+        if (c != null) {
+            if (c.moveToFirst()) {
+                set = new HashSet<AppWidgetAttribute>();
+                do {
+                    try {
+                        AppWidgetAttribute widget = new AppWidgetAttribute();
+                        widget.widgetId = c.getInt(0);
+                        widget.widgetType = c.getInt(1);
+                        set.add(widget);
+                    } catch (IndexOutOfBoundsException e) {
+                        Log.e(TAG, e.toString());
+                    }
+                } while (c.moveToNext());
+            }
+            c.close();
+        }
+        return set;
+    }
+
+    public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
+        Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
+                new String [] { CallNote.PHONE_NUMBER },
+                CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?",
+                new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE },
+                null);
+
+        if (cursor != null && cursor.moveToFirst()) {
+            try {
+                return cursor.getString(0);
+            } catch (IndexOutOfBoundsException e) {
+                Log.e(TAG, "Get call number fails " + e.toString());
+            } finally {
+                cursor.close();
+            }
+        }
+        return "";
+    }
+
+    public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
+        Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
+                new String [] { CallNote.NOTE_ID },
+                CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL("
+                + CallNote.PHONE_NUMBER + ",?)",
+                new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber },
+                null);
+
+        if (cursor != null) {
+            if (cursor.moveToFirst()) {
+                try {
+                    return cursor.getLong(0);
+                } catch (IndexOutOfBoundsException e) {
+                    Log.e(TAG, "Get call note id fails " + e.toString());
+                }
+            }
+            cursor.close();
+        }
+        return 0;
+    }
+
+    public static String getSnippetById(ContentResolver resolver, long noteId) {
+        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
+                new String [] { NoteColumns.SNIPPET },
+                NoteColumns.ID + "=?",
+                new String [] { String.valueOf(noteId)},
+                null);
+
+        if (cursor != null) {
+            String snippet = "";
+            if (cursor.moveToFirst()) {
+                snippet = cursor.getString(0);
+            }
+            cursor.close();
+            return snippet;
+        }
+        throw new IllegalArgumentException("Note is not found with id: " + noteId);
+    }
+
+    public static String getFormattedSnippet(String snippet) {
+        if (snippet != null) {
+            snippet = snippet.trim();
+            int index = snippet.indexOf('\n');
+            if (index != -1) {
+                snippet = snippet.substring(0, index);
+            }
+        }
+        return snippet;
+    }
+}

src/Ftool/DataUtils.java

@@ -0,0 +1,467 @@
+//*
+ * 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 内容解析器，用于与内容提供者进行交互
+     * @param ids 要删除的笔记的 ID 集合
+     * @return 如果删除成功返回 true，否则返回 false
+     */
+    public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
+        // 检查传入的 ID 集合是否为空
+        if (ids == null) {
+            // 如果为空，记录日志并返回 true
+            Log.d(TAG, "the ids is null");
+            return true;
+        }
+        // 检查 ID 集合的大小是否为 0
+        if (ids.size() == 0) {
+            // 如果为 0，记录日志并返回 true
+            Log.d(TAG, "no id is in the hashset");
+            return true;
+        }
+
+        // 创建一个用于存储内容提供者操作的列表
+        ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
+        // 遍历 ID 集合
+        for (long id : ids) {
+            // 检查是否为系统根文件夹的 ID，如果是则不进行删除操作并记录错误日志
+            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) {
+                // 如果无效，记录日志并返回 false
+                Log.d(TAG, "delete notes failed, ids:" + ids.toString());
+                return false;
+            }
+            // 操作成功，返回 true
+            return true;
+        } catch (RemoteException e) {
+            // 捕获远程异常并记录错误日志
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        } catch (OperationApplicationException e) {
+            // 捕获操作应用异常并记录错误日志
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        }
+        // 发生异常，返回 false
+        return false;
+    }
+
+    /**
+     * 将单个笔记移动到指定文件夹的方法。
+     * 
+     * @param resolver 内容解析器，用于与内容提供者进行交互
+     * @param id 要移动的笔记的 ID
+     * @param srcFolderId 笔记的源文件夹 ID
+     * @param desFolderId 笔记要移动到的目标文件夹 ID
+     */
+    public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
+        // 创建一个 ContentValues 对象，用于存储要更新的字段和值
+        ContentValues values = new ContentValues();
+        // 设置笔记的父文件夹 ID 为目标文件夹 ID
+        values.put(NoteColumns.PARENT_ID, desFolderId);
+        // 设置笔记的原始父文件夹 ID 为源文件夹 ID
+        values.put(NoteColumns.ORIGIN_PARENT_ID, srcFolderId);
+        // 设置笔记的本地修改标志为 1
+        values.put(NoteColumns.LOCAL_MODIFIED, 1);
+        // 执行更新操作，将笔记移动到目标文件夹
+        resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
+    }
+
+    /**
+     * 批量将笔记移动到指定文件夹的方法。
+     * 
+     * @param resolver 内容解析器，用于与内容提供者进行交互
+     * @param ids 要移动的笔记的 ID 集合
+     * @param folderId 笔记要移动到的目标文件夹 ID
+     * @return 如果移动成功返回 true，否则返回 false
+     */
+    public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids,
+            long folderId) {
+        // 检查传入的 ID 集合是否为空
+        if (ids == null) {
+            // 如果为空，记录日志并返回 true
+            Log.d(TAG, "the ids is null");
+            return true;
+        }
+
+        // 创建一个用于存储内容提供者操作的列表
+        ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
+        // 遍历 ID 集合
+        for (long id : ids) {
+            // 创建一个更新操作的构建器
+            ContentProviderOperation.Builder builder = ContentProviderOperation
+                    .newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
+            // 设置笔记的父文件夹 ID 为目标文件夹 ID
+            builder.withValue(NoteColumns.PARENT_ID, folderId);
+            // 设置笔记的本地修改标志为 1
+            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) {
+                // 如果无效，记录日志并返回 false
+                Log.d(TAG, "delete notes failed, ids:" + ids.toString());
+                return false;
+            }
+            // 操作成功，返回 true
+            return true;
+        } catch (RemoteException e) {
+            // 捕获远程异常并记录错误日志
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        } catch (OperationApplicationException e) {
+            // 捕获操作应用异常并记录错误日志
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        }
+        // 发生异常，返回 false
+        return false;
+    }
+
+    /**
+     * 获取除系统文件夹外的所有用户文件夹数量的方法。
+     * 
+     * @param resolver 内容解析器，用于与内容提供者进行交互
+     * @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_FOLER)},
+                null);
+
+        // 初始化文件夹数量为 0
+        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 内容解析器，用于与内容提供者进行交互
+     * @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_FOLER,
+                new String [] {String.valueOf(type)},
+                null);
+
+        // 初始化存在标志为 false
+        boolean exist = false;
+        // 检查游标是否不为空
+        if (cursor != null) {
+            // 检查游标中的记录数量是否大于 0
+            if (cursor.getCount() > 0) {
+                // 如果大于 0，说明笔记存在，设置存在标志为 true
+                exist = true;
+            }
+            // 关闭游标
+            cursor.close();
+        }
+        // 返回存在标志
+        return exist;
+    }
+
+    /**
+     * 检查笔记是否存在于数据库中的方法。
+     * 
+     * @param resolver 内容解析器，用于与内容提供者进行交互
+     * @param noteId 要检查的笔记的 ID
+     * @return 如果笔记存在返回 true，否则返回 false
+     */
+    public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
+        // 查询笔记数据库，检查笔记是否存在
+        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
+                null, null, null, null);
+
+        // 初始化存在标志为 false
+        boolean exist = false;
+        // 检查游标是否不为空
+        if (cursor != null) {
+            // 检查游标中的记录数量是否大于 0
+            if (cursor.getCount() > 0) {
+                // 如果大于 0，说明笔记存在，设置存在标志为 true
+                exist = true;
+            }
+            // 关闭游标
+            cursor.close();
+        }
+        // 返回存在标志
+        return exist;
+    }
+
+    /**
+     * 检查数据是否存在于数据库中的方法。
+     * 
+     * @param resolver 内容解析器，用于与内容提供者进行交互
+     * @param dataId 要检查的数据的 ID
+     * @return 如果数据存在返回 true，否则返回 false
+     */
+    public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
+        // 查询数据数据库，检查数据是否存在
+        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId),
+                null, null, null, null);
+
+        // 初始化存在标志为 false
+        boolean exist = false;
+        // 检查游标是否不为空
+        if (cursor != null) {
+            // 检查游标中的记录数量是否大于 0
+            if (cursor.getCount() > 0) {
+                // 如果大于 0，说明数据存在，设置存在标志为 true
+                exist = true;
+            }
+            // 关闭游标
+            cursor.close();
+        }
+        // 返回存在标志
+        return exist;
+    }
+
+    /**
+     * 检查可见文件夹名称是否已存在的方法。
+     * 
+     * @param resolver 内容解析器，用于与内容提供者进行交互
+     * @param name 要检查的文件夹名称
+     * @return 如果文件夹名称已存在返回 true，否则返回 false
+     */
+    public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
+        // 查询笔记数据库，检查可见文件夹名称是否已存在
+        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,
+                NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER +
+                " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER +
+                " AND " + NoteColumns.SNIPPET + "=?",
+                new String[] { name }, null);
+        // 初始化存在标志为 false
+        boolean exist = false;
+        // 检查游标是否不为空
+        if(cursor != null) {
+            // 检查游标中的记录数量是否大于 0
+            if(cursor.getCount() > 0) {
+                // 如果大于 0，说明文件夹名称已存在，设置存在标志为 true
+                exist = true;
+            }
+            // 关闭游标
+            cursor.close();
+        }
+        // 返回存在标志
+        return exist;
+    }
+
+    /**
+     * 获取指定文件夹下的笔记小部件属性集合的方法。
+     * 
+     * @param resolver 内容解析器，用于与内容提供者进行交互
+     * @param folderId 文件夹的 ID
+     * @return 笔记小部件属性的集合，如果没有则返回 null
+     */
+    public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
+        // 查询笔记数据库，获取指定文件夹下的笔记小部件信息
+        Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
+                new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE },
+                NoteColumns.PARENT_ID + "=?",
+                new String[] { String.valueOf(folderId) },
+                null);
+
+        // 初始化小部件属性集合为 null
+        HashSet<AppWidgetAttribute> set = null;
+        // 检查游标是否不为空
+        if (c != null) {
+            // 将游标移动到第一行
+            if (c.moveToFirst()) {
+                // 创建一个小部件属性集合
+                set = new HashSet<AppWidgetAttribute>();
+                do {
+                    try {
+                        // 创建一个小部件属性对象
+                        AppWidgetAttribute widget = new AppWidgetAttribute();
+                        // 从游标中获取小部件 ID
+                        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 内容解析器，用于与内容提供者进行交互
+     * @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 内容解析器，用于与内容提供者进行交互
+     * @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;
+    }
+
+    public static String getSnippetById(ContentResolver resolver, long noteId) {
+        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
+                new String [] { NoteColumns.SNIPPET },
+                NoteColumns.ID + "=?",
+                new String [] { String.valueOf(noteId)},
+                null);
+
+        if (cursor != null) {
+            String snippet = "";
+            if (cursor.moveToFirst()) {
+                snippet = cursor.getString(0);
+            }
+            cursor.close();
+            return snippet;
+        }
+        throw new IllegalArgumentException("Note is not found with id: " + noteId);
+    }
+
+    public static String getFormattedSnippet(String snippet) {
+        if (snippet != null) {
+            snippet = snippet.trim();
+            int index = snippet.indexOf('\n');
+            if (index != -1) {
+                snippet = snippet.substring(0, index);
+            }
+        }
+        return snippet;
+    }
+}

src/Ftool/ResourceParser.java

@@ -0,0 +1,270 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.tool;
+
+import android.content.Context;
+import android.preference.PreferenceManager;
+
+import net.micode.notes.R;
+import net.micode.notes.ui.NotesPreferenceActivity;
+
+/**
+ * 该类用于解析和管理笔记应用中的资源，包括背景颜色、字体大小、不同界面元素的背景资源等。
+ */
+public class ResourceParser {
+
+    // 定义笔记背景颜色的常量
+    public static final int YELLOW           = 0;
+    public static final int BLUE             = 1;
+    public static final int WHITE            = 2;
+    public static final int GREEN            = 3;
+    public static final int RED              = 4;
+
+    // 默认的笔记背景颜色
+    public static final int BG_DEFAULT_COLOR = YELLOW;
+
+    // 定义笔记字体大小的常量
+    public static final int TEXT_SMALL       = 0;
+    public static final int TEXT_MEDIUM      = 1;
+    public static final int TEXT_LARGE       = 2;
+    public static final int TEXT_SUPER       = 3;
+
+    // 默认的笔记字体大小
+    public static final int BG_DEFAULT_FONT_SIZE = TEXT_MEDIUM;
+
+    /**
+     * 该静态内部类用于管理笔记编辑界面的背景资源。
+     */
+    public static class NoteBgResources {
+        // 笔记编辑界面的背景资源数组
+        private final static int [] BG_EDIT_RESOURCES = new int [] {
+            R.drawable.edit_yellow,
+            R.drawable.edit_blue,
+            R.drawable.edit_white,
+            R.drawable.edit_green,
+            R.drawable.edit_red
+        };
+
+        // 笔记编辑界面标题的背景资源数组
+        private final static int [] BG_EDIT_TITLE_RESOURCES = new int [] {
+            R.drawable.edit_title_yellow,
+            R.drawable.edit_title_blue,
+            R.drawable.edit_title_white,
+            R.drawable.edit_title_green,
+            R.drawable.edit_title_red
+        };
+
+        /**
+         * 根据传入的颜色 ID 获取笔记编辑界面的背景资源 ID。
+         * @param id 颜色 ID，对应前面定义的颜色常量
+         * @return 笔记编辑界面的背景资源 ID
+         */
+        public static int getNoteBgResource(int id) {
+            return BG_EDIT_RESOURCES[id];
+        }
+
+        /**
+         * 根据传入的颜色 ID 获取笔记编辑界面标题的背景资源 ID。
+         * @param id 颜色 ID，对应前面定义的颜色常量
+         * @return 笔记编辑界面标题的背景资源 ID
+         */
+        public static int getNoteTitleBgResource(int id) {
+            return BG_EDIT_TITLE_RESOURCES[id];
+        }
+    }
+
+    /**
+     * 获取默认的笔记背景颜色 ID。
+     * 如果用户在偏好设置中开启了随机背景颜色选项，则随机返回一个颜色 ID；
+     * 否则返回默认的背景颜色 ID。
+     * @param context 上下文对象
+     * @return 默认的笔记背景颜色 ID
+     */
+    public static int getDefaultBgId(Context context) {
+        if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean(
+                NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) {
+            return (int) (Math.random() * NoteBgResources.BG_EDIT_RESOURCES.length);
+        } else {
+            return BG_DEFAULT_COLOR;
+        }
+    }
+
+    /**
+     * 该静态内部类用于管理笔记列表项的背景资源。
+     */
+    public static class NoteItemBgResources {
+        // 笔记列表项中第一项的背景资源数组
+        private final static int [] BG_FIRST_RESOURCES = new int [] {
+            R.drawable.list_yellow_up,
+            R.drawable.list_blue_up,
+            R.drawable.list_white_up,
+            R.drawable.list_green_up,
+            R.drawable.list_red_up
+        };
+
+        // 笔记列表项中普通项的背景资源数组
+        private final static int [] BG_NORMAL_RESOURCES = new int [] {
+            R.drawable.list_yellow_middle,
+            R.drawable.list_blue_middle,
+            R.drawable.list_white_middle,
+            R.drawable.list_green_middle,
+            R.drawable.list_red_middle
+        };
+
+        // 笔记列表项中最后一项的背景资源数组
+        private final static int [] BG_LAST_RESOURCES = new int [] {
+            R.drawable.list_yellow_down,
+            R.drawable.list_blue_down,
+            R.drawable.list_white_down,
+            R.drawable.list_green_down,
+            R.drawable.list_red_down,
+        };
+
+        // 笔记列表项中单独一项的背景资源数组
+        private final static int [] BG_SINGLE_RESOURCES = new int [] {
+            R.drawable.list_yellow_single,
+            R.drawable.list_blue_single,
+            R.drawable.list_white_single,
+            R.drawable.list_green_single,
+            R.drawable.list_red_single
+        };
+
+        /**
+         * 根据传入的颜色 ID 获取笔记列表项中第一项的背景资源 ID。
+         * @param id 颜色 ID，对应前面定义的颜色常量
+         * @return 笔记列表项中第一项的背景资源 ID
+         */
+        public static int getNoteBgFirstRes(int id) {
+            return BG_FIRST_RESOURCES[id];
+        }
+
+        /**
+         * 根据传入的颜色 ID 获取笔记列表项中最后一项的背景资源 ID。
+         * @param id 颜色 ID，对应前面定义的颜色常量
+         * @return 笔记列表项中最后一项的背景资源 ID
+         */
+        public static int getNoteBgLastRes(int id) {
+            return BG_LAST_RESOURCES[id];
+        }
+
+        /**
+         * 根据传入的颜色 ID 获取笔记列表项中单独一项的背景资源 ID。
+         * @param id 颜色 ID，对应前面定义的颜色常量
+         * @return 笔记列表项中单独一项的背景资源 ID
+         */
+        public static int getNoteBgSingleRes(int id) {
+            return BG_SINGLE_RESOURCES[id];
+        }
+
+        /**
+         * 根据传入的颜色 ID 获取笔记列表项中普通项的背景资源 ID。
+         * @param id 颜色 ID，对应前面定义的颜色常量
+         * @return 笔记列表项中普通项的背景资源 ID
+         */
+        public static int getNoteBgNormalRes(int id) {
+            return BG_NORMAL_RESOURCES[id];
+        }
+
+        /**
+         * 获取文件夹的背景资源 ID。
+         * @return 文件夹的背景资源 ID
+         */
+        public static int getFolderBgRes() {
+            return R.drawable.list_folder;
+        }
+    }
+
+    /**
+     * 该静态内部类用于管理小部件的背景资源。
+     */
+    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,
+        };
+
+        /**
+         * 根据传入的颜色 ID 获取 2x 大小小部件的背景资源 ID。
+         * @param id 颜色 ID，对应前面定义的颜色常量
+         * @return 2x 大小小部件的背景资源 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
+        };
+
+        /**
+         * 根据传入的颜色 ID 获取 4x 大小小部件的背景资源 ID。
+         * @param id 颜色 ID，对应前面定义的颜色常量
+         * @return 4x 大小小部件的背景资源 ID
+         */
+        public static int getWidget4xBgResource(int id) {
+            return BG_4X_RESOURCES[id];
+        }
+    }
+
+    /**
+     * 该静态内部类用于管理文本外观资源。
+     */
+    public static class TextAppearanceResources {
+        // 文本外观资源数组
+        private final static int [] TEXTAPPEARANCE_RESOURCES = new int [] {
+            R.style.TextAppearanceNormal,
+            R.style.TextAppearanceMedium,
+            R.style.TextAppearanceLarge,
+            R.style.TextAppearanceSuper
+        };
+
+        /**
+         * 根据传入的 ID 获取文本外观资源 ID。
+         * 如果传入的 ID 超出了资源数组的长度，返回默认的字体大小对应的资源 ID。
+         * @param id 文本外观 ID
+         * @return 文本外观资源 ID
+         */
+        public static int getTexAppearanceResource(int id) {
+            /**
+             * HACKME: Fix bug of store the resource id in shared preference.
+             * The id may larger than the length of resources, in this case,
+             * return the {@link ResourceParser#BG_DEFAULT_FONT_SIZE}
+             */
+            if (id >= TEXTAPPEARANCE_RESOURCES.length) {
+                return BG_DEFAULT_FONT_SIZE;
+            }
+            return TEXTAPPEARANCE_RESOURCES[id];
+        }
+
+        /**
+         * 获取文本外观资源数组的长度。
+         * @return 文本外观资源数组的长度
+         */
+        public static int getResourcesSize() {
+            return TEXTAPPEARANCE_RESOURCES.length;
+        }
+    }
+}

src/Model/Note.java

@@ -0,0 +1,390 @@
+/*
+ * 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.content.ContentProviderOperation;
+import android.content.ContentProviderResult;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.OperationApplicationException;
+import android.net.Uri;
+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.DataColumns;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.data.Notes.TextNote;
+
+import java.util.ArrayList;
+
+/**
+ * 该类表示一个笔记对象，用于管理笔记的各种属性和数据，
+ * 包括笔记的基本信息（如创建时间、修改时间等）以及笔记的文本数据和通话数据。
+ */
+public class Note {
+    // 用于存储笔记的差异值，即笔记有改动的属性值
+    private ContentValues mNoteDiffValues;
+    // 用于存储笔记的数据，包括文本数据和通话数据
+    private NoteData mNoteData;
+    // 日志标签，用于在日志中标识该类的信息
+    private static final String TAG = "Note";
+
+    /**
+     * 创建一个新的笔记 ID，用于向数据库中添加新笔记。
+     * 
+     * @param context 应用程序上下文，用于访问内容解析器
+     * @param folderId 笔记所属文件夹的 ID
+     * @return 新创建的笔记的 ID
+     */
+    public static synchronized long getNewNoteId(Context context, long folderId) {
+        // 创建一个新的 ContentValues 对象，用于存储要插入数据库的笔记信息
+        ContentValues values = new ContentValues();
+        // 获取当前时间作为笔记的创建时间
+        long createdTime = System.currentTimeMillis();
+        // 将创建时间添加到 ContentValues 中
+        values.put(NoteColumns.CREATED_DATE, createdTime);
+        // 将修改时间设置为创建时间，因为是新创建的笔记
+        values.put(NoteColumns.MODIFIED_DATE, createdTime);
+        // 设置笔记的类型为普通笔记
+        values.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
+        // 标记笔记为本地已修改
+        values.put(NoteColumns.LOCAL_MODIFIED, 1);
+        // 设置笔记所属文件夹的 ID
+        values.put(NoteColumns.PARENT_ID, folderId);
+        // 使用内容解析器插入新笔记，并获取插入后的 URI
+        Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values);
+
+        long noteId = 0;
+        try {
+            // 从 URI 中提取笔记的 ID
+            noteId = Long.valueOf(uri.getPathSegments().get(1));
+        } catch (NumberFormatException e) {
+            // 若提取 ID 时出现异常，记录错误日志
+            Log.e(TAG, "Get note id error :" + e.toString());
+            noteId = 0;
+        }
+        if (noteId == -1) {
+            // 若笔记 ID 为 -1，抛出异常表示笔记 ID 错误
+            throw new IllegalStateException("Wrong note id:" + noteId);
+        }
+        return noteId;
+    }
+
+    /**
+     * 构造函数，初始化笔记的差异值和笔记数据对象。
+     */
+    public Note() {
+        mNoteDiffValues = new ContentValues();
+        mNoteData = new NoteData();
+    }
+
+    /**
+     * 设置笔记的属性值，并标记笔记为本地已修改，同时更新修改时间。
+     * 
+     * @param key 属性名
+     * @param value 属性值
+     */
+    public void setNoteValue(String key, String value) {
+        mNoteDiffValues.put(key, value);
+        mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+        mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+    }
+
+    /**
+     * 设置笔记的文本数据的属性值。
+     * 
+     * @param key 属性名
+     * @param value 属性值
+     */
+    public void setTextData(String key, String value) {
+        mNoteData.setTextData(key, value);
+    }
+
+    /**
+     * 设置笔记的文本数据的 ID。
+     * 
+     * @param id 文本数据的 ID
+     */
+    public void setTextDataId(long id) {
+        mNoteData.setTextDataId(id);
+    }
+
+    /**
+     * 获取笔记的文本数据的 ID。
+     * 
+     * @return 文本数据的 ID
+     */
+    public long getTextDataId() {
+        return mNoteData.mTextDataId;
+    }
+
+    /**
+     * 设置笔记的通话数据的 ID。
+     * 
+     * @param id 通话数据的 ID
+     */
+    public void setCallDataId(long id) {
+        mNoteData.setCallDataId(id);
+    }
+
+    /**
+     * 设置笔记的通话数据的属性值。
+     * 
+     * @param key 属性名
+     * @param value 属性值
+     */
+    public void setCallData(String key, String value) {
+        mNoteData.setCallData(key, value);
+    }
+
+    /**
+     * 判断笔记是否被本地修改过。
+     * 
+     * @return 若笔记被本地修改过返回 true，否则返回 false
+     */
+    public boolean isLocalModified() {
+        return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
+    }
+
+    /**
+     * 将笔记的修改同步到数据库中。
+     * 
+     * @param context 应用程序上下文，用于访问内容解析器
+     * @param noteId 笔记的 ID
+     * @return 若同步成功返回 true，否则返回 false
+     */
+    public boolean syncNote(Context context, long noteId) {
+        if (noteId <= 0) {
+            // 若笔记 ID 不合法，抛出异常
+            throw new IllegalArgumentException("Wrong note id:" + noteId);
+        }
+
+        if (!isLocalModified()) {
+            // 若笔记未被修改，直接返回 true
+            return true;
+        }
+
+        /**
+         * 理论上，一旦数据发生变化，笔记的 LOCAL_MODIFIED 和 MODIFIED_DATE 应该被更新。
+         * 为了数据安全，即使更新笔记失败，我们也会更新笔记的数据信息。
+         */
+        if (context.getContentResolver().update(
+                ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), mNoteDiffValues, null,
+                null) == 0) {
+            // 若更新笔记失败，记录错误日志
+            Log.e(TAG, "Update note error, should not happen");
+            // 不返回，继续执行后续操作
+        }
+        // 清空笔记的差异值
+        mNoteDiffValues.clear();
+
+        if (mNoteData.isLocalModified()
+                && (mNoteData.pushIntoContentResolver(context, noteId) == null)) {
+            // 若笔记数据被修改且同步失败，返回 false
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * 内部类，用于管理笔记的数据，包括文本数据和通话数据。
+     */
+    private class NoteData {
+        // 文本数据的 ID
+        private long mTextDataId;
+        // 存储文本数据的 ContentValues 对象
+        private ContentValues mTextDataValues;
+        // 通话数据的 ID
+        private long mCallDataId;
+        // 存储通话数据的 ContentValues 对象
+        private ContentValues mCallDataValues;
+        // 日志标签，用于在日志中标识该内部类的信息
+        private static final String TAG = "NoteData";
+
+        /**
+         * 构造函数，初始化文本数据和通话数据的 ContentValues 对象，以及 ID 为 0。
+         */
+        public NoteData() {
+            mTextDataValues = new ContentValues();
+            mCallDataValues = new ContentValues();
+            mTextDataId = 0;
+            mCallDataId = 0;
+        }
+
+        /**
+         * 判断笔记数据是否被本地修改过。
+         * 
+         * @return 若笔记数据被本地修改过返回 true，否则返回 false
+         */
+        boolean isLocalModified() {
+            return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
+        }
+
+        /**
+         * 设置笔记的文本数据的 ID。
+         * 
+         * @param id 文本数据的 ID
+         */
+        void setTextDataId(long id) {
+            if(id <= 0) {
+                // 若文本数据 ID 不合法，抛出异常
+                throw new IllegalArgumentException("Text data id should larger than 0");
+            }
+            mTextDataId = id;
+        }
+
+        /**
+         * 设置笔记的通话数据的 ID。
+         * 
+         * @param id 通话数据的 ID
+         */
+        void setCallDataId(long id) {
+            if (id <= 0) {
+                // 若通话数据 ID 不合法，抛出异常
+                throw new IllegalArgumentException("Call data id should larger than 0");
+            }
+            mCallDataId = id;
+        }
+
+        /**
+         * 设置笔记的通话数据的属性值，并标记笔记为本地已修改，同时更新修改时间。
+         * 
+         * @param key 属性名
+         * @param value 属性值
+         */
+        void setCallData(String key, String value) {
+            mCallDataValues.put(key, value);
+            mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+            mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+        }
+
+        /**
+         * 设置笔记的文本数据的属性值，并标记笔记为本地已修改，同时更新修改时间。
+         * 
+         * @param key 属性名
+         * @param value 属性值
+         */
+        void setTextData(String key, String value) {
+            mTextDataValues.put(key, value);
+            mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+            mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+        }
+
+        /**
+         * 将笔记的数据（文本数据和通话数据）推送到内容解析器中进行同步。
+         * 
+         * @param context 应用程序上下文，用于访问内容解析器
+         * @param noteId 笔记的 ID
+         * @return 若同步成功返回笔记的 URI，否则返回 null
+         */
+        Uri pushIntoContentResolver(Context context, long noteId) {
+            /**
+             * 进行安全检查，确保笔记 ID 合法。
+             */
+            if (noteId <= 0) {
+                // 若笔记 ID 不合法，抛出异常
+                throw new IllegalArgumentException("Wrong note id:" + noteId);
+            }
+
+            // 创建一个 ContentProviderOperation 列表，用于批量操作
+            ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
+            // ContentProviderOperation 构建器
+            ContentProviderOperation.Builder builder = null;
+
+            if(mTextDataValues.size() > 0) {
+                // 若文本数据有修改
+                mTextDataValues.put(DataColumns.NOTE_ID, noteId);
+                if (mTextDataId == 0) {
+                    // 若文本数据 ID 为 0，说明是新的文本数据
+                    mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE);
+                    // 插入新的文本数据
+                    Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
+                            mTextDataValues);
+                    try {
+                        // 获取插入后的文本数据 ID
+                        setTextDataId(Long.valueOf(uri.getPathSegments().get(1)));
+                    } catch (NumberFormatException e) {
+                        // 若获取 ID 失败，记录错误日志并清空文本数据
+                        Log.e(TAG, "Insert new text data fail with noteId" + noteId);
+                        mTextDataValues.clear();
+                        return null;
+                    }
+                } else {
+                    // 若文本数据 ID 不为 0，说明是更新已有的文本数据
+                    builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
+                            Notes.CONTENT_DATA_URI, mTextDataId));
+                    builder.withValues(mTextDataValues);
+                    operationList.add(builder.build());
+                }
+                // 清空文本数据的 ContentValues 对象
+                mTextDataValues.clear();
+            }
+
+            if(mCallDataValues.size() > 0) {
+                // 若通话数据有修改
+                mCallDataValues.put(DataColumns.NOTE_ID, noteId);
+                if (mCallDataId == 0) {
+                    // 若通话数据 ID 为 0，说明是新的通话数据
+                    mCallDataValues.put(DataColumns.MIME_TYPE, CallNote.CONTENT_ITEM_TYPE);
+                    // 插入新的通话数据
+                    Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
+                            mCallDataValues);
+                    try {
+                        // 获取插入后的通话数据 ID
+                        setCallDataId(Long.valueOf(uri.getPathSegments().get(1)));
+                    } catch (NumberFormatException e) {
+                        // 若获取 ID 失败，记录错误日志并清空通话数据
+                        Log.e(TAG, "Insert new call data fail with noteId" + noteId);
+                        mCallDataValues.clear();
+                        return null;
+                    }
+                } else {
+                    // 若通话数据 ID 不为 0，说明是更新已有的通话数据
+                    builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
+                            Notes.CONTENT_DATA_URI, mCallDataId));
+                    builder.withValues(mCallDataValues);
+                    operationList.add(builder.build());
+                }
+                // 清空通话数据的 ContentValues 对象
+                mCallDataValues.clear();
+            }
+
+            if (operationList.size() > 0) {
+                try {
+                    // 批量执行 ContentProviderOperation 列表中的操作
+                    ContentProviderResult[] results = context.getContentResolver().applyBatch(
+                            Notes.AUTHORITY, operationList);
+                    return (results == null || results.length == 0 || results[0] == null) ? null
+                            : ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId);
+                } catch (RemoteException e) {
+                    // 若执行批量操作时出现远程异常，记录错误日志
+                    Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+                    return null;
+                } catch (OperationApplicationException e) {
+                    // 若执行批量操作时出现操作应用异常，记录错误日志
+                    Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+                    return null;
+                }
+            }
+            return null;
+        }
+    }
+}

src/Model/WorkingNote.java

@@ -0,0 +1,523 @@
+/*
+ * 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
+    };
+
+    // 数据 ID 列的索引
+    private static final int DATA_ID_COLUMN = 0;
+    // 数据内容列的索引
+    private static final int DATA_CONTENT_COLUMN = 1;
+    // 数据 MIME 类型列的索引
+    private static final int DATA_MIME_TYPE_COLUMN = 2;
+    // 数据模式列的索引
+    private static final int DATA_MODE_COLUMN = 3;
+    // 便签父文件夹 ID 列的索引
+    private static final int NOTE_PARENT_ID_COLUMN = 0;
+    // 便签提醒日期列的索引
+    private static final int NOTE_ALERTED_DATE_COLUMN = 1;
+    // 便签背景颜色 ID 列的索引
+    private static final int NOTE_BG_COLOR_ID_COLUMN = 2;
+    // 便签小部件 ID 列的索引
+    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;
+
+    /**
+     * 新建便签的构造函数。
+     *
+     * @param context  上下文对象
+     * @param folderId 便签所在文件夹的 ID
+     */
+    private WorkingNote(Context context, long folderId) {
+        mContext = context;
+        // 初始化提醒日期为 0，表示没有提醒
+        mAlertDate = 0;
+        // 初始化修改日期为当前时间
+        mModifiedDate = System.currentTimeMillis();
+        mFolderId = folderId;
+        mNote = new Note();
+        // 初始化便签 ID 为 0，表示新便签还未分配 ID
+        mNoteId = 0;
+        // 标记便签未被删除
+        mIsDeleted = false;
+        // 初始化便签模式为 0
+        mMode = 0;
+        // 初始化小部件类型为无效类型
+        mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
+    }
+
+    /**
+     * 加载现有便签的构造函数。
+     *
+     * @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();
+    }
+
+    /**
+     * 加载便签的基本信息，包括父文件夹 ID、背景颜色 ID、小部件 ID 等。
+     */
+    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()) {
+                // 获取便签所在文件夹的 ID
+                mFolderId = cursor.getLong(NOTE_PARENT_ID_COLUMN);
+                // 获取便签的背景颜色 ID
+                mBgColorId = cursor.getInt(NOTE_BG_COLOR_ID_COLUMN);
+                // 获取便签小部件的 ID
+                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);
+            // 抛出异常，表示找不到指定 ID 的便签
+            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 {
+                    // 获取数据的 MIME 类型
+                    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);
+                        // 设置便签的文本数据 ID
+                        mNote.setTextDataId(cursor.getLong(DATA_ID_COLUMN));
+                    } else if (DataConstants.CALL_NOTE.equals(type)) {
+                        // 如果是通话便签类型，设置通话数据 ID
+                        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);
+            // 抛出异常，表示找不到指定 ID 的便签数据
+            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);
+        // 设置便签的背景颜色 ID
+        note.setBgColorId(defaultBgColorId);
+        // 设置便签小部件的 ID
+        note.setWidgetId(widgetId);
+        // 设置便签小部件的类型
+        note.setWidgetType(widgetType);
+        return note;
+    }
+
+    /**
+     * 加载指定 ID 的便签。
+     *
+     * @param context 上下文对象
+     * @param id      便签的 ID
+     * @return 加载的便签对象
+     */
+    public static WorkingNote load(Context context, long id) {
+        return new WorkingNote(context, id, 0);
+    }
+
+    /**
+     * 保存便签。
+     *
+     * @return 如果保存成功返回 true，否则返回 false
+     */
+    public synchronized boolean saveNote() {
+        if (isWorthSaving()) {
+            if (!existInDatabase()) {
+                // 如果便签不在数据库中，创建一个新的便签 ID
+                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，否则返回 false
+     */
+    public boolean existInDatabase() {
+        return mNoteId > 0;
+    }
+
+    /**
+     * 判断便签是否值得保存。
+     *
+     * @return 如果值得保存返回 true，否则返回 false
+     */
+    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 如果为 true 表示标记为已删除，否则为未删除
+     */
+    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();
+            }
+            // 设置便签的背景颜色 ID
+            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;
+            // 设置便签的小部件 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);
+        // 设置便签的父文件夹 ID 为通话记录文件夹的 ID
+        mNote.setNoteValue(NoteColumns.PARENT_ID, String.valueOf(Notes.ID_CALL_RECORD_FOLDER));
+    }
+
+    /**
+     * 判断便签是否设置了提醒。
+     *
+     * @return 如果设置了提醒返回 true，否则返回 false
+     */
+    public boolean hasClockAlert() {
+        return (mAlertDate > 0 ? true : false);
+    }
+
+    public String getContent() {
+        return mContent;
+    }
+
+    public long getAlertDate() {
+        return mAlertDate;
+    }
+
+    public long getModifiedDate() {
+        return mModifiedDate;
+    }
+
+    public int getBgColorResId() {
+        return NoteBgResources.getNoteBgResource(mBgColorId);
+    }
+
+    public int getBgColorId() {
+        return mBgColorId;
+    }
+
+    public int getTitleBgResId() {
+        return NoteBgResources.getNoteTitleBgResource(mBgColorId);
+    }
+
+    public int getCheckListMode() {
+        return mMode;
+    }
+
+    public long getNoteId() {
+        return mNoteId;
+    }
+
+    public long getFolderId() {
+        return mFolderId;
+    }
+
+    public int getWidgetId() {
+        return mWidgetId;
+    }
+
+    public int getWidgetType() {
+        return mWidgetType;
+    }
+
+    public interface NoteSettingChangedListener {
+        /**
+         * Called when the background color of current note has just changed
+         */
+        void onBackgroundColorChanged();
+
+        /**
+         * Called when user set clock
+         */
+        void onClockAlertChanged(long date, boolean set);
+
+        /**
+         * Call when user create note from widget
+         */
+        void onWidgetChanged();
+
+        /**
+         * Call when switch between check list mode and normal mode
+         * @param oldMode is previous mode before change
+         * @param newMode is new mode
+         */
+        void onCheckListModeChanged(int oldMode, int newMode);
+    }
+}

src/Widget/NoteWidgetProvider.java

@@ -0,0 +1,226 @@
+/*
+ * 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;
+
+/**
+ * 抽象类 NoteWidgetProvider，继承自 AppWidgetProvider，用于处理笔记小部件的相关操作。
+ * 提供了小部件删除、更新等功能，并且定义了一些抽象方法供子类实现特定的资源获取。
+ */
+public abstract class NoteWidgetProvider extends AppWidgetProvider {
+    // 查询笔记信息时使用的投影，指定要查询的列
+    public static final String [] PROJECTION = new String [] {
+        NoteColumns.ID,
+        NoteColumns.BG_COLOR_ID,
+        NoteColumns.SNIPPET
+    };
+
+    // 笔记 ID 在投影数组中的索引
+    public static final int COLUMN_ID           = 0;
+    // 笔记背景颜色 ID 在投影数组中的索引
+    public static final int COLUMN_BG_COLOR_ID  = 1;
+    // 笔记摘要在投影数组中的索引
+    public static final int COLUMN_SNIPPET      = 2;
+
+    // 日志标签，用于在日志中标识该类的相关信息
+    private static final String TAG = "NoteWidgetProvider";
+
+    /**
+     * 当小部件被删除时调用此方法。
+     * 该方法会将对应笔记的小部件 ID 设置为无效值。
+     *
+     * @param context 上下文对象
+     * @param appWidgetIds 被删除的小部件 ID 数组
+     */
+    @Override
+    public void onDeleted(Context context, int[] appWidgetIds) {
+        // 创建 ContentValues 对象，用于存储要更新的字段和值
+        ContentValues values = new ContentValues();
+        // 将笔记的小部件 ID 设置为无效值
+        values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
+        // 遍历被删除的小部件 ID 数组
+        for (int i = 0; i < appWidgetIds.length; i++) {
+            // 更新笔记数据库中对应小部件 ID 的笔记记录
+            context.getContentResolver().update(Notes.CONTENT_NOTE_URI,
+                    values,
+                    NoteColumns.WIDGET_ID + "=?",
+                    new String[] { String.valueOf(appWidgetIds[i])});
+        }
+    }
+
+    /**
+     * 根据小部件 ID 获取笔记小部件的信息。
+     *
+     * @param context 上下文对象
+     * @param widgetId 小部件 ID
+     * @return 包含笔记信息的游标，如果查询失败则返回 null
+     */
+    private Cursor getNoteWidgetInfo(Context context, int widgetId) {
+        // 查询笔记数据库，获取指定小部件 ID 且不在回收站的笔记信息
+        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);
+    }
+
+    /**
+     * 更新小部件的方法，默认不开启隐私模式。
+     *
+     * @param context 上下文对象
+     * @param appWidgetManager 小部件管理器
+     * @param appWidgetIds 要更新的小部件 ID 数组
+     */
+    protected void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
+        // 调用带隐私模式参数的更新方法，隐私模式为 false
+        update(context, appWidgetManager, appWidgetIds, false);
+    }
+
+    /**
+     * 更新小部件的具体实现方法。
+     * 根据小部件 ID 获取笔记信息，设置小部件的背景、文本和点击事件等。
+     *
+     * @param context 上下文对象
+     * @param appWidgetManager 小部件管理器
+     * @param appWidgetIds 要更新的小部件 ID 数组
+     * @param privacyMode 是否开启隐私模式
+     */
+    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 = new Intent(context, NoteEditActivity.class);
+                // 设置意图标志，确保活动以单顶模式启动
+                intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
+                // 将小部件 ID 作为额外数据添加到意图中
+                intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]);
+                // 将小部件类型作为额外数据添加到意图中
+                intent.putExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, getWidgetType());
+
+                // 获取指定小部件 ID 的笔记信息游标
+                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;
+                    }
+                    // 从游标中获取笔记摘要
+                    snippet = c.getString(COLUMN_SNIPPET);
+                    // 从游标中获取笔记背景颜色 ID
+                    bgId = c.getInt(COLUMN_BG_COLOR_ID);
+                    // 将笔记 ID 作为额外数据添加到意图中
+                    intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID));
+                    // 设置意图的动作类型为查看
+                    intent.setAction(Intent.ACTION_VIEW);
+                } else {
+                    // 如果没有找到笔记信息，设置默认的提示信息
+                    snippet = context.getResources().getString(R.string.widget_havenot_content);
+                    // 设置意图的动作类型为插入或编辑
+                    intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
+                }
+
+                // 关闭游标
+                if (c != null) {
+                    c.close();
+                }
+
+                // 创建 RemoteViews 对象，用于设置小部件的布局
+                RemoteViews rv = new RemoteViews(context.getPackageName(), getLayoutId());
+                // 设置小部件的背景图片资源
+                rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId));
+                // 将背景颜色 ID 作为额外数据添加到意图中
+                intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId);
+
+                /**
+                 * 生成用于启动小部件宿主的待定意图
+                 */
+                PendingIntent pendingIntent = null;
+                if (privacyMode) {
+                    // 如果开启隐私模式，设置小部件文本为隐私模式提示信息
+                    rv.setTextViewText(R.id.widget_text,
+                            context.getString(R.string.widget_under_visit_mode));
+                    // 创建启动笔记列表活动的待定意图
+                    pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], new Intent(
+                            context, NotesListActivity.class), PendingIntent.FLAG_UPDATE_CURRENT);
+                } else {
+                    // 如果未开启隐私模式，设置小部件文本为笔记摘要
+                    rv.setTextViewText(R.id.widget_text, snippet);
+                    // 创建启动笔记编辑活动的待定意图
+                    pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], intent,
+                            PendingIntent.FLAG_UPDATE_CURRENT);
+                }
+
+                // 设置小部件文本的点击事件为待定意图
+                rv.setOnClickPendingIntent(R.id.widget_text, pendingIntent);
+                // 更新指定小部件 ID 的小部件布局
+                appWidgetManager.updateAppWidget(appWidgetIds[i], rv);
+            }
+        }
+    }
+
+    /**
+     * 抽象方法，用于获取指定背景颜色 ID 对应的背景资源 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/Widget/NoteWidgetProvider_2x.java

@@ -0,0 +1,77 @@
+/*
+ * 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;
+
+/**
+ * NoteWidgetProvider_2x 类继承自 NoteWidgetProvider，用于处理 2x 尺寸的笔记小部件。
+ * 它重写了父类的一些抽象方法，以提供适合 2x 小部件的布局、背景资源和小部件类型。
+ */
+public class NoteWidgetProvider_2x extends NoteWidgetProvider {
+
+    /**
+     * 当小部件需要更新时调用此方法。
+     * 调用父类的 update 方法来完成小部件的更新操作。
+     *
+     * @param context 上下文对象，用于获取资源和执行相关操作
+     * @param appWidgetManager 小部件管理器，用于管理和更新小部件
+     * @param appWidgetIds 要更新的小部件的 ID 数组
+     */
+    @Override
+    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
+        // 调用父类的 update 方法进行小部件更新
+        super.update(context, appWidgetManager, appWidgetIds);
+    }
+
+    /**
+     * 获取 2x 小部件的布局资源 ID。
+     *
+     * @return 2x 小部件的布局资源 ID，即 R.layout.widget_2x
+     */
+    @Override
+    protected int getLayoutId() {
+        return R.layout.widget_2x;
+    }
+
+    /**
+     * 根据背景颜色 ID 获取 2x 小部件的背景资源 ID。
+     * 调用 ResourceParser 类中的 WidgetBgResources 内部类的方法来获取相应的背景资源。
+     *
+     * @param bgId 背景颜色 ID，用于指定要获取的背景颜色
+     * @return 2x 小部件的背景资源 ID
+     */
+    @Override
+    protected int getBgResourceId(int bgId) {
+        return ResourceParser.WidgetBgResources.getWidget2xBgResource(bgId);
+    }
+
+    /**
+     * 获取 2x 小部件的类型。
+     *
+     * @return 2x 小部件的类型，即 Notes.TYPE_WIDGET_2X
+     */
+    @Override
+    protected int getWidgetType() {
+        return Notes.TYPE_WIDGET_2X;
+    }
+}

src/Widget/NoteWidgetProvider_4x.java

@@ -0,0 +1,76 @@
+/*
+ * 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;
+
+/**
+ * NoteWidgetProvider_4x 类继承自 NoteWidgetProvider，用于处理 4x 尺寸的笔记小部件。
+ * 它重写了父类的一些方法，以提供适合 4x 小部件的布局、背景资源和小部件类型等信息。
+ */
+public class NoteWidgetProvider_4x extends NoteWidgetProvider {
+
+    /**
+     * 当小部件需要更新时调用此方法。
+     * 调用父类的 update 方法来完成小部件的更新操作。
+     * 
+     * @param context 上下文对象，用于获取系统服务和资源等
+     * @param appWidgetManager 小部件管理器，用于管理和更新小部件
+     * @param appWidgetIds 要更新的小部件的 ID 数组
+     */
+    @Override
+    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
+        // 调用父类的 update 方法进行小部件更新
+        super.update(context, appWidgetManager, appWidgetIds);
+    }
+
+    /**
+     * 获取 4x 小部件的布局资源 ID。
+     * 
+     * @return 4x 小部件的布局资源 ID，即 R.layout.widget_4x
+     */
+    protected int getLayoutId() {
+        return R.layout.widget_4x;
+    }
+
+    /**
+     * 根据背景颜色 ID 获取 4x 小部件的背景资源 ID。
+     * 借助 ResourceParser 类中的 WidgetBgResources 内部类来获取对应背景资源。
+     * 
+     * @param bgId 背景颜色 ID，代表不同的背景颜色
+     * @return 4x 小部件对应背景颜色的背景资源 ID
+     */
+    @Override
+    protected int getBgResourceId(int bgId) {
+        return ResourceParser.WidgetBgResources.getWidget4xBgResource(bgId);
+    }
+
+    /**
+     * 获取 4x 小部件的类型。
+     * 
+     * @return 4x 小部件的类型，即 Notes.TYPE_WIDGET_4X
+     */
+    @Override
+    protected int getWidgetType() {
+        return Notes.TYPE_WIDGET_4X;
+    }
+}

src/Widgit

@@ -0,0 +1 @@
+undefined

src/tool/BackupUtils.java

@@ -0,0 +1,344 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.tool;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.os.Environment;
+import android.text.TextUtils;
+import android.text.format.DateFormat;
+import android.util.Log;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.DataConstants;
+import net.micode.notes.data.Notes.NoteColumns;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.PrintStream;
+
+
+public class BackupUtils {
+    private static final String TAG = "BackupUtils";
+    // Singleton stuff
+    private static BackupUtils sInstance;
+
+    public static synchronized BackupUtils getInstance(Context context) {
+        if (sInstance == null) {
+            sInstance = new BackupUtils(context);
+        }
+        return sInstance;
+    }
+
+    /**
+     * Following states are signs to represents backup or restore
+     * status
+     */
+    // Currently, the sdcard is not mounted
+    public static final int STATE_SD_CARD_UNMOUONTED           = 0;
+    // The backup file not exist
+    public static final int STATE_BACKUP_FILE_NOT_EXIST        = 1;
+    // The data is not well formated, may be changed by other programs
+    public static final int STATE_DATA_DESTROIED               = 2;
+    // Some run-time exception which causes restore or backup fails
+    public static final int STATE_SYSTEM_ERROR                 = 3;
+    // Backup or restore success
+    public static final int STATE_SUCCESS                      = 4;
+
+    private TextExport mTextExport;
+
+    private BackupUtils(Context context) {
+        mTextExport = new TextExport(context);
+    }
+
+    private static boolean externalStorageAvailable() {
+        return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
+    }
+
+    public int exportToText() {
+        return mTextExport.exportToText();
+    }
+
+    public String getExportedTextFileName() {
+        return mTextExport.mFileName;
+    }
+
+    public String getExportedTextFileDir() {
+        return mTextExport.mFileDirectory;
+    }
+
+    private static class TextExport {
+        private static final String[] NOTE_PROJECTION = {
+                NoteColumns.ID,
+                NoteColumns.MODIFIED_DATE,
+                NoteColumns.SNIPPET,
+                NoteColumns.TYPE
+        };
+
+        private static final int NOTE_COLUMN_ID = 0;
+
+        private static final int NOTE_COLUMN_MODIFIED_DATE = 1;
+
+        private static final int NOTE_COLUMN_SNIPPET = 2;
+
+        private static final String[] DATA_PROJECTION = {
+                DataColumns.CONTENT,
+                DataColumns.MIME_TYPE,
+                DataColumns.DATA1,
+                DataColumns.DATA2,
+                DataColumns.DATA3,
+                DataColumns.DATA4,
+        };
+
+        private static final int DATA_COLUMN_CONTENT = 0;
+
+        private static final int DATA_COLUMN_MIME_TYPE = 1;
+
+        private static final int DATA_COLUMN_CALL_DATE = 2;
+
+        private static final int DATA_COLUMN_PHONE_NUMBER = 4;
+
+        private final String [] TEXT_FORMAT;
+        private static final int FORMAT_FOLDER_NAME          = 0;
+        private static final int FORMAT_NOTE_DATE            = 1;
+        private static final int FORMAT_NOTE_CONTENT         = 2;
+
+        private Context mContext;
+        private String mFileName;
+        private String mFileDirectory;
+
+        public TextExport(Context context) {
+            TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note);
+            mContext = context;
+            mFileName = "";
+            mFileDirectory = "";
+        }
+
+        private String getFormat(int id) {
+            return TEXT_FORMAT[id];
+        }
+
+        /**
+         * Export the folder identified by folder id to text
+         */
+        private void exportFolderToText(String folderId, PrintStream ps) {
+            // Query notes belong to this folder
+            Cursor notesCursor = mContext.getContentResolver().query(Notes.CONTENT_NOTE_URI,
+                    NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[] {
+                        folderId
+                    }, null);
+
+            if (notesCursor != null) {
+                if (notesCursor.moveToFirst()) {
+                    do {
+                        // Print note's last modified date
+                        ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
+                                mContext.getString(R.string.format_datetime_mdhm),
+                                notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
+                        // Query data belong to this note
+                        String noteId = notesCursor.getString(NOTE_COLUMN_ID);
+                        exportNoteToText(noteId, ps);
+                    } while (notesCursor.moveToNext());
+                }
+                notesCursor.close();
+            }
+        }
+
+        /**
+         * Export note identified by id to a print stream
+         */
+        private void exportNoteToText(String noteId, PrintStream ps) {
+            Cursor dataCursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI,
+                    DATA_PROJECTION, DataColumns.NOTE_ID + "=?", new String[] {
+                        noteId
+                    }, null);
+
+            if (dataCursor != null) {
+                if (dataCursor.moveToFirst()) {
+                    do {
+                        String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE);
+                        if (DataConstants.CALL_NOTE.equals(mimeType)) {
+                            // Print phone number
+                            String phoneNumber = dataCursor.getString(DATA_COLUMN_PHONE_NUMBER);
+                            long callDate = dataCursor.getLong(DATA_COLUMN_CALL_DATE);
+                            String location = dataCursor.getString(DATA_COLUMN_CONTENT);
+
+                            if (!TextUtils.isEmpty(phoneNumber)) {
+                                ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
+                                        phoneNumber));
+                            }
+                            // Print call date
+                            ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), DateFormat
+                                    .format(mContext.getString(R.string.format_datetime_mdhm),
+                                            callDate)));
+                            // Print call attachment location
+                            if (!TextUtils.isEmpty(location)) {
+                                ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
+                                        location));
+                            }
+                        } else if (DataConstants.NOTE.equals(mimeType)) {
+                            String content = dataCursor.getString(DATA_COLUMN_CONTENT);
+                            if (!TextUtils.isEmpty(content)) {
+                                ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
+                                        content));
+                            }
+                        }
+                    } while (dataCursor.moveToNext());
+                }
+                dataCursor.close();
+            }
+            // print a line separator between note
+            try {
+                ps.write(new byte[] {
+                        Character.LINE_SEPARATOR, Character.LETTER_NUMBER
+                });
+            } catch (IOException e) {
+                Log.e(TAG, e.toString());
+            }
+        }
+
+        /**
+         * Note will be exported as text which is user readable
+         */
+        public int exportToText() {
+            if (!externalStorageAvailable()) {
+                Log.d(TAG, "Media was not mounted");
+                return STATE_SD_CARD_UNMOUONTED;
+            }
+
+            PrintStream ps = getExportToTextPrintStream();
+            if (ps == null) {
+                Log.e(TAG, "get print stream error");
+                return STATE_SYSTEM_ERROR;
+            }
+            // First export folder and its notes
+            Cursor folderCursor = mContext.getContentResolver().query(
+                    Notes.CONTENT_NOTE_URI,
+                    NOTE_PROJECTION,
+                    "(" + NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND "
+                            + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + ") OR "
+                            + NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER, null, null);
+
+            if (folderCursor != null) {
+                if (folderCursor.moveToFirst()) {
+                    do {
+                        // Print folder's name
+                        String folderName = "";
+                        if(folderCursor.getLong(NOTE_COLUMN_ID) == Notes.ID_CALL_RECORD_FOLDER) {
+                            folderName = mContext.getString(R.string.call_record_folder_name);
+                        } else {
+                            folderName = folderCursor.getString(NOTE_COLUMN_SNIPPET);
+                        }
+                        if (!TextUtils.isEmpty(folderName)) {
+                            ps.println(String.format(getFormat(FORMAT_FOLDER_NAME), folderName));
+                        }
+                        String folderId = folderCursor.getString(NOTE_COLUMN_ID);
+                        exportFolderToText(folderId, ps);
+                    } while (folderCursor.moveToNext());
+                }
+                folderCursor.close();
+            }
+
+            // Export notes in root's folder
+            Cursor noteCursor = mContext.getContentResolver().query(
+                    Notes.CONTENT_NOTE_URI,
+                    NOTE_PROJECTION,
+                    NoteColumns.TYPE + "=" + +Notes.TYPE_NOTE + " AND " + NoteColumns.PARENT_ID
+                            + "=0", null, null);
+
+            if (noteCursor != null) {
+                if (noteCursor.moveToFirst()) {
+                    do {
+                        ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
+                                mContext.getString(R.string.format_datetime_mdhm),
+                                noteCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
+                        // Query data belong to this note
+                        String noteId = noteCursor.getString(NOTE_COLUMN_ID);
+                        exportNoteToText(noteId, ps);
+                    } while (noteCursor.moveToNext());
+                }
+                noteCursor.close();
+            }
+            ps.close();
+
+            return STATE_SUCCESS;
+        }
+
+        /**
+         * Get a print stream pointed to the file {@generateExportedTextFile}
+         */
+        private PrintStream getExportToTextPrintStream() {
+            File file = generateFileMountedOnSDcard(mContext, R.string.file_path,
+                    R.string.file_name_txt_format);
+            if (file == null) {
+                Log.e(TAG, "create file to exported failed");
+                return null;
+            }
+            mFileName = file.getName();
+            mFileDirectory = mContext.getString(R.string.file_path);
+            PrintStream ps = null;
+            try {
+                FileOutputStream fos = new FileOutputStream(file);
+                ps = new PrintStream(fos);
+            } catch (FileNotFoundException e) {
+                e.printStackTrace();
+                return null;
+            } catch (NullPointerException e) {
+                e.printStackTrace();
+                return null;
+            }
+            return ps;
+        }
+    }
+
+    /**
+     * Generate the text file to store imported data
+     */
+    private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
+        StringBuilder sb = new StringBuilder();
+        sb.append(Environment.getExternalStorageDirectory());
+        sb.append(context.getString(filePathResId));
+        File filedir = new File(sb.toString());
+        sb.append(context.getString(
+                fileNameFormatResId,
+                DateFormat.format(context.getString(R.string.format_date_ymd),
+                        System.currentTimeMillis())));
+        File file = new File(sb.toString());
+
+        try {
+            if (!filedir.exists()) {
+                filedir.mkdir();
+            }
+            if (!file.exists()) {
+                file.createNewFile();
+            }
+            return file;
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+}
+
+

src/tool/GTaskStringUtils.java

@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.tool;
+
+public class GTaskStringUtils {
+
+    public final static String GTASK_JSON_ACTION_ID = "action_id";
+
+    public final static String GTASK_JSON_ACTION_LIST = "action_list";
+
+    public final static String GTASK_JSON_ACTION_TYPE = "action_type";
+
+    public final static String GTASK_JSON_ACTION_TYPE_CREATE = "create";
+
+    public final static String GTASK_JSON_ACTION_TYPE_GETALL = "get_all";
+
+    public final static String GTASK_JSON_ACTION_TYPE_MOVE = "move";
+
+    public final static String GTASK_JSON_ACTION_TYPE_UPDATE = "update";
+
+    public final static String GTASK_JSON_CREATOR_ID = "creator_id";
+
+    public final static String GTASK_JSON_CHILD_ENTITY = "child_entity";
+
+    public final static String GTASK_JSON_CLIENT_VERSION = "client_version";
+
+    public final static String GTASK_JSON_COMPLETED = "completed";
+
+    public final static String GTASK_JSON_CURRENT_LIST_ID = "current_list_id";
+
+    public final static String GTASK_JSON_DEFAULT_LIST_ID = "default_list_id";
+
+    public final static String GTASK_JSON_DELETED = "deleted";
+
+    public final static String GTASK_JSON_DEST_LIST = "dest_list";
+
+    public final static String GTASK_JSON_DEST_PARENT = "dest_parent";
+
+    public final static String GTASK_JSON_DEST_PARENT_TYPE = "dest_parent_type";
+
+    public final static String GTASK_JSON_ENTITY_DELTA = "entity_delta";
+
+    public final static String GTASK_JSON_ENTITY_TYPE = "entity_type";
+
+    public final static String GTASK_JSON_GET_DELETED = "get_deleted";
+
+    public final static String GTASK_JSON_ID = "id";
+
+    public final static String GTASK_JSON_INDEX = "index";
+
+    public final static String GTASK_JSON_LAST_MODIFIED = "last_modified";
+
+    public final static String GTASK_JSON_LATEST_SYNC_POINT = "latest_sync_point";
+
+    public final static String GTASK_JSON_LIST_ID = "list_id";
+
+    public final static String GTASK_JSON_LISTS = "lists";
+
+    public final static String GTASK_JSON_NAME = "name";
+
+    public final static String GTASK_JSON_NEW_ID = "new_id";
+
+    public final static String GTASK_JSON_NOTES = "notes";
+
+    public final static String GTASK_JSON_PARENT_ID = "parent_id";
+
+    public final static String GTASK_JSON_PRIOR_SIBLING_ID = "prior_sibling_id";
+
+    public final static String GTASK_JSON_RESULTS = "results";
+
+    public final static String GTASK_JSON_SOURCE_LIST = "source_list";
+
+    public final static String GTASK_JSON_TASKS = "tasks";
+
+    public final static String GTASK_JSON_TYPE = "type";
+
+    public final static String GTASK_JSON_TYPE_GROUP = "GROUP";
+
+    public final static String GTASK_JSON_TYPE_TASK = "TASK";
+
+    public final static String GTASK_JSON_USER = "user";
+
+    public final static String MIUI_FOLDER_PREFFIX = "[MIUI_Notes]";
+
+    public final static String FOLDER_DEFAULT = "Default";
+
+    public final static String FOLDER_CALL_NOTE = "Call_Note";
+
+    public final static String FOLDER_META = "METADATA";
+
+    public final static String META_HEAD_GTASK_ID = "meta_gid";
+
+    public final static String META_HEAD_NOTE = "meta_note";
+
+    public final static String META_HEAD_DATA = "meta_data";
+
+    public final static String META_NOTE_NAME = "[META INFO] DON'T UPDATE AND DELETE";
+
+}

src/项目原代码.txt

@@ -0,0 +1 @@
+assdjgyuguyhgnb6

ui/AlarmAlertActivity.java

@@ -0,0 +1,229 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.ui;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.content.DialogInterface.OnDismissListener;
+import android.content.Intent;
+import android.media.AudioManager;
+import android.media.MediaPlayer;
+import android.media.RingtoneManager;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.PowerManager;
+import android.provider.Settings;
+import android.view.Window;
+import android.view.WindowManager;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.tool.DataUtils;
+
+import java.io.IOException;
+
+/**
+ * AlarmAlertActivity 类用于处理笔记提醒，当笔记提醒时间到达时，
+ * 显示提醒对话框并播放提醒声音。
+ */
+public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener {
+    // 存储笔记的 ID
+    private long mNoteId;
+    // 存储笔记的摘要信息
+    private String mSnippet;
+    // 摘要信息显示的最大长度
+    private static final int SNIPPET_PREW_MAX_LEN = 60;
+    // 用于播放提醒声音的媒体播放器
+    MediaPlayer mPlayer;
+
+    /**
+     * Activity 创建时调用的方法，进行初始化操作。
+     * @param savedInstanceState 如果 Activity 是重新创建的，则包含之前保存的状态信息。
+     */
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        // 请求不显示标题栏
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+
+        // 获取当前窗口
+        final Window win = getWindow();
+        // 添加标志，使窗口在锁屏状态下也能显示
+        win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
+
+        // 如果屏幕处于关闭状态
+        if (!isScreenOn()) {
+            // 添加标志，保持屏幕常亮、点亮屏幕、允许在屏幕开启时锁定等
+            win.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
+                    | WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
+                    | WindowManager.LayoutParams.FLAG_ALLOW_LOCK_WHILE_SCREEN_ON
+                    | WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR);
+        }
+
+        // 获取启动该 Activity 的 Intent
+        Intent intent = getIntent();
+
+        try {
+            // 从 Intent 的数据路径中获取笔记的 ID
+            mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1));
+            // 根据笔记 ID 获取笔记的摘要信息
+            mSnippet = DataUtils.getSnippetById(this.getContentResolver(), mNoteId);
+            // 如果摘要信息长度超过最大显示长度，则进行截取并添加省略号
+            mSnippet = mSnippet.length() > SNIPPET_PREW_MAX_LEN ? mSnippet.substring(0,
+                    SNIPPET_PREW_MAX_LEN) + getResources().getString(R.string.notelist_string_info)
+                    : mSnippet;
+        } catch (IllegalArgumentException e) {
+            // 处理异常，打印堆栈信息
+            e.printStackTrace();
+            return;
+        }
+
+        // 创建媒体播放器实例
+        mPlayer = new MediaPlayer();
+        // 检查笔记是否在数据库中可见
+        if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) {
+            // 显示提醒对话框
+            showActionDialog();
+            // 播放提醒声音
+            playAlarmSound();
+        } else {
+            // 如果笔记不可见，则关闭该 Activity
+            finish();
+        }
+    }
+
+    /**
+     * 检查屏幕是否处于开启状态。
+     * @return 如果屏幕开启返回 true，否则返回 false。
+     */
+    private boolean isScreenOn() {
+        // 获取电源管理服务
+        PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
+        // 检查屏幕是否开启
+        return pm.isScreenOn();
+    }
+
+    /**
+     * 播放提醒声音。
+     */
+    private void playAlarmSound() {
+        // 获取默认的闹钟铃声 URI
+        Uri url = RingtoneManager.getActualDefaultRingtoneUri(this, RingtoneManager.TYPE_ALARM);
+
+        // 获取静音模式下受影响的音频流设置
+        int silentModeStreams = Settings.System.getInt(getContentResolver(),
+                Settings.System.MODE_RINGER_STREAMS_AFFECTED, 0);
+
+        // 根据静音模式设置音频流类型
+        if ((silentModeStreams & (1 << AudioManager.STREAM_ALARM)) != 0) {
+            mPlayer.setAudioStreamType(silentModeStreams);
+        } else {
+            mPlayer.setAudioStreamType(AudioManager.STREAM_ALARM);
+        }
+        try {
+            // 设置音频数据源
+            mPlayer.setDataSource(this, url);
+            // 准备媒体播放器
+            mPlayer.prepare();
+            // 设置循环播放
+            mPlayer.setLooping(true);
+            // 开始播放
+            mPlayer.start();
+        } catch (IllegalArgumentException e) {
+            // 处理异常，打印堆栈信息
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            // 处理异常，打印堆栈信息
+            e.printStackTrace();
+        } catch (IllegalStateException e) {
+            // 处理异常，打印堆栈信息
+            e.printStackTrace();
+        } catch (IOException e) {
+            // 处理异常，打印堆栈信息
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * 显示提醒对话框。
+     */
+    private void showActionDialog() {
+        // 创建对话框构建器
+        AlertDialog.Builder dialog = new AlertDialog.Builder(this);
+        // 设置对话框标题
+        dialog.setTitle(R.string.app_name);
+        // 设置对话框显示的消息，即笔记摘要信息
+        dialog.setMessage(mSnippet);
+        // 设置确认按钮及其点击监听器
+        dialog.setPositiveButton(R.string.notealert_ok, this);
+        // 如果屏幕处于开启状态，设置进入笔记编辑页面的按钮
+        if (isScreenOn()) {
+            dialog.setNegativeButton(R.string.notealert_enter, this);
+        }
+        // 显示对话框并设置对话框关闭监听器
+        dialog.show().setOnDismissListener(this);
+    }
+
+    /**
+     * 处理对话框按钮点击事件。
+     * @param dialog 触发点击事件的对话框。
+     * @param which 被点击的按钮标识。
+     */
+    public void onClick(DialogInterface dialog, int which) {
+        switch (which) {
+            case DialogInterface.BUTTON_NEGATIVE:
+                // 创建一个 Intent 用于启动笔记编辑 Activity
+                Intent intent = new Intent(this, NoteEditActivity.class);
+                // 设置 Intent 的操作类型为查看
+                intent.setAction(Intent.ACTION_VIEW);
+                // 传递笔记的 ID 到笔记编辑 Activity
+                intent.putExtra(Intent.EXTRA_UID, mNoteId);
+                // 启动笔记编辑 Activity
+                startActivity(intent);
+                break;
+            default:
+                break;
+        }
+    }
+
+    /**
+     * 处理对话框关闭事件。
+     * @param dialog 关闭的对话框。
+     */
+    public void onDismiss(DialogInterface dialog) {
+        // 停止播放提醒声音
+        stopAlarmSound();
+        // 关闭当前 Activity
+        finish();
+    }
+
+    /**
+     * 停止播放提醒声音并释放媒体播放器资源。
+     */
+    private void stopAlarmSound() {
+        if (mPlayer != null) {
+            // 停止播放
+            mPlayer.stop();
+            // 释放媒体播放器资源
+            mPlayer.release();
+            mPlayer = null;
+        }
+    }
+}

ui/AlarmInitReceiver.java

@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+ package net.micode.notes.ui;
+
+ import android.app.AlarmManager;
+ import android.app.PendingIntent;
+ import android.content.BroadcastReceiver;
+ import android.content.ContentUris;
+ import android.content.Context;
+ import android.content.Intent;
+ import android.database.Cursor;
+ 
+ import net.micode.notes.data.Notes;
+ import net.micode.notes.data.Notes.NoteColumns;
+ 
+ /**
+  * AlarmInitReceiver 类用于在接收到广播时初始化所有未触发的提醒闹钟。
+  * 它会查询数据库中所有提醒日期晚于当前时间的便签，并为每个便签设置一个提醒闹钟。
+  */
+ public class AlarmInitReceiver extends BroadcastReceiver {
+ 
+     // 定义查询便签时需要返回的列
+     private static final String [] PROJECTION = new String [] {
+         NoteColumns.ID,  // 便签的 ID
+         NoteColumns.ALERTED_DATE  // 便签的提醒日期
+     };
+ 
+     // 定义查询结果集中各列的索引
+     private static final int COLUMN_ID                = 0;  // 便签 ID 列的索引
+     private static final int COLUMN_ALERTED_DATE      = 1;  // 便签提醒日期列的索引
+ 
+     /**
+      * 当接收到广播时调用此方法。
+      * 该方法会查询数据库中所有提醒日期晚于当前时间的便签，并为每个便签设置一个提醒闹钟。
+      *
+      * @param context 应用程序的上下文
+      * @param intent 接收到的广播意图
+      */
+     @Override
+     public void onReceive(Context context, Intent intent) {
+         // 获取当前时间的毫秒数
+         long currentDate = System.currentTimeMillis();
+         // 查询数据库中所有提醒日期晚于当前时间且类型为便签的记录
+         Cursor c = context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
+                 PROJECTION,
+                 // 查询条件：提醒日期大于当前时间且便签类型为普通便签
+                 NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE,
+                 // 查询条件的参数，将当前时间作为参数传入
+                 new String[] { String.valueOf(currentDate) },
+                 null);
+ 
+         // 如果查询结果不为空
+         if (c != null) {
+             // 移动到结果集的第一行
+             if (c.moveToFirst()) {
+                 // 遍历结果集中的每一行
+                 do {
+                     // 获取当前便签的提醒日期
+                     long alertDate = c.getLong(COLUMN_ALERTED_DATE);
+                     // 创建一个新的意图，用于触发 AlarmReceiver
+                     Intent sender = new Intent(context, AlarmReceiver.class);
+                     // 设置意图的数据为当前便签的 URI
+                     sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(COLUMN_ID)));
+                     // 创建一个 PendingIntent，用于在提醒日期触发广播
+                     PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, 0);
+                     // 获取系统的闹钟服务
+                     AlarmManager alermManager = (AlarmManager) context
+                             .getSystemService(Context.ALARM_SERVICE);
+                     // 设置闹钟，在提醒日期唤醒设备并触发 PendingIntent
+                     alermManager.set(AlarmManager.RTC_WAKEUP, alertDate, pendingIntent);
+                 } while (c.moveToNext());
+             }
+             // 关闭游标，释放资源
+             c.close();
+         }
+     }
+ }

ui/AlarmReceiver.java

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

ui/DateTimePicker.java

@@ -0,0 +1,412 @@
+/*
+ * 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 net.micode.notes.ui.DateTimePicker.OnDateTimeChangedListener;
+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 void removeSyncAccount() {
+    // 获取指定名称的 SharedPreferences 对象，使用私有模式，确保只有本应用可以访问这些设置
+    SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
+    // 获取 SharedPreferences 的编辑器，用于修改存储的设置
+    SharedPreferences.Editor editor = settings.edit();
+    // 检查 SharedPreferences 中是否包含同步账户名称的键
+    if (settings.contains(PREFERENCE_SYNC_ACCOUNT_NAME)) {
+        // 如果包含，则从编辑器中移除该键值对
+        editor.remove(PREFERENCE_SYNC_ACCOUNT_NAME);
+    }
+    // 检查 SharedPreferences 中是否包含最后同步时间的键
+    if (settings.contains(PREFERENCE_LAST_SYNC_TIME)) {
+        // 如果包含，则从编辑器中移除该键值对
+        editor.remove(PREFERENCE_LAST_SYNC_TIME);
+    }
+    // 提交编辑器中的修改，将更改保存到 SharedPreferences 中
+    editor.commit();
+
+    // 清理本地与 Google 任务（GTask）相关的信息，由于数据库操作可能会阻塞主线程，因此在新线程中执行
+    new Thread(new Runnable() {
+        public void run() {
+            // 创建一个 ContentValues 对象，用于存储要更新的数据
+            ContentValues values = new ContentValues();
+            // 将 GTask ID 字段设置为空字符串
+            values.put(NoteColumns.GTASK_ID, "");
+            // 将同步 ID 字段设置为 0
+            values.put(NoteColumns.SYNC_ID, 0);
+            // 使用 ContentResolver 更新 Notes 内容提供者中的笔记数据，将 GTask ID 和同步 ID 字段清空
+            getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
+        }
+    }).start();
+}
+
+// 获取当前设置的同步账户名称
+public static String getSyncAccountName(Context context) {
+    // 获取指定名称的 SharedPreferences 对象，使用私有模式
+    SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
+            Context.MODE_PRIVATE);
+    // 从 SharedPreferences 中获取同步账户名称，如果不存在则返回空字符串
+    return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
+}
+
+// 设置最后一次同步的时间
+public static void setLastSyncTime(Context context, long time) {
+    // 获取指定名称的 SharedPreferences 对象，使用私有模式
+    SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
+            Context.MODE_PRIVATE);
+    // 获取 SharedPreferences 的编辑器，用于修改存储的设置
+    SharedPreferences.Editor editor = settings.edit();
+    // 将最后同步时间存储到编辑器中
+    editor.putLong(PREFERENCE_LAST_SYNC_TIME, time);
+    // 提交编辑器中的修改，将更改保存到 SharedPreferences 中
+    editor.commit();
+}
+
+// 获取最后一次同步的时间
+public static long getLastSyncTime(Context context) {
+    // 获取指定名称的 SharedPreferences 对象，使用私有模式
+    SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
+            Context.MODE_PRIVATE);
+    // 从 SharedPreferences 中获取最后同步时间，如果不存在则返回 0
+    return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);
+}
+
+// 自定义广播接收器，用于接收 GTask 同步服务的广播
+private class GTaskReceiver extends BroadcastReceiver {
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        // 刷新界面，更新账户设置和同步按钮状态等信息
+        refreshUI();
+        // 检查广播意图中是否包含正在同步的标志，并且标志为 true
+        if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {
+            // 查找用于显示同步状态的 TextView 控件
+            TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
+            // 设置同步状态文本为广播意图中携带的进度消息
+            syncStatus.setText(intent
+                    .getStringExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_PROGRESS_MSG));
+        }
+    }
+}
+
+// 处理选项菜单的点击事件
+public boolean onOptionsItemSelected(MenuItem item) {
+    // 根据点击的菜单项 ID 进行不同的处理
+    switch (item.getItemId()) {
+        // 如果点击的是应用图标（即返回按钮）
+        case android.R.id.home:
+            // 创建一个意图，用于启动 NotesListActivity
+            Intent intent = new Intent(this, NotesListActivity.class);
+            // 添加标志，确保启动的 NotesListActivity 位于任务栈的顶部，并清除之前的所有活动
+            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+            // 启动 NotesListActivity
+            startActivity(intent);
+            // 返回 true 表示事件已处理
+            return true;
+        // 如果点击的是其他菜单项
+        default:
+            // 返回 false 表示事件未处理
+            return false;
+    }
+}
+    // 获取当前月份
+public int getCurrentMonth() {
+    // 通过Calendar对象获取当前月份
+    return mDate.get(Calendar.MONTH);
+}
+
+/**
+ * 设置当前年份中的月份
+ *
+ * @param month 年份中的月份
+ */
+public void setCurrentMonth(int month) {
+    // 如果不是初始化阶段且设置的月份与当前月份相同，则直接返回
+    if (!mInitialising && month == getCurrentMonth()) {
+        return;
+    }
+    // 设置Calendar对象的月份
+    mDate.set(Calendar.MONTH, month);
+    // 更新日期控件显示
+    updateDateControl();
+    // 触发日期时间改变的回调
+    onDateTimeChanged();
+}
+
+/**
+ * 获取当前月份中的日期
+ *
+ * @return 月份中的日期
+ */
+public int getCurrentDay() {
+    // 通过Calendar对象获取当前月份中的日期
+    return mDate.get(Calendar.DAY_OF_MONTH);
+}
+
+/**
+ * 设置当前月份中的日期
+ *
+ * @param dayOfMonth 月份中的日期
+ */
+public void setCurrentDay(int dayOfMonth) {
+    // 如果不是初始化阶段且设置的日期与当前日期相同，则直接返回
+    if (!mInitialising && dayOfMonth == getCurrentDay()) {
+        return;
+    }
+    // 设置Calendar对象的日期
+    mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
+    // 更新日期控件显示
+    updateDateControl();
+    // 触发日期时间改变的回调
+    onDateTimeChanged();
+}
+
+/**
+ * 获取24小时制的当前小时，范围在(0~23)
+ * @return 24小时制的当前小时
+ */
+public int getCurrentHourOfDay() {
+    // 通过Calendar对象获取24小时制的当前小时
+    return mDate.get(Calendar.HOUR_OF_DAY);
+}
+
+// 获取当前小时，根据是否为24小时制进行不同处理
+private int getCurrentHour() {
+    if (mIs24HourView){
+        // 如果是24小时制，直接返回24小时制的当前小时
+        return getCurrentHourOfDay();
+    } else {
+        // 如果是12小时制
+        int hour = getCurrentHourOfDay();
+        if (hour > HOURS_IN_HALF_DAY) {
+            // 如果小时数大于12，减去12
+            return hour - HOURS_IN_HALF_DAY;
+        } else {
+            // 如果小时数为0，则显示为12，否则直接显示
+            return hour == 0 ? HOURS_IN_HALF_DAY : hour;
+        }
+    }
+}
+
+/**
+ * 设置24小时制的当前小时，范围在(0~23)
+ *
+ * @param hourOfDay 24小时制的当前小时
+ */
+public void setCurrentHour(int hourOfDay) {
+    // 如果不是初始化阶段且设置的小时与当前小时相同，则直接返回
+    if (!mInitialising && hourOfDay == getCurrentHourOfDay()) {
+        return;
+    }
+    // 设置Calendar对象的小时
+    mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
+    if (!mIs24HourView) {
+        // 如果是12小时制
+        if (hourOfDay >= HOURS_IN_HALF_DAY) {
+            // 如果小时数大于等于12，设置为下午
+            mIsAm = false;
+            if (hourOfDay > HOURS_IN_HALF_DAY) {
+                // 如果小时数大于12，减去12
+                hourOfDay -= HOURS_IN_HALF_DAY;
+            }
+        } else {
+            // 如果小时数小于12，设置为上午
+            mIsAm = true;
+            if (hourOfDay == 0) {
+                // 如果小时数为0，则显示为12
+                hourOfDay = HOURS_IN_HALF_DAY;
+            }
+        }
+        // 更新上午/下午控件显示
+        updateAmPmControl();
+    }
+    // 设置小时选择器的值
+    mHourSpinner.setValue(hourOfDay);
+    // 触发日期时间改变的回调
+    onDateTimeChanged();
+}
+
+/**
+ * 获取当前分钟
+ *
+ * @return 当前分钟
+ */
+public int getCurrentMinute() {
+    // 通过Calendar对象获取当前分钟
+    return mDate.get(Calendar.MINUTE);
+}
+
+/**
+ * 设置当前分钟
+ */
+public void setCurrentMinute(int minute) {
+    // 如果不是初始化阶段且设置的分钟与当前分钟相同，则直接返回
+    if (!mInitialising && minute == getCurrentMinute()) {
+        return;
+    }
+    // 设置分钟选择器的值
+    mMinuteSpinner.setValue(minute);
+    // 设置Calendar对象的分钟
+    mDate.set(Calendar.MINUTE, minute);
+    // 触发日期时间改变的回调
+    onDateTimeChanged();
+}
+
+/**
+ * @return 如果是24小时制视图返回true，否则返回false。
+ */
+public boolean is24HourView () {
+    // 返回是否为24小时制视图的标志
+    return mIs24HourView;
+}
+
+/**
+ * 设置是否为24小时制或上午/下午模式。
+ *
+ * @param is24HourView 为true表示24小时制模式，为false表示上午/下午模式。
+ */
+public void set24HourView(boolean is24HourView) {
+    // 如果当前模式与要设置的模式相同，则直接返回
+    if (mIs24HourView == is24HourView) {
+        return;
+    }
+    // 更新是否为24小时制视图的标志
+    mIs24HourView = is24HourView;
+    // 根据是否为24小时制视图，显示或隐藏上午/下午选择器
+    mAmPmSpinner.setVisibility(is24HourView ? View.GONE : View.VISIBLE);
+    // 获取当前24小时制的小时
+    int hour = getCurrentHourOfDay();
+    // 更新小时选择器的范围
+    updateHourControl();
+    // 设置当前小时
+    setCurrentHour(hour);
+    // 更新上午/下午控件显示
+    updateAmPmControl();
+}
+
+// 更新日期控件的显示
+private void updateDateControl() {
+    // 创建一个新的Calendar对象
+    Calendar cal = Calendar.getInstance();
+    // 设置Calendar对象的时间为当前时间
+    cal.setTimeInMillis(mDate.getTimeInMillis());
+    // 将日期向前移动DAYS_IN_ALL_WEEK / 2 + 1天
+    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) {
+        // 日期向后移动1天
+        cal.add(Calendar.DAY_OF_YEAR, 1);
+        // 将日期格式化为"MM.dd EEEE"的字符串
+        mDateDisplayValues[i] = (String) DateFormat.format("MM.dd EEEE", cal);
+    }
+    // 设置日期选择器的显示值
+    mDateSpinner.setDisplayedValues(mDateDisplayValues);
+    // 设置日期选择器的当前值为中间值
+    mDateSpinner.setValue(DAYS_IN_ALL_WEEK / 2);
+    // 使日期选择器重绘
+    mDateSpinner.invalidate();
+}
+
+// 更新上午/下午控件的显示
+private void updateAmPmControl() {
+    if (mIs24HourView) {
+        // 如果是24小时制视图，隐藏上午/下午选择器
+        mAmPmSpinner.setVisibility(View.GONE);
+    } else {
+        // 如果是12小时制视图，根据是否为上午设置选择器的值
+        int index = mIsAm ? Calendar.AM : Calendar.PM;
+        mAmPmSpinner.setValue(index);
+        // 显示上午/下午选择器
+        mAmPmSpinner.setVisibility(View.VISIBLE);
+    }
+}
+
+// 更新小时控件的显示
+private void updateHourControl() {
+    if (mIs24HourView) {
+        // 如果是24小时制视图，设置小时选择器的最小值和最大值
+        mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW);
+        mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW);
+    } else {
+        // 如果是12小时制视图，设置小时选择器的最小值和最大值
+        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() {
+    if (mOnDateTimeChangedListener != null) {
+        // 调用回调函数，传递当前的年、月、日、小时和分钟
+        mOnDateTimeChangedListener.onDateTimeChanged(this, getCurrentYear(),
+                getCurrentMonth(), getCurrentDay(), getCurrentHourOfDay(), getCurrentMinute());
+    }
+}
+}

ui/DateTimePickerDialog.java

@@ -0,0 +1,146 @@
+/*
+ * 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;
+ 
+ /**
+  * DateTimePickerDialog 类继承自 AlertDialog，用于显示一个日期时间选择对话框。
+  * 该对话框包含一个 DateTimePicker 组件，允许用户选择日期和时间。
+  * 当用户选择日期和时间并点击确定按钮时，会触发相应的回调函数。
+  */
+ public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
+ 
+     // 用于存储用户选择的日期和时间
+     private Calendar mDate = Calendar.getInstance();
+     // 标记是否使用 24 小时制显示时间
+     private boolean mIs24HourView;
+     // 日期时间选择确定的回调接口
+     private OnDateTimeSetListener mOnDateTimeSetListener;
+     // 自定义的日期时间选择器组件
+     private DateTimePicker mDateTimePicker;
+ 
+     /**
+      * 日期时间选择确定的回调接口，当用户点击确定按钮时会调用该接口的方法。
+      */
+     public interface OnDateTimeSetListener {
+         /**
+          * 当用户点击确定按钮时调用该方法，传递对话框实例和选择的日期时间（以毫秒为单位）。
+          * @param dialog 日期时间选择对话框实例
+          * @param date 选择的日期时间（以毫秒为单位）
+          */
+         void OnDateTimeSet(AlertDialog dialog, long date);
+     }
+ 
+     /**
+      * 构造函数，初始化日期时间选择对话框。
+      * @param context 上下文对象
+      * @param date 初始显示的日期时间（以毫秒为单位）
+      */
+     public DateTimePickerDialog(Context context, long date) {
+         super(context);
+         // 创建 DateTimePicker 实例
+         mDateTimePicker = new DateTimePicker(context);
+         // 将 DateTimePicker 设置为对话框的视图
+         setView(mDateTimePicker);
+         // 为 DateTimePicker 设置日期时间改变的监听器
+         mDateTimePicker.setOnDateTimeChangedListener(new OnDateTimeChangedListener() {
+             @Override
+             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());
+             }
+         });
+         // 设置 Calendar 对象的时间为传入的日期时间
+         mDate.setTimeInMillis(date);
+         // 将秒数设置为 0
+         mDate.set(Calendar.SECOND, 0);
+         // 设置 DateTimePicker 的当前日期时间
+         mDateTimePicker.setCurrentDate(mDate.getTimeInMillis());
+         // 设置对话框的确定按钮及其点击监听器
+         setButton(context.getString(R.string.datetime_dialog_ok), this);
+         // 设置对话框的取消按钮
+         setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener)null);
+         // 根据系统设置确定是否使用 24 小时制
+         set24HourView(DateFormat.is24HourFormat(this.getContext()));
+         // 更新对话框的标题显示初始日期时间
+         updateTitle(mDate.getTimeInMillis());
+     }
+ 
+     /**
+      * 设置是否使用 24 小时制显示时间。
+      * @param is24HourView true 表示使用 24 小时制，false 表示使用 12 小时制
+      */
+     public void set24HourView(boolean is24HourView) {
+         mIs24HourView = is24HourView;
+     }
+ 
+     /**
+      * 设置日期时间选择确定的回调接口。
+      * @param callBack 实现 OnDateTimeSetListener 接口的回调对象
+      */
+     public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) {
+         mOnDateTimeSetListener = callBack;
+     }
+ 
+     /**
+      * 更新对话框的标题，显示当前选择的日期时间。
+      * @param date 当前选择的日期时间（以毫秒为单位）
+      */
+     private void updateTitle(long date) {
+         // 设置日期时间显示的标志
+         int flag =
+             DateUtils.FORMAT_SHOW_YEAR |
+             DateUtils.FORMAT_SHOW_DATE |
+             DateUtils.FORMAT_SHOW_TIME;
+         // 根据是否使用 24 小时制添加相应的标志
+         flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_24HOUR;
+         // 设置对话框的标题为格式化后的日期时间
+         setTitle(DateUtils.formatDateTime(this.getContext(), date, flag));
+     }
+ 
+     /**
+      * 处理对话框按钮的点击事件。
+      * @param arg0 对话框接口对象
+      * @param arg1 按钮的索引
+      */
+     @Override
+     public void onClick(DialogInterface arg0, int arg1) {
+         // 如果设置了回调接口，则调用回调方法
+         if (mOnDateTimeSetListener != null) {
+             mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis());
+         }
+     }
+ }

ui/DropdownMenu.java

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+ package net.micode.notes.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;
+ 
+ /**
+  * DropdownMenu 类用于创建一个下拉菜单，它将一个按钮与一个弹出菜单关联起来。
+  * 当点击按钮时，会显示弹出菜单。
+  */
+ public class DropdownMenu {
+     // 用于触发弹出菜单的按钮
+     private Button mButton;
+     // 弹出菜单对象
+     private PopupMenu mPopupMenu;
+     // 弹出菜单的菜单对象
+     private Menu mMenu;
+ 
+     /**
+      * 构造函数，用于初始化下拉菜单。
+      *
+      * @param context 上下文对象，用于创建弹出菜单
+      * @param button  触发弹出菜单的按钮
+      * @param menuId  菜单资源的 ID，用于指定弹出菜单的内容
+      */
+     public DropdownMenu(Context context, Button button, int menuId) {
+         // 保存传入的按钮对象
+         mButton = button;
+         // 设置按钮的背景资源为下拉图标
+         mButton.setBackgroundResource(R.drawable.dropdown_icon);
+         // 创建一个弹出菜单，将其关联到按钮上
+         mPopupMenu = new PopupMenu(context, mButton);
+         // 获取弹出菜单的菜单对象
+         mMenu = mPopupMenu.getMenu();
+         // 从指定的菜单资源 ID 中加载菜单内容到菜单对象中
+         mPopupMenu.getMenuInflater().inflate(menuId, mMenu);
+         // 为按钮设置点击监听器，当按钮被点击时显示弹出菜单
+         mButton.setOnClickListener(new OnClickListener() {
+             public void onClick(View v) {
+                 mPopupMenu.show();
+             }
+         });
+     }
+ 
+     /**
+      * 设置下拉菜单中菜单项的点击监听器。
+      *
+      * @param listener 菜单项点击监听器对象
+      */
+     public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {
+         // 检查弹出菜单是否为空
+         if (mPopupMenu != null) {
+             // 设置弹出菜单的菜单项点击监听器
+             mPopupMenu.setOnMenuItemClickListener(listener);
+         }
+     }
+ 
+     /**
+      * 根据菜单项的 ID 查找对应的菜单项。
+      *
+      * @param id 菜单项的 ID
+      * @return 找到的菜单项对象，如果未找到则返回 null
+      */
+     public MenuItem findItem(int id) {
+         // 在菜单对象中查找指定 ID 的菜单项
+         return mMenu.findItem(id);
+     }
+ 
+     /**
+      * 设置按钮的标题文本。
+      *
+      * @param title 要设置的标题文本
+      */
+     public void setTitle(CharSequence title) {
+         // 设置按钮的文本为传入的标题文本
+         mButton.setText(title);
+     }
+ }

ui/FoldersListAdapter.java

@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+ package net.micode.notes.ui;
+
+ import 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; // 名称列的索引
+ 
+     /**
+      * 构造函数，用于创建 FoldersListAdapter 实例。
+      *
+      * @param context 上下文对象，用于访问应用资源
+      * @param c 包含文件夹数据的游标
+      */
+     public FoldersListAdapter(Context context, Cursor c) {
+         super(context, c);
+         // TODO Auto-generated constructor stub
+     }
+ 
+     /**
+      * 创建一个新的视图来显示游标中的数据。
+      *
+      * @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) {
+         // 检查视图是否为 FolderListItem 类型
+         if (view instanceof FolderListItem) {
+             // 获取文件夹名称，如果文件夹的 ID 是根文件夹的 ID，则显示特定的字符串
+             String folderName = (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
+                     .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
+             // 调用 FolderListItem 的 bind 方法将文件夹名称绑定到视图上
+             ((FolderListItem) view).bind(folderName);
+         }
+     }
+ 
+     /**
+      * 根据指定的位置获取文件夹的名称。
+      *
+      * @param context 上下文对象，用于访问应用资源
+      * @param position 文件夹在列表中的位置
+      * @return 返回文件夹的名称
+      */
+     public String getFolderName(Context context, int position) {
+         // 获取指定位置的游标
+         Cursor cursor = (Cursor) getItem(position);
+         // 获取文件夹名称，如果文件夹的 ID 是根文件夹的 ID，则显示特定的字符串
+         return (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
+                 .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
+     }
+ 
+     /**
+      * FolderListItem 是一个自定义的线性布局，用于显示文件夹名称。
+      */
+     private class FolderListItem extends LinearLayout {
+         private TextView mName; // 用于显示文件夹名称的文本视图
+ 
+         /**
+          * 构造函数，用于创建 FolderListItem 实例。
+          *
+          * @param context 上下文对象，用于访问应用资源
+          */
+         public FolderListItem(Context context) {
+             super(context);
+             // 加载文件夹列表项的布局文件
+             inflate(context, R.layout.folder_list_item, this);
+             // 获取布局文件中的文本视图
+             mName = (TextView) findViewById(R.id.tv_folder_name);
+         }
+ 
+         /**
+          * 将文件夹名称绑定到文本视图上。
+          *
+          * @param name 文件夹的名称
+          */
+         public void bind(String name) {
+             mName.setText(name);
+         }
+     }
+ }

ui/NoteEditText.java

@@ -0,0 +1,317 @@
+/*
+ * 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;
+ 
+ /**
+  * NoteEditText 类继承自 EditText，用于处理笔记编辑过程中的一些特殊逻辑，
+  * 如处理删除、回车按键事件，处理链接点击事件等。
+  */
+ public class NoteEditText extends EditText {
+     // 日志标签，用于在日志中标识该类的信息
+     private static final String TAG = "NoteEditText";
+     // 该编辑文本框的索引，用于在列表中定位
+     private int mIndex;
+     // 删除操作前的选择起始位置
+     private int mSelectionStartBeforeDelete;
+ 
+     // 电话链接的协议前缀
+     private static final String SCHEME_TEL = "tel:" ;
+     // 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 {
+         // 初始化映射，将电话协议前缀映射到对应的菜单项资源 ID
+         sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel);
+         // 初始化映射，将 HTTP 协议前缀映射到对应的菜单项资源 ID
+         sSchemaActionResMap.put(SCHEME_HTTP, R.string.note_link_web);
+         // 初始化映射，将邮件协议前缀映射到对应的菜单项资源 ID
+         sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email);
+     }
+ 
+     /**
+      * OnTextViewChangeListener 接口定义了在编辑文本框发生特定事件时的回调方法，
+      * 由外部类实现，用于处理删除、回车和文本变化等事件。
+      */
+     public interface OnTextViewChangeListener {
+         /**
+          * 当按下删除键且文本为空时，调用此方法删除当前编辑文本框。
+          * @param index 当前编辑文本框的索引
+          * @param text 当前编辑文本框的文本内容
+          */
+         void onEditTextDelete(int index, String text);
+ 
+         /**
+          * 当按下回车键时，调用此方法在当前编辑文本框之后添加一个新的编辑文本框。
+          * @param index 当前编辑文本框的下一个索引
+          * @param text 当前编辑文本框中光标之后的文本内容
+          */
+         void onEditTextEnter(int index, String text);
+ 
+         /**
+          * 当文本内容发生变化时，调用此方法隐藏或显示菜单项。
+          * @param index 当前编辑文本框的索引
+          * @param hasText 当前编辑文本框是否有文本内容
+          */
+         void onTextChange(int index, boolean hasText);
+     }
+ 
+     // 文本变化监听器实例
+     private OnTextViewChangeListener mOnTextViewChangeListener;
+ 
+     /**
+      * 构造函数，使用默认属性创建 NoteEditText 实例。
+      * @param context 上下文对象
+      */
+     public NoteEditText(Context context) {
+         super(context, null);
+         // 初始化索引为 0
+         mIndex = 0;
+     }
+ 
+     /**
+      * 设置当前编辑文本框的索引。
+      * @param index 要设置的索引值
+      */
+     public void setIndex(int index) {
+         mIndex = index;
+     }
+ 
+     /**
+      * 设置文本变化监听器。
+      * @param listener 实现了 OnTextViewChangeListener 接口的监听器实例
+      */
+     public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
+         mOnTextViewChangeListener = listener;
+     }
+ 
+     /**
+      * 构造函数，使用指定的属性集创建 NoteEditText 实例。
+      * @param context 上下文对象
+      * @param attrs 属性集
+      */
+     public NoteEditText(Context context, AttributeSet attrs) {
+         super(context, attrs, android.R.attr.editTextStyle);
+     }
+ 
+     /**
+      * 构造函数，使用指定的属性集和默认样式创建 NoteEditText 实例。
+      * @param context 上下文对象
+      * @param attrs 属性集
+      * @param defStyle 默认样式
+      */
+     public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
+         super(context, attrs, defStyle);
+         // TODO Auto-generated constructor stub
+     }
+ 
+     /**
+      * 处理触摸事件，当手指按下时，根据触摸位置设置光标位置。
+      * @param event 触摸事件对象
+      * @return 是否处理该事件
+      */
+     @Override
+     public boolean onTouchEvent(MotionEvent event) {
+         switch (event.getAction()) {
+             case MotionEvent.ACTION_DOWN:
+                 // 获取触摸点的 x 坐标
+                 int x = (int) event.getX();
+                 // 获取触摸点的 y 坐标
+                 int y = (int) event.getY();
+                 // 减去左内边距
+                 x -= getTotalPaddingLeft();
+                 // 减去上内边距
+                 y -= getTotalPaddingTop();
+                 // 加上水平滚动距离
+                 x += getScrollX();
+                 // 加上垂直滚动距离
+                 y += getScrollY();
+ 
+                 // 获取文本布局对象
+                 Layout layout = getLayout();
+                 // 根据垂直位置获取所在行
+                 int line = layout.getLineForVertical(y);
+                 // 根据行和水平位置获取偏移量
+                 int off = layout.getOffsetForHorizontal(line, x);
+                 // 设置光标位置
+                 Selection.setSelection(getText(), off);
+                 break;
+         }
+ 
+         return super.onTouchEvent(event);
+     }
+ 
+     /**
+      * 处理按键按下事件，记录删除操作前的选择起始位置，处理回车键事件。
+      * @param keyCode 按键码
+      * @param event 按键事件对象
+      * @return 是否处理该事件
+      */
+     @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);
+     }
+ 
+     /**
+      * 处理按键释放事件，根据按键码调用相应的监听器方法。
+      * @param keyCode 按键码
+      * @param event 按键事件对象
+      * @return 是否处理该事件
+      */
+     @Override
+     public boolean onKeyUp(int keyCode, KeyEvent event) {
+         switch(keyCode) {
+             case KeyEvent.KEYCODE_DEL:
+                 if (mOnTextViewChangeListener != null) {
+                     if (0 == mSelectionStartBeforeDelete && mIndex != 0) {
+                         // 当删除操作从文本开头开始且索引不为 0 时，调用删除回调方法
+                         mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString());
+                         return true;
+                     }
+                 } else {
+                     // 记录日志，提示监听器未设置
+                     Log.d(TAG, "OnTextViewChangeListener was not seted");
+                 }
+                 break;
+             case KeyEvent.KEYCODE_ENTER:
+                 if (mOnTextViewChangeListener != null) {
+                     // 获取当前选择的起始位置
+                     int selectionStart = getSelectionStart();
+                     // 获取光标之后的文本内容
+                     String text = getText().subSequence(selectionStart, length()).toString();
+                     // 设置文本为光标之前的内容
+                     setText(getText().subSequence(0, selectionStart));
+                     // 调用回车回调方法
+                     mOnTextViewChangeListener.onEditTextEnter(mIndex + 1, text);
+                 } else {
+                     // 记录日志，提示监听器未设置
+                     Log.d(TAG, "OnTextViewChangeListener was not seted");
+                 }
+                 break;
+             default:
+                 break;
+         }
+         return super.onKeyUp(keyCode, event);
+     }
+ 
+     /**
+      * 处理焦点变化事件，根据焦点状态和文本内容调用文本变化监听器方法。
+      * @param focused 是否获得焦点
+      * @param direction 焦点变化的方向
+      * @param previouslyFocusedRect 之前焦点所在的矩形区域
+      */
+     @Override
+     protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
+         if (mOnTextViewChangeListener != null) {
+             if (!focused && TextUtils.isEmpty(getText())) {
+                 // 失去焦点且文本为空时，调用文本变化回调方法，标记为无文本
+                 mOnTextViewChangeListener.onTextChange(mIndex, false);
+             } else {
+                 // 其他情况，调用文本变化回调方法，标记为有文本
+                 mOnTextViewChangeListener.onTextChange(mIndex, true);
+             }
+         }
+         super.onFocusChanged(focused, direction, previouslyFocusedRect);
+     }
+ 
+     /**
+      * 创建上下文菜单，当选中的文本包含链接时，添加相应的菜单项。
+      * @param menu 上下文菜单对象
+      */
+     @Override
+     protected void onCreateContextMenu(ContextMenu menu) {
+         if (getText() instanceof Spanned) {
+             // 获取选择的起始位置
+             int selStart = getSelectionStart();
+             // 获取选择的结束位置
+             int selEnd = getSelectionEnd();
+ 
+             // 获取选择范围的最小值
+             int min = Math.min(selStart, selEnd);
+             // 获取选择范围的最大值
+             int max = Math.max(selStart, selEnd);
+ 
+             // 获取选择范围内的所有 URLSpan 对象
+             final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class);
+             if (urls.length == 1) {
+                 // 如果只有一个 URLSpan 对象
+                 int defaultResId = 0;
+                 for(String schema: sSchemaActionResMap.keySet()) {
+                     if(urls[0].getURL().indexOf(schema) >= 0) {
+                         // 根据链接协议前缀获取对应的菜单项资源 ID
+                         defaultResId = sSchemaActionResMap.get(schema);
+                         break;
+                     }
+                 }
+ 
+                 if (defaultResId == 0) {
+                     // 如果没有匹配的协议前缀，使用默认的菜单项资源 ID
+                     defaultResId = R.string.note_link_other;
+                 }
+ 
+                 // 添加菜单项，并设置点击监听器
+                 menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener(
+                         new OnMenuItemClickListener() {
+                             public boolean onMenuItemClick(MenuItem item) {
+                                 // 点击菜单项时，触发链接的点击事件
+                                 urls[0].onClick(NoteEditText.this);
+                                 return true;
+                             }
+                         });
+             }
+         }
+         super.onCreateContextMenu(menu);
+     }
+ }

ui/NoteItemData.java

@@ -0,0 +1,360 @@
+/*
+ * 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;
+ 
+ /**
+  * NoteItemData 类用于封装从数据库查询得到的笔记项数据。
+  * 该类提供了从 Cursor 中提取笔记数据的功能，并提供了一系列方法来获取这些数据。
+  */
+ public class NoteItemData {
+     // 定义从数据库查询笔记数据时使用的列名数组
+     static final String [] PROJECTION = new String [] {
+         NoteColumns.ID,             // 笔记的唯一标识符
+         NoteColumns.ALERTED_DATE,   // 提醒日期
+         NoteColumns.BG_COLOR_ID,    // 背景颜色 ID
+         NoteColumns.CREATED_DATE,   // 创建日期
+         NoteColumns.HAS_ATTACHMENT, // 是否有附件
+         NoteColumns.MODIFIED_DATE,  // 修改日期
+         NoteColumns.NOTES_COUNT,    // 笔记数量
+         NoteColumns.PARENT_ID,      // 父文件夹 ID
+         NoteColumns.SNIPPET,        // 笔记摘要
+         NoteColumns.TYPE,           // 笔记类型
+         NoteColumns.WIDGET_ID,      // 小部件 ID
+         NoteColumns.WIDGET_TYPE,    // 小部件类型
+     };
+ 
+     // 定义每个列在 PROJECTION 数组中的索引，方便从 Cursor 中获取数据
+     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;         // 背景颜色 ID
+     private long mCreatedDate;      // 创建日期
+     private boolean mHasAttachment; // 是否有附件
+     private long mModifiedDate;     // 修改日期
+     private int mNotesCount;        // 笔记数量
+     private long mParentId;         // 父文件夹 ID
+     private String mSnippet;        // 笔记摘要
+     private int mType;              // 笔记类型
+     private int mWidgetId;          // 小部件 ID
+     private int mWidgetType;        // 小部件类型
+     private String mName;           // 联系人姓名
+     private String mPhoneNumber;    // 联系人电话号码
+ 
+     // 笔记在列表中的位置相关标志
+     private boolean mIsLastItem;           // 是否是列表中的最后一项
+     private boolean mIsFirstItem;          // 是否是列表中的第一项
+     private boolean mIsOnlyOneItem;        // 是否是列表中唯一的一项
+     private boolean mIsOneNoteFollowingFolder; // 是否是文件夹后面的单条笔记
+     private boolean mIsMultiNotesFollowingFolder; // 是否是文件夹后面的多条笔记
+ 
+     /**
+      * 构造函数，从 Cursor 中提取笔记数据并初始化对象的属性。
+      *
+      * @param context 上下文对象，用于获取内容解析器等资源
+      * @param cursor 包含笔记数据的 Cursor 对象
+      */
+     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);
+     }
+ 
+     /**
+      * 检查笔记在列表中的位置，并设置相应的标志。
+      *
+      * @param cursor 包含笔记数据的 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;
+                     }
+                 }
+                 // 将 Cursor 移动回原来的位置
+                 if (!cursor.moveToNext()) {
+                     throw new IllegalStateException("cursor move to previous but can't move back");
+                 }
+             }
+         }
+     }
+ 
+     /**
+      * 判断笔记是否是文件夹后面的单条笔记。
+      *
+      * @return 如果是则返回 true，否则返回 false
+      */
+     public boolean isOneFollowingFolder() {
+         return mIsOneNoteFollowingFolder;
+     }
+ 
+     /**
+      * 判断笔记是否是文件夹后面的多条笔记之一。
+      *
+      * @return 如果是则返回 true，否则返回 false
+      */
+     public boolean isMultiFollowingFolder() {
+         return mIsMultiNotesFollowingFolder;
+     }
+ 
+     /**
+      * 判断笔记是否是列表中的最后一项。
+      *
+      * @return 如果是则返回 true，否则返回 false
+      */
+     public boolean isLast() {
+         return mIsLastItem;
+     }
+ 
+     /**
+      * 获取通话记录的联系人姓名。
+      *
+      * @return 联系人姓名
+      */
+     public String getCallName() {
+         return mName;
+     }
+ 
+     /**
+      * 判断笔记是否是列表中的第一项。
+      *
+      * @return 如果是则返回 true，否则返回 false
+      */
+     public boolean isFirst() {
+         return mIsFirstItem;
+     }
+ 
+     /**
+      * 判断笔记是否是列表中唯一的一项。
+      *
+      * @return 如果是则返回 true，否则返回 false
+      */
+     public boolean isSingle() {
+         return mIsOnlyOneItem;
+     }
+ 
+     /**
+      * 获取笔记的唯一标识符。
+      *
+      * @return 笔记的唯一标识符
+      */
+     public long getId() {
+         return mId;
+     }
+ 
+     /**
+      * 获取笔记的提醒日期。
+      *
+      * @return 提醒日期
+      */
+     public long getAlertDate() {
+         return mAlertDate;
+     }
+ 
+     /**
+      * 获取笔记的创建日期。
+      *
+      * @return 创建日期
+      */
+     public long getCreatedDate() {
+         return mCreatedDate;
+     }
+ 
+     /**
+      * 判断笔记是否有附件。
+      *
+      * @return 如果有附件则返回 true，否则返回 false
+      */
+     public boolean hasAttachment() {
+         return mHasAttachment;
+     }
+ 
+     /**
+      * 获取笔记的修改日期。
+      *
+      * @return 修改日期
+      */
+     public long getModifiedDate() {
+         return mModifiedDate;
+     }
+ 
+     /**
+      * 获取笔记的背景颜色 ID。
+      *
+      * @return 背景颜色 ID
+      */
+     public int getBgColorId() {
+         return mBgColorId;
+     }
+ 
+     /**
+      * 获取笔记的父文件夹 ID。
+      *
+      * @return 父文件夹 ID
+      */
+     public long getParentId() {
+         return mParentId;
+     }
+ 
+     /**
+      * 获取笔记的数量。
+      *
+      * @return 笔记数量
+      */
+     public int getNotesCount() {
+         return mNotesCount;
+     }
+ 
+     /**
+      * 获取笔记所在文件夹的 ID。
+      *
+      * @return 文件夹 ID
+      */
+     public long getFolderId () {
+         return mParentId;
+     }
+ 
+     /**
+      * 获取笔记的类型。
+      *
+      * @return 笔记类型
+      */
+     public int getType() {
+         return mType;
+     }
+ 
+     /**
+      * 获取笔记对应的小部件类型。
+      *
+      * @return 小部件类型
+      */
+     public int getWidgetType() {
+         return mWidgetType;
+     }
+ 
+     /**
+      * 获取笔记对应的小部件 ID。
+      *
+      * @return 小部件 ID
+      */
+     public int getWidgetId() {
+         return mWidgetId;
+     }
+ 
+     /**
+      * 获取笔记的摘要。
+      *
+      * @return 笔记摘要
+      */
+     public String getSnippet() {
+         return mSnippet;
+     }
+ 
+     /**
+      * 判断笔记是否设置了提醒。
+      *
+      * @return 如果设置了提醒则返回 true，否则返回 false
+      */
+     public boolean hasAlert() {
+         return (mAlertDate > 0);
+     }
+ 
+     /**
+      * 判断笔记是否是通话记录。
+      *
+      * @return 如果是通话记录则返回 true，否则返回 false
+      */
+     public boolean isCallRecord() {
+         return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber));
+     }
+ 
+     /**
+      * 从 Cursor 中获取笔记的类型。
+      *
+      * @param cursor 包含笔记数据的 Cursor 对象
+      * @return 笔记的类型
+      */
+     public static int getNoteType(Cursor cursor) {
+         return cursor.getInt(TYPE_COLUMN);
+     }
+ }

ui/NotesListAdapter.java

@@ -0,0 +1,312 @@
+/*
+ * 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;
+ 
+ /**
+  * NotesListAdapter 是一个用于显示笔记列表的适配器，继承自 CursorAdapter。
+  * 它负责管理笔记列表的视图绑定、选择状态等操作。
+  */
+ public class NotesListAdapter extends CursorAdapter {
+     // 日志标签，用于在调试时标识该类的日志信息
+     private static final String TAG = "NotesListAdapter";
+     // 上下文对象，用于获取资源和执行与 UI 相关的操作
+     private Context mContext;
+     // 用于存储每个笔记项的选择状态，键为笔记项的位置，值为是否选中的布尔值
+     private HashMap<Integer, Boolean> mSelectedIndex;
+     // 笔记的总数
+     private int mNotesCount;
+     // 是否处于选择模式的标志
+     private boolean mChoiceMode;
+ 
+     /**
+      * 内部类，用于存储小部件的属性，包括小部件 ID 和小部件类型
+      */
+     public static class AppWidgetAttribute {
+         // 小部件的 ID
+         public int widgetId;
+         // 小部件的类型
+         public int widgetType;
+     };
+ 
+     /**
+      * 构造函数，初始化适配器
+      * @param context 上下文对象
+      */
+     public NotesListAdapter(Context context) {
+         // 调用父类的构造函数，传入上下文和初始的 Cursor 为 null
+         super(context, null);
+         // 初始化选择状态的 HashMap
+         mSelectedIndex = new HashMap<Integer, Boolean>();
+         // 保存上下文对象
+         mContext = context;
+         // 初始化笔记总数为 0
+         mNotesCount = 0;
+     }
+ 
+     /**
+      * 创建一个新的视图对象，用于显示笔记项
+      * @param context 上下文对象
+      * @param cursor 数据库游标，包含笔记数据
+      * @param parent 父视图组
+      * @return 新的 NotesListItem 视图对象
+      */
+     @Override
+     public View newView(Context context, Cursor cursor, ViewGroup parent) {
+         return new NotesListItem(context);
+     }
+ 
+     /**
+      * 将数据库游标中的数据绑定到指定的视图上
+      * @param view 要绑定数据的视图
+      * @param context 上下文对象
+      * @param cursor 数据库游标，包含笔记数据
+      */
+     @Override
+     public void bindView(View view, Context context, Cursor cursor) {
+         // 检查视图是否为 NotesListItem 类型
+         if (view instanceof NotesListItem) {
+             // 创建一个 NoteItemData 对象，用于封装笔记数据
+             NoteItemData itemData = new NoteItemData(context, cursor);
+             // 调用 NotesListItem 的 bind 方法，将数据绑定到视图上，并传入选择模式和当前项的选择状态
+             ((NotesListItem) view).bind(context, itemData, mChoiceMode,
+                     isSelectedItem(cursor.getPosition()));
+         }
+     }
+ 
+     /**
+      * 设置指定位置的笔记项的选择状态
+      * @param position 笔记项的位置
+      * @param checked 是否选中
+      */
+     public void setCheckedItem(final int position, final boolean checked) {
+         // 将指定位置的选择状态保存到 HashMap 中
+         mSelectedIndex.put(position, checked);
+         // 通知适配器数据发生变化，刷新视图
+         notifyDataSetChanged();
+     }
+ 
+     /**
+      * 判断适配器是否处于选择模式
+      * @return 如果处于选择模式返回 true，否则返回 false
+      */
+     public boolean isInChoiceMode() {
+         return mChoiceMode;
+     }
+ 
+     /**
+      * 设置适配器的选择模式
+      * @param mode 是否开启选择模式
+      */
+     public void setChoiceMode(boolean mode) {
+         // 清空选择状态的 HashMap
+         mSelectedIndex.clear();
+         // 更新选择模式标志
+         mChoiceMode = mode;
+     }
+ 
+     /**
+      * 全选或全不选所有笔记项
+      * @param checked 是否全选
+      */
+     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
+      * @return 包含所有选中笔记项 ID 的 HashSet
+      */
+     public HashSet<Long> getSelectedItemIds() {
+         // 创建一个 HashSet 用于存储选中笔记项的 ID
+         HashSet<Long> itemSet = new HashSet<Long>();
+         // 遍历选择状态的 HashMap
+         for (Integer position : mSelectedIndex.keySet()) {
+             // 检查当前位置的笔记项是否被选中
+             if (mSelectedIndex.get(position) == true) {
+                 // 获取当前位置的笔记项的 ID
+                 Long id = getItemId(position);
+                 // 检查 ID 是否为根文件夹的 ID，如果是则记录日志，否则将 ID 添加到 HashSet 中
+                 if (id == Notes.ID_ROOT_FOLDER) {
+                     Log.d(TAG, "Wrong item id, should not happen");
+                 } else {
+                     itemSet.add(id);
+                 }
+             }
+         }
+         return itemSet;
+     }
+ 
+     /**
+      * 获取所有选中的小部件的属性
+      * @return 包含所有选中小部件属性的 HashSet
+      */
+     public HashSet<AppWidgetAttribute> getSelectedWidget() {
+         // 创建一个 HashSet 用于存储选中小部件的属性
+         HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>();
+         // 遍历选择状态的 HashMap
+         for (Integer position : mSelectedIndex.keySet()) {
+             // 检查当前位置的笔记项是否被选中
+             if (mSelectedIndex.get(position) == true) {
+                 // 获取当前位置的数据库游标
+                 Cursor c = (Cursor) getItem(position);
+                 // 检查游标是否有效
+                 if (c != null) {
+                     // 创建一个 AppWidgetAttribute 对象，用于存储小部件的属性
+                     AppWidgetAttribute widget = new AppWidgetAttribute();
+                     // 创建一个 NoteItemData 对象，用于封装笔记数据
+                     NoteItemData item = new NoteItemData(mContext, c);
+                     // 获取小部件的 ID 并保存到 AppWidgetAttribute 对象中
+                     widget.widgetId = item.getWidgetId();
+                     // 获取小部件的类型并保存到 AppWidgetAttribute 对象中
+                     widget.widgetType = item.getWidgetType();
+                     // 将 AppWidgetAttribute 对象添加到 HashSet 中
+                     itemSet.add(widget);
+                     /**
+                      * 不要在这里关闭游标，只有适配器可以关闭它
+                      */
+                 } else {
+                     // 记录游标无效的错误日志
+                     Log.e(TAG, "Invalid cursor");
+                     return null;
+                 }
+             }
+         }
+         return itemSet;
+     }
+ 
+     /**
+      * 获取选中的笔记项的数量
+      * @return 选中的笔记项的数量
+      */
+     public int getSelectedCount() {
+         // 获取选择状态的 HashMap 中的所有值
+         Collection<Boolean> values = mSelectedIndex.values();
+         // 检查值集合是否为空
+         if (null == values) {
+             return 0;
+         }
+         // 创建一个迭代器，用于遍历值集合
+         Iterator<Boolean> iter = values.iterator();
+         // 初始化选中笔记项的数量为 0
+         int count = 0;
+         // 遍历值集合
+         while (iter.hasNext()) {
+             // 检查当前值是否为 true，如果是则增加选中笔记项的数量
+             if (true == iter.next()) {
+                 count++;
+             }
+         }
+         return count;
+     }
+ 
+     /**
+      * 判断是否所有笔记项都被选中
+      * @return 如果所有笔记项都被选中返回 true，否则返回 false
+      */
+     public boolean isAllSelected() {
+         // 获取选中的笔记项的数量
+         int checkedCount = getSelectedCount();
+         // 检查选中的笔记项数量是否不为 0 且等于笔记总数
+         return (checkedCount != 0 && checkedCount == mNotesCount);
+     }
+ 
+     /**
+      * 判断指定位置的笔记项是否被选中
+      * @param position 笔记项的位置
+      * @return 如果指定位置的笔记项被选中返回 true，否则返回 false
+      */
+     public boolean isSelectedItem(final int position) {
+         // 检查指定位置的选择状态是否为 null，如果是则返回 false，否则返回该位置的选择状态
+         if (null == mSelectedIndex.get(position)) {
+             return false;
+         }
+         return mSelectedIndex.get(position);
+     }
+ 
+     /**
+      * 当内容发生变化时调用，更新笔记总数
+      */
+     @Override
+     protected void onContentChanged() {
+         // 调用父类的方法
+         super.onContentChanged();
+         // 重新计算笔记总数
+         calcNotesCount();
+     }
+ 
+     /**
+      * 更改适配器使用的数据库游标时调用，更新笔记总数
+      * @param cursor 新的数据库游标
+      */
+     @Override
+     public void changeCursor(Cursor cursor) {
+         // 调用父类的方法
+         super.changeCursor(cursor);
+         // 重新计算笔记总数
+         calcNotesCount();
+     }
+ 
+     /**
+      * 计算笔记的总数
+      */
+     private void calcNotesCount() {
+         // 初始化笔记总数为 0
+         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;
+             }
+         }
+     }
+ }

ui/NotesListItem.java

@@ -0,0 +1,207 @@
+/*
+ * 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 {
+     // 用于显示提醒图标的 ImageView
+     private ImageView mAlert;
+     // 用于显示标题的 TextView
+     private TextView mTitle;
+     // 用于显示修改时间的 TextView
+     private TextView mTime;
+     // 用于显示通话记录中联系人姓名的 TextView
+     private TextView mCallName;
+     // 存储当前笔记项数据的对象
+     private NoteItemData mItemData;
+     // 用于选择笔记项的 CheckBox
+     private CheckBox mCheckBox;
+ 
+     /**
+      * 构造函数，初始化 NotesListItem 视图。
+      *
+      * @param context 上下文对象
+      */
+     public NotesListItem(Context context) {
+         super(context);
+         // 将 note_item 布局文件填充到当前视图中
+         inflate(context, R.layout.note_item, this);
+         // 通过 findViewById 方法获取布局中的各个视图组件
+         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);
+     }
+ 
+     /**
+      * 绑定数据到当前笔记项视图。
+      * 根据不同的笔记类型和选择模式，设置视图的显示内容和样式。
+      *
+      * @param context     上下文对象
+      * @param data        笔记项数据对象
+      * @param choiceMode  是否处于选择模式
+      * @param checked     当前笔记项是否被选中
+      */
+     public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
+         // 如果处于选择模式且笔记类型为普通笔记
+         if (choiceMode && data.getType() == Notes.TYPE_NOTE) {
+             // 显示 CheckBox 并设置其选中状态
+             mCheckBox.setVisibility(View.VISIBLE);
+             mCheckBox.setChecked(checked);
+         } else {
+             // 否则隐藏 CheckBox
+             mCheckBox.setVisibility(View.GONE);
+         }
+ 
+         // 保存当前笔记项数据
+         mItemData = data;
+         // 如果笔记项的 ID 为通话记录文件夹的 ID
+         if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
+             // 隐藏通话记录联系人姓名的 TextView
+             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);
+         } 
+         // 如果笔记项的父 ID 为通话记录文件夹的 ID
+         else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
+             // 显示通话记录联系人姓名的 TextView 并设置其文本
+             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 {
+             // 隐藏通话记录联系人姓名的 TextView
+             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);
+     }
+ 
+     /**
+      * 根据笔记项数据设置背景资源。
+      * 根据笔记类型和笔记项在列表中的位置，选择不同的背景资源。
+      *
+      * @param data 笔记项数据对象
+      */
+     private void setBackground(NoteItemData data) {
+         // 获取笔记项的背景颜色 ID
+         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());
+         }
+     }
+ 
+     /**
+      * 获取当前笔记项的数据对象。
+      *
+      * @return 笔记项数据对象
+      */
+     public NoteItemData getItemData() {
+         return mItemData;
+     }
+ }

ui/NotesPreferenceActivity.java

@@ -0,0 +1,530 @@
+/*
+ * 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;
+ 
+ /**
+  * NotesPreferenceActivity 是一个用于管理笔记应用设置的活动类。
+  * 它允许用户设置同步账户、执行同步操作，并显示最后一次同步的时间。
+  */
+ 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;
+     // 用于接收 GTaskSyncService 广播的接收器
+     private GTaskReceiver mReceiver;
+     // 原始的 Google 账户数组
+     private Account[] mOriAccounts;
+     // 标记是否添加了新账户
+     private boolean mHasAddedAccount;
+ 
+     /**
+      * 活动创建时调用，进行初始化操作。
+      * @param icicle 保存的活动状态
+      */
+     @Override
+     protected void onCreate(Bundle icicle) {
+         super.onCreate(icicle);
+ 
+         // 设置应用图标可用于导航返回
+         getActionBar().setDisplayHomeAsUpEnabled(true);
+ 
+         // 从 XML 文件中加载偏好设置
+         addPreferencesFromResource(R.xml.preferences);
+         // 查找同步账户偏好类别
+         mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);
+         // 创建 GTask 广播接收器
+         mReceiver = new GTaskReceiver();
+         // 创建意图过滤器，监听 GTaskSyncService 的广播
+         IntentFilter filter = new IntentFilter();
+         filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME);
+         // 注册广播接收器
+         registerReceiver(mReceiver, filter);
+ 
+         // 初始化原始账户数组
+         mOriAccounts = null;
+         // 加载设置头部视图
+         View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null);
+         // 将头部视图添加到列表视图中
+         getListView().addHeaderView(header, null, true);
+     }
+ 
+     /**
+      * 活动恢复时调用，检查是否添加了新账户并刷新 UI。
+      */
+     @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;
+                     }
+                 }
+             }
+         }
+ 
+         // 刷新 UI
+         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)) {
+                         // 如果没有设置同步账户，显示选择账户的对话框
+                         showSelectAccountAlertDialog();
+                     } else {
+                         // 如果已经设置了同步账户，显示更改账户的确认对话框
+                         showChangeAccountConfirmAlertDialog();
+                     }
+                 } else {
+                     // 如果正在同步，显示提示信息
+                     Toast.makeText(NotesPreferenceActivity.this,
+                             R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
+                             .show();
+                 }
+                 return true;
+             }
+         });
+ 
+         // 将偏好项添加到同步账户偏好类别中
+         mAccountCategory.addPreference(accountPref);
+     }
+ 
+     /**
+      * 加载同步按钮和最后一次同步时间的显示。
+      */
+     private void loadSyncButton() {
+         // 查找同步按钮
+         Button syncButton = (Button) findViewById(R.id.preference_sync_button);
+         // 查找最后一次同步时间的文本视图
+         TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
+ 
+         // 根据同步状态设置按钮状态和文本
+         if (GTaskSyncService.isSyncing()) {
+             syncButton.setText(getString(R.string.preferences_button_sync_cancel));
+             syncButton.setOnClickListener(new View.OnClickListener() {
+                 public void onClick(View v) {
+                     // 取消同步操作
+                     GTaskSyncService.cancelSync(NotesPreferenceActivity.this);
+                 }
+             });
+         } else {
+             syncButton.setText(getString(R.string.preferences_button_sync_immediately));
+             syncButton.setOnClickListener(new View.OnClickListener() {
+                 public void onClick(View v) {
+                     // 立即开始同步操作
+                     GTaskSyncService.startSync(NotesPreferenceActivity.this);
+                 }
+             });
+            }
+         // 只有在设置了同步账户时，同步按钮才可用
+         syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this)));
+ 
+         // 根据同步状态设置最后一次同步时间的显示
+         if (GTaskSyncService.isSyncing()) {
+             lastSyncTimeView.setText(GTaskSyncService.getProgressString());
+             lastSyncTimeView.setVisibility(View.VISIBLE);
+         } else {
+             long lastSyncTime = getLastSyncTime(this);
+             if (lastSyncTime != 0) {
+                 lastSyncTimeView.setText(getString(R.string.preferences_last_sync_time,
+                         DateFormat.format(getString(R.string.preferences_last_sync_time_format),
+                                 lastSyncTime)));
+                 lastSyncTimeView.setVisibility(View.VISIBLE);
+             } else {
+                 lastSyncTimeView.setVisibility(View.GONE);
+             }
+         }
+     }
+ 
+     /**
+      * 刷新 UI，包括同步账户偏好和同步按钮。
+      */
+     private void refreshUI() {
+         loadAccountPreference();
+         loadSyncButton();
+     }
+ 
+     /**
+      * 显示选择账户的对话框。
+      */
+     private void showSelectAccountAlertDialog() {
+         // 创建一个 AlertDialog 构建器
+         AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
+ 
+         // 加载自定义标题视图
+         View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
+         // 查找标题文本视图
+         TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
+         // 设置标题文本
+         titleTextView.setText(getString(R.string.preferences_dialog_select_account_title));
+         // 查找副标题文本视图
+         TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
+         // 设置副标题文本
+         subtitleTextView.setText(getString(R.string.preferences_dialog_select_account_tips));
+ 
+         // 设置自定义标题
+         dialogBuilder.setCustomTitle(titleView);
+         // 设置确定按钮为空
+         dialogBuilder.setPositiveButton(null, null);
+ 
+         // 获取所有 Google 账户
+         Account[] accounts = getGoogleAccounts();
+         // 获取当前的默认同步账户名称
+         String defAccount = getSyncAccountName(this);
+ 
+         // 记录原始账户数组
+         mOriAccounts = accounts;
+         // 标记未添加新账户
+         mHasAddedAccount = false;
+ 
+         if (accounts.length > 0) {
+             // 创建账户名称数组
+             CharSequence[] items = new CharSequence[accounts.length];
+             final CharSequence[] itemMapping = items;
+             int checkedItem = -1;
+             int index = 0;
+             for (Account account : accounts) {
+                 if (TextUtils.equals(account.name, defAccount)) {
+                     checkedItem = index;
+                 }
+                 items[index++] = account.name;
+             }
+             // 设置单选列表项
+             dialogBuilder.setSingleChoiceItems(items, checkedItem,
+                     new DialogInterface.OnClickListener() {
+                         public void onClick(DialogInterface dialog, int which) {
+                             // 设置选择的账户为同步账户
+                             setSyncAccount(itemMapping[which].toString());
+                             // 关闭对话框
+                             dialog.dismiss();
+                             // 刷新 UI
+                             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 构建器
+         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) {
+                     // 选择移除账户，移除同步账户并刷新 UI
+                     removeSyncAccount();
+                     refreshUI();
+                 }
+             }
+         });
+         // 显示对话框
+         dialogBuilder.show();
+     }
+ 
+     /**
+      * 获取所有 Google 账户。
+      * @return Google 账户数组
+      */
+     private Account[] getGoogleAccounts() {
+         // 获取账户管理器
+         AccountManager accountManager = AccountManager.get(this);
+         // 获取所有 Google 账户
+         return accountManager.getAccountsByType("com.google");
+     }
+ 
+     /**
+      * 设置同步账户。
+      * @param account 要设置的账户名称
+      */
+     private void setSyncAccount(String account) {
+         if (!getSyncAccountName(this).equals(account)) {
+             // 获取共享偏好设置
+             SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
+             // 获取偏好编辑器
+             SharedPreferences.Editor editor = settings.edit();
+             if (account != null) {
+                 // 保存同步账户名称
+                 editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, account);
+             } else {
+                 // 清空同步账户名称
+                 editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
+             }
+             // 提交更改
+             editor.commit();
+ 
+             // 清空最后一次同步时间
+             setLastSyncTime(this, 0);
+ 
+             // 清理本地与 GTask 相关的信息
+             new Thread(new Runnable() {
+                 public void run() {
+                     // 创建内容值对象
+                     ContentValues values = new ContentValues();
+                     // 清空 GTask ID
+                     values.put(NoteColumns.GTASK_ID, "");
+                     // 清空同步 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 对象，使用私有模式，确保只有本应用可以访问这些设置
+    SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
+    // 获取 SharedPreferences 的编辑器，用于修改存储的设置
+    SharedPreferences.Editor editor = settings.edit();
+    // 检查 SharedPreferences 中是否包含同步账户名称的键
+    if (settings.contains(PREFERENCE_SYNC_ACCOUNT_NAME)) {
+        // 如果包含，则从编辑器中移除该键值对
+        editor.remove(PREFERENCE_SYNC_ACCOUNT_NAME);
+    }
+    // 检查 SharedPreferences 中是否包含最后同步时间的键
+    if (settings.contains(PREFERENCE_LAST_SYNC_TIME)) {
+        // 如果包含，则从编辑器中移除该键值对
+        editor.remove(PREFERENCE_LAST_SYNC_TIME);
+    }
+    // 提交编辑器中的修改，将更改保存到 SharedPreferences 中
+    editor.commit();
+
+    // 清理本地与 Google 任务（GTask）相关的信息，由于数据库操作可能会阻塞主线程，因此在新线程中执行
+    new Thread(new Runnable() {
+        public void run() {
+            // 创建一个 ContentValues 对象，用于存储要更新的数据
+            ContentValues values = new ContentValues();
+            // 将 GTask ID 字段设置为空字符串
+            values.put(NoteColumns.GTASK_ID, "");
+            // 将同步 ID 字段设置为 0
+            values.put(NoteColumns.SYNC_ID, 0);
+            // 使用 ContentResolver 更新 Notes 内容提供者中的笔记数据，将 GTask ID 和同步 ID 字段清空
+            getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
+        }
+    }).start();
+}
+
+// 获取当前设置的同步账户名称
+public static String getSyncAccountName(Context context) {
+    // 获取指定名称的 SharedPreferences 对象，使用私有模式
+    SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
+            Context.MODE_PRIVATE);
+    // 从 SharedPreferences 中获取同步账户名称，如果不存在则返回空字符串
+    return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
+}
+
+// 设置最后一次同步的时间
+public static void setLastSyncTime(Context context, long time) {
+    // 获取指定名称的 SharedPreferences 对象，使用私有模式
+    SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
+            Context.MODE_PRIVATE);
+    // 获取 SharedPreferences 的编辑器，用于修改存储的设置
+    SharedPreferences.Editor editor = settings.edit();
+    // 将最后同步时间存储到编辑器中
+    editor.putLong(PREFERENCE_LAST_SYNC_TIME, time);
+    // 提交编辑器中的修改，将更改保存到 SharedPreferences 中
+    editor.commit();
+}
+
+// 获取最后一次同步的时间
+public static long getLastSyncTime(Context context) {
+    // 获取指定名称的 SharedPreferences 对象，使用私有模式
+    SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
+            Context.MODE_PRIVATE);
+    // 从 SharedPreferences 中获取最后同步时间，如果不存在则返回 0
+    return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);
+}
+
+// 自定义广播接收器，用于接收 GTask 同步服务的广播
+private class GTaskReceiver extends BroadcastReceiver {
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        // 刷新界面，更新账户设置和同步按钮状态等信息
+        refreshUI();
+        // 检查广播意图中是否包含正在同步的标志，并且标志为 true
+        if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {
+            // 查找用于显示同步状态的 TextView 控件
+            TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
+            // 设置同步状态文本为广播意图中携带的进度消息
+            syncStatus.setText(intent
+                    .getStringExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_PROGRESS_MSG));
+        }
+    }
+}
+
+// 处理选项菜单的点击事件
+public boolean onOptionsItemSelected(MenuItem item) {
+    // 根据点击的菜单项 ID 进行不同的处理
+    switch (item.getItemId()) {
+        // 如果点击的是应用图标（即返回按钮）
+        case android.R.id.home:
+            // 创建一个意图，用于启动 NotesListActivity
+            Intent intent = new Intent(this, NotesListActivity.class);
+            // 添加标志，确保启动的 NotesListActivity 位于任务栈的顶部，并清除之前的所有活动
+            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+            // 启动 NotesListActivity
+            startActivity(intent);
+            // 返回 true 表示事件已处理
+            return true;
+        // 如果点击的是其他菜单项
+        default:
+            // 返回 false 表示事件未处理
+            return false;
+    }
+}