注释代码

Signed-off-by: 张建忠 <a17853992082@163.com>

源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/data/NotesProvider.java

@@ -50,6 +50,7 @@ public class NotesProvider extends ContentProvider {
     private static final int URI_SEARCH          = 5;
     private static final int URI_SEARCH_SUGGEST  = 6;
 
+<<<<<<< HEAD
     // 静态初始化块，用于在类加载时初始化静态资源
     static {
         // 创建一个UriMatcher对象，用于匹配URI，初始状态设置为NO_MATCH，表示没有匹配
@@ -71,6 +72,16 @@ public class NotesProvider extends ContentProvider {
         mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST);
         // 添加URI匹配规则，匹配"content://com.example.notes/search_suggest_query/*"路径，匹配码为URI_SEARCH_SUGGEST
         // 其中"*"表示任意字符串，用于匹配带有查询参数的搜索建议URI
+=======
+    static {
+        mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+        mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
+        mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM);
+        mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA);
+        mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM);
+        mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH);
+        mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST);
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", URI_SEARCH_SUGGEST);
     }
 

源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/tool/BackupUtils.java

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+<<<<<<< HEAD
 // 包声明，表明该类所属的包名，此处在net.micode.notes.ui包下
 package net.micode.notes.ui;
 
@@ -213,4 +214,334 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
             mPlayer = null;
         }
     }
-}
+}
+=======
+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;
+    }
+}
+
+
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee

源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/tool/DataUtils.java

@@ -14,7 +14,10 @@
  * limitations under the License.
  */
 
+<<<<<<< HEAD
 // 包声明，表明该类所属的包名为net.micode.notes.tool
+=======
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
 package net.micode.notes.tool;
 
 import android.content.ContentProviderOperation;
@@ -35,6 +38,7 @@ import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;
 import java.util.ArrayList;
 import java.util.HashSet;
 
+<<<<<<< HEAD
 // DataUtils工具类，提供了一系列用于操作笔记数据相关的实用方法
 public class DataUtils {
     // 用于日志记录的标签，方便在日志中识别该类输出的相关信息
@@ -43,16 +47,26 @@ public class DataUtils {
     // 批量删除笔记的方法，根据给定的ContentResolver和要删除笔记的ID集合来执行删除操作
     public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
         // 如果传入的ID集合为null，记录日志并返回true（可能表示无需进行删除操作的情况）
+=======
+
+public class DataUtils {
+    public static final String TAG = "DataUtils";
+    public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         if (ids == null) {
             Log.d(TAG, "the ids is null");
             return true;
         }
+<<<<<<< HEAD
         // 如果ID集合为空，记录日志并返回true（表示没有实际要删除的笔记）
+=======
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         if (ids.size() == 0) {
             Log.d(TAG, "no id is in the hashset");
             return true;
         }
 
+<<<<<<< HEAD
         // 创建一个用于存储内容提供器操作的列表，后续将批量执行这些操作来删除笔记
         ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
         // 遍历要删除的笔记ID集合
@@ -73,10 +87,25 @@ public class DataUtils {
             // 通过ContentResolver批量执行操作列表中的删除操作，并获取操作结果数组
             ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
             // 如果结果数组为null，或者长度为0，或者第一个结果为null，表示删除笔记失败，记录日志并返回false
+=======
+        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);
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
             if (results == null || results.length == 0 || results[0] == null) {
                 Log.d(TAG, "delete notes failed, ids:" + ids.toString());
                 return false;
             }
+<<<<<<< HEAD
             // 如果成功执行删除操作，返回true
             return true;
         } catch (RemoteException e) {
@@ -84,11 +113,18 @@ public class DataUtils {
             Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
         } catch (OperationApplicationException e) {
             // 如果在应用操作过程中出现异常（比如操作不符合要求等），记录详细的异常信息到日志
+=======
+            return true;
+        } catch (RemoteException e) {
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        } catch (OperationApplicationException e) {
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
             Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
         }
         return false;
     }
 
+<<<<<<< HEAD
     // 将指定笔记移动到指定文件夹的方法，通过更新笔记的相关字段来实现移动操作
     public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
         // 创建一个ContentValues对象，用于存储要更新的列和对应的值
@@ -107,11 +143,24 @@ public class DataUtils {
     public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids,
             long folderId) {
         // 如果传入的笔记ID集合为null，记录日志并返回true（可能表示无需进行移动操作的情况）
+=======
+    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) {
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         if (ids == null) {
             Log.d(TAG, "the ids is null");
             return true;
         }
 
+<<<<<<< HEAD
         // 创建一个用于存储内容提供器操作的列表，后续将批量执行这些操作来移动笔记
         ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
         // 遍历要移动的笔记ID集合
@@ -124,17 +173,30 @@ public class DataUtils {
             // 设置本地修改标志，可能表示该笔记在本地有过修改操作
             builder.withValue(NoteColumns.LOCAL_MODIFIED, 1);
             // 将构建好的操作添加到操作列表中
+=======
+        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);
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
             operationList.add(builder.build());
         }
 
         try {
+<<<<<<< HEAD
             // 通过ContentResolver批量执行操作列表中的更新操作，并获取操作结果数组
             ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
             // 如果结果数组为null，或者长度为0，或者第一个结果为null，表示移动笔记失败，记录日志并返回false
+=======
+            ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
             if (results == null || results.length == 0 || results[0] == null) {
                 Log.d(TAG, "delete notes failed, ids:" + ids.toString());
                 return false;
             }
+<<<<<<< HEAD
             // 如果成功执行移动操作，返回true
             return true;
         } catch (RemoteException e) {
@@ -142,12 +204,19 @@ public class DataUtils {
             Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
         } catch (OperationApplicationException e) {
             // 如果在应用操作过程中出现异常（比如操作不符合要求等），记录详细的异常信息到日志
+=======
+            return true;
+        } catch (RemoteException e) {
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        } catch (OperationApplicationException e) {
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
             Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
         }
         return false;
     }
 
     /**
+<<<<<<< HEAD
      * 获取除系统文件夹（参考Notes#TYPE_SYSTEM）之外的所有文件夹数量的方法
      */
     public static int getUserFolderCount(ContentResolver resolver) {
@@ -155,12 +224,19 @@ public class DataUtils {
         // 查询的列只需要计数结果，所以使用"COUNT(*)"
         // 查询条件是类型为文件夹（NoteColumns.TYPE对应的是文件夹类型）且父文件夹ID不是回收站文件夹ID
         Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
+=======
+     * 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,
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
                 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;
+<<<<<<< HEAD
         // 如果游标不为null，表示查询到了结果
         if (cursor!= null) {
             // 将游标移动到第一条记录（因为只有一条计数结果记录）
@@ -173,6 +249,15 @@ public class DataUtils {
                     Log.e(TAG, "get folder count failed:" + e.toString());
                 } finally {
                     // 关闭游标，释放资源
+=======
+        if(cursor != null) {
+            if(cursor.moveToFirst()) {
+                try {
+                    count = cursor.getInt(0);
+                } catch (IndexOutOfBoundsException e) {
+                    Log.e(TAG, "get folder count failed:" + e.toString());
+                } finally {
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
                     cursor.close();
                 }
             }
@@ -180,9 +265,13 @@ public class DataUtils {
         return count;
     }
 
+<<<<<<< HEAD
     // 判断指定笔记在笔记数据库中是否可见（根据特定条件，比如不在回收站等）的方法
     public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
         // 通过ContentResolver查询指定笔记的记录，查询条件是类型为指定类型且父文件夹ID不是回收站文件夹ID
+=======
+    public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
                 null,
                 NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER,
@@ -190,6 +279,7 @@ public class DataUtils {
                 null);
 
         boolean exist = false;
+<<<<<<< HEAD
         // 如果游标不为null，表示查询到了结果
         if (cursor!= null) {
             // 如果查询到的记录数量大于0，表示该笔记存在且符合可见条件，设置exist为true
@@ -197,18 +287,29 @@ public class DataUtils {
                 exist = true;
             }
             // 关闭游标，释放资源
+=======
+        if (cursor != null) {
+            if (cursor.getCount() > 0) {
+                exist = true;
+            }
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
             cursor.close();
         }
         return exist;
     }
 
+<<<<<<< HEAD
     // 判断指定笔记在笔记数据库中是否存在的方法（简单查询是否有对应记录）
     public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
         // 通过ContentResolver查询指定笔记的记录，不设置额外的查询条件
+=======
+    public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
                 null, null, null, null);
 
         boolean exist = false;
+<<<<<<< HEAD
         // 如果游标不为null，表示查询到了结果
         if (cursor!= null) {
             // 如果查询到的记录数量大于0，表示该笔记存在，设置exist为true
@@ -216,18 +317,29 @@ public class DataUtils {
                 exist = true;
             }
             // 关闭游标，释放资源
+=======
+        if (cursor != null) {
+            if (cursor.getCount() > 0) {
+                exist = true;
+            }
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
             cursor.close();
         }
         return exist;
     }
 
+<<<<<<< HEAD
     // 判断指定数据（可能是某种关联数据等）在数据数据库中是否存在的方法（简单查询是否有对应记录）
     public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
         // 通过ContentResolver查询指定数据的记录，不设置额外的查询条件
+=======
+    public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId),
                 null, null, null, null);
 
         boolean exist = false;
+<<<<<<< HEAD
         // 如果游标不为null，表示查询到了结果
         if (cursor!= null) {
             // 如果查询到的记录数量大于0，表示该数据存在，设置exist为true
@@ -239,12 +351,25 @@ public class DataUtils {
     // 检查指定名称的文件夹在数据库中是否可见（根据特定条件，如不在回收站且名称匹配等）的方法
     public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
         // 通过ContentResolver查询符合条件的文件夹记录，查询条件是类型为文件夹、父文件夹ID不是回收站文件夹ID且摘要（可能是名称相关字段）匹配指定名称
+=======
+        if (cursor != null) {
+            if (cursor.getCount() > 0) {
+                exist = true;
+            }
+            cursor.close();
+        }
+        return exist;
+    }
+
+    public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         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;
+<<<<<<< HEAD
         // 如果游标不为null，表示查询到了结果
         if (cursor!= null) {
             // 如果查询到的记录数量大于0，表示存在符合条件的文件夹，设置exist为true
@@ -252,14 +377,24 @@ public class DataUtils {
                 exist = true;
             }
             // 关闭游标，释放资源
+=======
+        if(cursor != null) {
+            if(cursor.getCount() > 0) {
+                exist = true;
+            }
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
             cursor.close();
         }
         return exist;
     }
 
+<<<<<<< HEAD
     // 获取指定文件夹下所有笔记对应的小部件相关属性集合的方法（可能用于展示小部件相关信息等）
     public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
         // 通过ContentResolver查询指定文件夹下笔记的小部件ID和小部件类型信息
+=======
+    public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
                 new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE },
                 NoteColumns.PARENT_ID + "=?",
@@ -267,13 +402,18 @@ public class DataUtils {
                 null);
 
         HashSet<AppWidgetAttribute> set = null;
+<<<<<<< HEAD
         // 如果游标不为null，表示查询到了结果
         if (c!= null) {
             // 将游标移动到第一条记录
+=======
+        if (c != null) {
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
             if (c.moveToFirst()) {
                 set = new HashSet<AppWidgetAttribute>();
                 do {
                     try {
+<<<<<<< HEAD
                         // 创建一个AppWidgetAttribute对象，用于存储小部件相关属性
                         AppWidgetAttribute widget = new AppWidgetAttribute();
                         // 从游标中获取小部件ID并赋值给widget对象
@@ -284,26 +424,41 @@ public class DataUtils {
                         set.add(widget);
                     } catch (IndexOutOfBoundsException e) {
                         // 如果获取数据出现越界异常，记录详细的异常信息到日志
+=======
+                        AppWidgetAttribute widget = new AppWidgetAttribute();
+                        widget.widgetId = c.getInt(0);
+                        widget.widgetType = c.getInt(1);
+                        set.add(widget);
+                    } catch (IndexOutOfBoundsException e) {
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
                         Log.e(TAG, e.toString());
                     }
                 } while (c.moveToNext());
             }
+<<<<<<< HEAD
             // 关闭游标，释放资源
+=======
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
             c.close();
         }
         return set;
     }
 
+<<<<<<< HEAD
     // 根据笔记ID获取对应的电话号码的方法（可能是与笔记关联的电话号码）
     public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
         // 通过ContentResolver查询指定笔记关联的数据表（可能是通话记录相关的数据表），获取电话号码列的值
         // 查询条件是笔记ID匹配且MIME类型匹配（可能用于确定数据类型）
+=======
+    public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         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);
 
+<<<<<<< HEAD
         if (cursor!= null && cursor.moveToFirst()) {
             try {
                 // 如果查询到结果且游标移动到第一条记录，获取电话号码字符串并返回
@@ -313,16 +468,28 @@ public class DataUtils {
                 Log.e(TAG, "Get call number fails " + e.toString());
             } finally {
                 // 关闭游标，释放资源
+=======
+        if (cursor != null && cursor.moveToFirst()) {
+            try {
+                return cursor.getString(0);
+            } catch (IndexOutOfBoundsException e) {
+                Log.e(TAG, "Get call number fails " + e.toString());
+            } finally {
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
                 cursor.close();
             }
         }
         return "";
     }
 
+<<<<<<< HEAD
     // 根据电话号码和通话日期获取对应的笔记ID的方法（可能用于反向查找关联笔记）
     public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
         // 通过ContentResolver查询指定数据表（可能是通话记录相关的数据表），获取笔记ID列的值
         // 查询条件是通话日期匹配、MIME类型匹配且电话号码匹配（通过自定义函数PHONE_NUMBERS_EQUAL判断）
+=======
+    public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
                 new String [] { CallNote.NOTE_ID },
                 CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL("
@@ -330,6 +497,7 @@ public class DataUtils {
                 new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber },
                 null);
 
+<<<<<<< HEAD
         if (cursor!= null) {
             if (cursor.moveToFirst()) {
                 try {
@@ -341,9 +509,51 @@ public class DataUtils {
                 }
             }
             // 关闭游标，释放资源
+=======
+        if (cursor != null) {
+            if (cursor.moveToFirst()) {
+                try {
+                    return cursor.getLong(0);
+                } catch (IndexOutOfBoundsException e) {
+                    Log.e(TAG, "Get call note id fails " + e.toString());
+                }
+            }
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
             cursor.close();
         }
         return 0;
     }
 
-    // 根据笔记ID获取对应的摘要信息的方法
+<<<<<<< HEAD
+    // 根据笔记ID获取对应的摘要信息的方法
+=======
+    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;
+    }
+}
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee

源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/tool/GTaskStringUtils.java

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+<<<<<<< HEAD
 // 包声明，表明该类所属的包名为net.micode.notes.tool
 package net.micode.notes.tool;
 
@@ -200,4 +201,103 @@ public class GTaskStringUtils {
     // 表示元数据中笔记名称相关的特定字符串常量，通常用于给出一个提示信息，
     // 告知不要对这类特殊的元数据笔记进行更新和删除操作等情况
     public final static String META_NOTE_NAME = "[META INFO] DON'T UPDATE AND DELETE";
-}
+}
+=======
+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";
+
+}
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee

源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/tool/ResourceParser.java

@@ -14,7 +14,10 @@
  * limitations under the License.
  */
 
+<<<<<<< HEAD
 // 包声明，表明该类所属的包名为net.micode.notes.tool
+=======
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
 package net.micode.notes.tool;
 
 import android.content.Context;
@@ -23,6 +26,7 @@ import android.preference.PreferenceManager;
 import net.micode.notes.R;
 import net.micode.notes.ui.NotesPreferenceActivity;
 
+<<<<<<< HEAD
 // ResourceParser类，从名称来看是一个资源解析相关的工具类，用于获取和处理各种与界面显示相关的资源（如颜色、背景图片、字体样式等资源的相关操作）
 public class ResourceParser {
 
@@ -66,16 +70,56 @@ public class ResourceParser {
         };
 
         // 根据传入的颜色标识ID（对应前面定义的颜色常量）获取笔记编辑页面的背景图片资源ID，方便在代码中设置对应的背景图片资源
+=======
+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
+        };
+
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         public static int getNoteBgResource(int id) {
             return BG_EDIT_RESOURCES[id];
         }
 
+<<<<<<< HEAD
         // 根据传入的颜色标识ID（对应前面定义的颜色常量）获取笔记编辑页面标题的背景图片资源ID，方便在代码中设置对应的标题背景图片资源
+=======
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         public static int getNoteTitleBgResource(int id) {
             return BG_EDIT_TITLE_RESOURCES[id];
         }
     }
 
+<<<<<<< HEAD
     // 根据给定的上下文（Context）获取默认的背景颜色标识ID，判断逻辑基于用户在偏好设置（Preference）中是否设置了特定的背景颜色相关选项
     public static int getDefaultBgId(Context context) {
         // 通过PreferenceManager获取默认的共享偏好设置对象，然后检查是否设置了特定的背景颜色设置键对应的布尔值（可能表示用户是否手动设置过背景颜色）
@@ -85,10 +129,18 @@ public class ResourceParser {
             return (int) (Math.random() * NoteBgResources.BG_EDIT_RESOURCES.length);
         } else {
             // 如果用户没有设置过，返回默认的背景颜色标识ID（即前面定义的BG_DEFAULT_COLOR）
+=======
+    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 {
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
             return BG_DEFAULT_COLOR;
         }
     }
 
+<<<<<<< HEAD
     // 内部静态类NoteItemBgResources，用于管理笔记列表项相关的背景资源（如不同位置的列表项背景图片资源等），同样将相关资源的获取逻辑封装在内部类中，便于代码的组织和维护
     public static class NoteItemBgResources {
         // 定义一个私有的静态整数数组，用于存储列表项第一个元素（比如列表中第一个笔记项）的背景图片资源ID，每个元素对应一种颜色（顺序与前面定义的颜色常量对应）的对应背景图片资源
@@ -128,31 +180,79 @@ public class ResourceParser {
         };
 
         // 根据传入的颜色标识ID（对应前面定义的颜色常量）获取列表项第一个元素的背景图片资源ID，方便在代码中设置对应的背景图片资源
+=======
+    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
+        };
+
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         public static int getNoteBgFirstRes(int id) {
             return BG_FIRST_RESOURCES[id];
         }
 
+<<<<<<< HEAD
         // 根据传入的颜色标识ID（对应前面定义的颜色常量）获取列表项最后一个元素的背景图片资源ID，方便在代码中设置对应的背景图片资源
+=======
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         public static int getNoteBgLastRes(int id) {
             return BG_LAST_RESOURCES[id];
         }
 
+<<<<<<< HEAD
         // 根据传入的颜色标识ID（对应前面定义的颜色常量）获取列表项单独存在时的背景图片资源ID，方便在代码中设置对应的背景图片资源
+=======
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         public static int getNoteBgSingleRes(int id) {
             return BG_SINGLE_RESOURCES[id];
         }
 
+<<<<<<< HEAD
         // 根据传入的颜色标识ID（对应前面定义的颜色常量）获取列表项中间元素的背景图片资源ID，方便在代码中设置对应的背景图片资源
+=======
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         public static int getNoteBgNormalRes(int id) {
             return BG_NORMAL_RESOURCES[id];
         }
 
+<<<<<<< HEAD
         // 获取文件夹的背景图片资源ID，这里固定返回一个表示文件夹背景图片的资源ID（可能所有文件夹使用相同的背景图片样式）
+=======
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         public static int getFolderBgRes() {
             return R.drawable.list_folder;
         }
     }
 
+<<<<<<< HEAD
     // 内部静态类WidgetBgResources，用于管理小部件相关的背景资源（如不同尺寸小部件的背景图片资源等），将相关资源的获取逻辑封装在内部类中，以更好地组织代码结构
     public static class WidgetBgResources {
         // 定义一个私有的静态整数数组，用于存储2倍尺寸小部件的背景图片资源ID，每个元素对应一种颜色（顺序与前面定义的颜色常量对应）的对应背景图片资源
@@ -165,10 +265,22 @@ public class ResourceParser {
         };
 
         // 根据传入的颜色标识ID（对应前面定义的颜色常量）获取2倍尺寸小部件的背景图片资源ID，方便在代码中设置对应的小部件背景图片资源
+=======
+    public static class WidgetBgResources {
+        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,
+        };
+
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         public static int getWidget2xBgResource(int id) {
             return BG_2X_RESOURCES[id];
         }
 
+<<<<<<< HEAD
         // 定义一个私有的静态整数数组，用于存储4倍尺寸小部件的背景图片资源ID，每个元素对应一种颜色（顺序与前面定义的颜色常量对应）的对应背景图片资源
         private final static int[] BG_4X_RESOURCES = new int[]{
                 R.drawable.widget_4x_yellow,
@@ -179,11 +291,22 @@ public class ResourceParser {
         };
 
         // 根据传入的颜色标识ID（对应前面定义的颜色常量）获取4倍尺寸小部件的背景图片资源ID，方便在代码中设置对应的小部件背景图片资源
+=======
+        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
+        };
+
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         public static int getWidget4xBgResource(int id) {
             return BG_4X_RESOURCES[id];
         }
     }
 
+<<<<<<< HEAD
     // 内部静态类TextAppearanceResources，用于管理文本外观相关的资源（如不同字体大小对应的样式资源等），将相关资源的获取逻辑封装在内部类中，使代码结构更清晰易读
     public static class TextAppearanceResources {
         // 定义一个私有的静态整数数组，用于存储不同字体大小对应的文本外观样式资源ID，每个元素对应一种字体大小级别（顺序与前面定义的字体大小常量对应）的对应样式资源
@@ -195,6 +318,16 @@ public class ResourceParser {
         };
 
         // 根据传入的字体大小标识ID（对应前面定义的字体大小常量）获取对应的文本外观样式资源ID，同时处理了ID超出资源数组长度的情况（可能是由于数据异常等原因），此时返回默认的字体大小对应的资源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
+        };
+
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         public static int getTexAppearanceResource(int id) {
             /**
              * HACKME: Fix bug of store the resource id in shared preference.
@@ -207,9 +340,16 @@ public class ResourceParser {
             return TEXTAPPEARANCE_RESOURCES[id];
         }
 
+<<<<<<< HEAD
         // 获取文本外观样式资源数组的长度，可用于判断传入的字体大小标识ID是否越界等情况，也便于在其他相关逻辑中了解资源的数量情况
+=======
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
         public static int getResourcesSize() {
             return TEXTAPPEARANCE_RESOURCES.length;
         }
     }
-}
+<<<<<<< HEAD
+}
+=======
+}
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee

源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/ui/AlarmAlertActivity.java

@@ -14,7 +14,10 @@
  * limitations under the License.
  */
 
+<<<<<<< HEAD
 // 包声明，表明该类属于net.micode.notes.ui包，通常用于存放与用户界面相关的类
+=======
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
 package net.micode.notes.ui;
 
 import android.app.Activity;
@@ -40,6 +43,7 @@ import net.micode.notes.tool.DataUtils;
 
 import java.io.IOException;
 
+<<<<<<< HEAD
 // AlarmAlertActivity类继承自Activity类，意味着它是一个安卓中的Activity，用于展示用户界面。
 // 同时实现了OnClickListener和OnDismissListener接口，用于处理对话框的点击和关闭事件
 public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener {
@@ -69,12 +73,31 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
         if (!isScreenOn()) {
             // 给窗口添加一系列标志位，用于确保屏幕在必要时亮起、保持常亮，并且允许在屏幕锁定时进行相关操作，
             // 同时设置布局相关的装饰属性，以保证界面能正确显示
+=======
+
+public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener {
+    private long mNoteId;
+    private String mSnippet;
+    private static final int SNIPPET_PREW_MAX_LEN = 60;
+    MediaPlayer mPlayer;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+
+        final Window win = getWindow();
+        win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
+
+        if (!isScreenOn()) {
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
             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);
         }
 
+<<<<<<< HEAD
         // 获取启动该Activity的Intent对象，Intent中可能携带了与提醒相关的数据，比如笔记的相关信息等
         Intent intent = getIntent();
 
@@ -90,10 +113,22 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
             // 则进行截断处理，截取前60个字符，并添加一个特定的提示字符串（从资源文件中获取），否则保持原摘要信息不变
         } catch (IllegalArgumentException e) {
             // 如果在解析笔记ID或者获取摘要信息过程中出现参数异常（比如格式不正确等原因），打印异常堆栈信息，并直接返回，不再执行后续操作
+=======
+        Intent intent = getIntent();
+
+        try {
+            mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1));
+            mSnippet = DataUtils.getSnippetById(this.getContentResolver(), mNoteId);
+            mSnippet = mSnippet.length() > SNIPPET_PREW_MAX_LEN ? mSnippet.substring(0,
+                    SNIPPET_PREW_MAX_LEN) + getResources().getString(R.string.notelist_string_info)
+                    : mSnippet;
+        } catch (IllegalArgumentException e) {
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
             e.printStackTrace();
             return;
         }
 
+<<<<<<< HEAD
         // 创建一个MediaPlayer实例，用于后续播放提醒声音
         mPlayer = new MediaPlayer();
         // 通过DataUtils工具类判断该笔记在笔记数据库中是否可见（可能涉及是否被删除、是否处于有效状态等条件判断），
@@ -105,10 +140,18 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
             playAlarmSound();
         } else {
             // 如果笔记不可见，直接结束当前Activity，意味着不需要展示提醒相关的界面了
+=======
+        mPlayer = new MediaPlayer();
+        if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) {
+            showActionDialog();
+            playAlarmSound();
+        } else {
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
             finish();
         }
     }
 
+<<<<<<< HEAD
     // 私有方法，用于判断屏幕是否处于开启状态
     private boolean isScreenOn() {
         // 获取系统的电源管理服务对象，用于查询屏幕的电源状态等信息
@@ -155,10 +198,45 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
             e.printStackTrace();
         } catch (IOException e) {
             // 如果在读取数据源等IO操作过程中出现异常（比如音频文件损坏、无法读取等原因），打印异常堆栈信息
+=======
+    private boolean isScreenOn() {
+        PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
+        return pm.isScreenOn();
+    }
+
+    private void playAlarmSound() {
+        Uri url = RingtoneManager.getActualDefaultRingtoneUri(this, RingtoneManager.TYPE_ALARM);
+
+        int silentModeStreams = Settings.System.getInt(getContentResolver(),
+                Settings.System.MODE_RINGER_STREAMS_AFFECTED, 0);
+
+        if ((silentModeStreams & (1 << AudioManager.STREAM_ALARM)) != 0) {
+            mPlayer.setAudioStreamType(silentModeStreams);
+        } else {
+            mPlayer.setAudioStreamType(AudioManager.STREAM_ALARM);
+        }
+        try {
+            mPlayer.setDataSource(this, url);
+            mPlayer.prepare();
+            mPlayer.setLooping(true);
+            mPlayer.start();
+        } catch (IllegalArgumentException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        } catch (IllegalStateException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        } catch (IOException e) {
+            // TODO Auto-generated catch block
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
             e.printStackTrace();
         }
     }
 
+<<<<<<< HEAD
     // 私有方法，用于创建并显示操作对话框，给用户提供相应的操作选项，比如确认、进入编辑等操作
     private void showActionDialog() {
         // 创建一个AlertDialog的构建器对象，用于方便地构建AlertDialog对话框
@@ -191,6 +269,25 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
                 // 通过Intent的额外数据传递机制，将笔记的ID传递给目标Activity（NoteEditActivity），以便目标Activity能获取并处理对应的笔记
                 intent.putExtra(Intent.EXTRA_UID, mNoteId);
                 // 启动目标Activity，跳转到对应的笔记编辑界面
+=======
+    private void showActionDialog() {
+        AlertDialog.Builder dialog = new AlertDialog.Builder(this);
+        dialog.setTitle(R.string.app_name);
+        dialog.setMessage(mSnippet);
+        dialog.setPositiveButton(R.string.notealert_ok, this);
+        if (isScreenOn()) {
+            dialog.setNegativeButton(R.string.notealert_enter, this);
+        }
+        dialog.show().setOnDismissListener(this);
+    }
+
+    public void onClick(DialogInterface dialog, int which) {
+        switch (which) {
+            case DialogInterface.BUTTON_NEGATIVE:
+                Intent intent = new Intent(this, NoteEditActivity.class);
+                intent.setAction(Intent.ACTION_VIEW);
+                intent.putExtra(Intent.EXTRA_UID, mNoteId);
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
                 startActivity(intent);
                 break;
             default:
@@ -198,6 +295,7 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
         }
     }
 
+<<<<<<< HEAD
     // 实现OnDismissListener接口的方法，当对话框关闭时会被调用，用于执行对话框关闭后的相关操作
     public void onDismiss(DialogInterface dialog) {
         // 调用stopAlarmSound方法停止播放提醒声音，并释放相关的资源，如MediaPlayer占用的内存等
@@ -217,4 +315,19 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
             mPlayer = null;
         }
     }
-}
+}
+=======
+    public void onDismiss(DialogInterface dialog) {
+        stopAlarmSound();
+        finish();
+    }
+
+    private void stopAlarmSound() {
+        if (mPlayer != null) {
+            mPlayer.stop();
+            mPlayer.release();
+            mPlayer = null;
+        }
+    }
+}
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee

源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/ui/AlarmInitReceiver.java

@@ -14,7 +14,10 @@
  * limitations under the License.
  */
 
+<<<<<<< HEAD
 // 包声明，表明该类属于net.micode.notes.ui包，通常与应用的用户界面相关模块放在一起，不过从类名来看，这个类更偏向于处理提醒相关的逻辑，属于UI层与业务逻辑交互的部分
+=======
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
 package net.micode.notes.ui;
 
 import android.app.AlarmManager;
@@ -28,6 +31,7 @@ import android.database.Cursor;
 import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
 
+<<<<<<< HEAD
 // AlarmInitReceiver类继承自BroadcastReceiver，用于接收系统广播消息，在这里可能是用于处理与提醒初始化相关的广播事件
 public class AlarmInitReceiver extends BroadcastReceiver {
 
@@ -88,4 +92,42 @@ public class AlarmInitReceiver extends BroadcastReceiver {
             c.close();
         }
     }
-}
+}
+=======
+
+public class AlarmInitReceiver extends BroadcastReceiver {
+
+    private static final String [] PROJECTION = new String [] {
+        NoteColumns.ID,
+        NoteColumns.ALERTED_DATE
+    };
+
+    private static final int COLUMN_ID                = 0;
+    private static final int COLUMN_ALERTED_DATE      = 1;
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        long currentDate = System.currentTimeMillis();
+        Cursor c = context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
+                PROJECTION,
+                NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE,
+                new String[] { String.valueOf(currentDate) },
+                null);
+
+        if (c != null) {
+            if (c.moveToFirst()) {
+                do {
+                    long alertDate = c.getLong(COLUMN_ALERTED_DATE);
+                    Intent sender = new Intent(context, AlarmReceiver.class);
+                    sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(COLUMN_ID)));
+                    PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, 0);
+                    AlarmManager alermManager = (AlarmManager) context
+                            .getSystemService(Context.ALARM_SERVICE);
+                    alermManager.set(AlarmManager.RTC_WAKEUP, alertDate, pendingIntent);
+                } while (c.moveToNext());
+            }
+            c.close();
+        }
+    }
+}
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee

源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/ui/AlarmReceiver.java

@@ -14,13 +14,17 @@
  * limitations under the License.
  */
 
+<<<<<<< HEAD
 // 包声明，表明该类所属的包名为net.micode.notes.ui，通常用于存放与应用用户界面相关的各类组件等代码
+=======
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
 package net.micode.notes.ui;
 
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 
+<<<<<<< HEAD
 // AlarmReceiver类继承自BroadcastReceiver，BroadcastReceiver用于接收系统或应用发出的广播消息，
 // 这里的AlarmReceiver大概率是专门用于接收与闹钟提醒相关广播的类，进而做出相应的响应操作
 public class AlarmReceiver extends BroadcastReceiver {
@@ -41,4 +45,14 @@ public class AlarmReceiver extends BroadcastReceiver {
         // 这样就会从广播接收逻辑跳转到对应的提醒界面展示逻辑，完成闹钟提醒触发后展示提醒界面的流程
         context.startActivity(intent);
     }
-}
+}
+=======
+public class AlarmReceiver extends BroadcastReceiver {
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        intent.setClass(context, AlarmAlertActivity.class);
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        context.startActivity(intent);
+    }
+}
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee

源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider.java

@@ -14,9 +14,13 @@
  * limitations under the License.
  */
 
+<<<<<<< HEAD
 // 包声明，表明该类所属的包名为net.micode.notes.widget，通常用于存放与桌面小部件（Widget）相关的代码逻辑
 package net.micode.notes.widget;
 
+=======
+package net.micode.notes.widget;
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
 import android.app.PendingIntent;
 import android.appwidget.AppWidgetManager;
 import android.appwidget.AppWidgetProvider;
@@ -34,6 +38,7 @@ import net.micode.notes.tool.ResourceParser;
 import net.micode.notes.ui.NoteEditActivity;
 import net.micode.notes.ui.NotesListActivity;
 
+<<<<<<< HEAD
 // NoteWidgetProvider类继承自AppWidgetProvider，是安卓中用于创建桌面小部件的基类，这里定义为抽象类，意味着它需要被具体的子类继承并实现一些抽象方法
 public abstract class NoteWidgetProvider extends AppWidgetProvider {
 
@@ -74,19 +79,54 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
     }
 
     // 私有方法，用于根据给定的小部件ID从数据库中获取该小部件相关的笔记信息（如笔记ID、背景颜色、摘要等），返回一个游标（Cursor）对象用于遍历查询结果
+=======
+public abstract class NoteWidgetProvider extends AppWidgetProvider {
+    public static final String [] PROJECTION = new String [] {
+        NoteColumns.ID,
+        NoteColumns.BG_COLOR_ID,
+        NoteColumns.SNIPPET
+    };
+
+    public static final int COLUMN_ID           = 0;
+    public static final int COLUMN_BG_COLOR_ID  = 1;
+    public static final int COLUMN_SNIPPET      = 2;
+
+    private static final String TAG = "NoteWidgetProvider";
+
+    @Override
+    public void onDeleted(Context context, int[] appWidgetIds) {
+        ContentValues values = new ContentValues();
+        values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
+        for (int i = 0; i < appWidgetIds.length; i++) {
+            context.getContentResolver().update(Notes.CONTENT_NOTE_URI,
+                    values,
+                    NoteColumns.WIDGET_ID + "=?",
+                    new String[] { String.valueOf(appWidgetIds[i])});
+        }
+    }
+
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
     private Cursor getNoteWidgetInfo(Context context, int widgetId) {
         return context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
                 PROJECTION,
                 NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?",
+<<<<<<< HEAD
                 new String[]{String.valueOf(widgetId), String.valueOf(Notes.ID_TRASH_FOLER)},
                 null);
     }
 
     // 受保护的方法，用于更新小部件的显示内容，它调用了另一个重载的update方法，并传入默认的隐私模式参数（false）
+=======
+                new String[] { String.valueOf(widgetId), String.valueOf(Notes.ID_TRASH_FOLER) },
+                null);
+    }
+
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
     protected void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
         update(context, appWidgetManager, appWidgetIds, false);
     }
 
+<<<<<<< HEAD
     // 私有方法，用于实际更新小部件的显示内容，根据传入的小部件ID数组，逐个更新对应的小部件显示情况，同时可以根据隐私模式参数进行不同的显示设置
     private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds,
                         boolean privacyMode) {
@@ -110,11 +150,27 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
                 Cursor c = getNoteWidgetInfo(context, appWidgetIds[i]);
                 if (c!= null && c.moveToFirst()) {
                     // 如果查询到的笔记记录数量大于1，说明存在多条笔记对应同一个小部件ID的异常情况，记录错误日志并关闭游标，直接返回，不进行后续更新操作
+=======
+    private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds,
+            boolean privacyMode) {
+        for (int i = 0; i < appWidgetIds.length; i++) {
+            if (appWidgetIds[i] != AppWidgetManager.INVALID_APPWIDGET_ID) {
+                int bgId = ResourceParser.getDefaultBgId(context);
+                String snippet = "";
+                Intent intent = new Intent(context, NoteEditActivity.class);
+                intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
+                intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]);
+                intent.putExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, getWidgetType());
+
+                Cursor c = getNoteWidgetInfo(context, appWidgetIds[i]);
+                if (c != null && c.moveToFirst()) {
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
                     if (c.getCount() > 1) {
                         Log.e(TAG, "Multiple message with same widget id:" + appWidgetIds[i]);
                         c.close();
                         return;
                     }
+<<<<<<< HEAD
                     // 获取笔记的摘要信息，从游标中根据之前定义的列索引（COLUMN_SNIPPET）获取对应的数据
                     snippet = c.getString(COLUMN_SNIPPET);
                     // 获取笔记对应的背景颜色ID，从游标中根据列索引（COLUMN_BG_COLOR_ID）获取对应的数据，并更新之前获取的默认背景颜色ID
@@ -155,18 +211,52 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
                     // 如果不处于隐私模式，设置小部件文本显示的内容为之前获取或设置的笔记摘要信息
                     rv.setTextViewText(R.id.widget_text, snippet);
                     // 创建一个PendingIntent，用于启动之前设置的Intent对应的Activity（根据不同情况可能是编辑页面、查看页面等）
+=======
+                    snippet = c.getString(COLUMN_SNIPPET);
+                    bgId = c.getInt(COLUMN_BG_COLOR_ID);
+                    intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID));
+                    intent.setAction(Intent.ACTION_VIEW);
+                } else {
+                    snippet = context.getResources().getString(R.string.widget_havenot_content);
+                    intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
+                }
+
+                if (c != null) {
+                    c.close();
+                }
+
+                RemoteViews rv = new RemoteViews(context.getPackageName(), getLayoutId());
+                rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId));
+                intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId);
+                /**
+                 * Generate the pending intent to start host for the widget
+                 */
+                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);
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
                     pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], intent,
                             PendingIntent.FLAG_UPDATE_CURRENT);
                 }
 
+<<<<<<< HEAD
                 // 设置小部件文本视图的点击事件PendingIntent，使得点击文本时能触发对应的操作
                 rv.setOnClickPendingIntent(R.id.widget_text, pendingIntent);
                 // 通过AppWidgetManager更新指定小部件ID对应的小部件显示内容，应用前面设置好的RemoteViews对象
+=======
+                rv.setOnClickPendingIntent(R.id.widget_text, pendingIntent);
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
                 appWidgetManager.updateAppWidget(appWidgetIds[i], rv);
             }
         }
     }
 
+<<<<<<< HEAD
     // 抽象方法，需要由具体的子类实现，根据传入的背景颜色ID返回对应的背景资源ID，用于设置小部件的背景图片等显示资源
     protected abstract int getBgResourceId(int bgId);
 
@@ -175,4 +265,12 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
 
     // 抽象方法，需要由具体的子类实现，返回小部件的类型信息，具体类型由子类根据业务逻辑定义，用于在Intent等操作中传递和区分不同类型的小部件
     protected abstract int getWidgetType();
-}
+}
+=======
+    protected abstract int getBgResourceId(int bgId);
+
+    protected abstract int getLayoutId();
+
+    protected abstract int getWidgetType();
+}
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee

源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_2x.java

@@ -14,7 +14,10 @@
  * limitations under the License.
  */
 
+<<<<<<< HEAD
 // 包声明，表明该类属于net.micode.notes.widget包，通常用于存放与桌面小部件相关的具体实现类
+=======
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
 package net.micode.notes.widget;
 
 import android.appwidget.AppWidgetManager;
@@ -24,6 +27,7 @@ import net.micode.notes.R;
 import net.micode.notes.data.Notes;
 import net.micode.notes.tool.ResourceParser;
 
+<<<<<<< HEAD
 // NoteWidgetProvider_2x类继承自NoteWidgetProvider抽象类，意味着它需要实现NoteWidgetProvider中定义的抽象方法，
 // 它是专门针对某种特定尺寸（从类名推测可能是2倍尺寸）桌面小部件的具体实现类
 public class NoteWidgetProvider_2x extends NoteWidgetProvider {
@@ -38,23 +42,42 @@ public class NoteWidgetProvider_2x extends NoteWidgetProvider {
 
     // 实现父类中定义的抽象方法getLayoutId，用于返回该小部件对应的布局资源ID，这里返回的是R.layout.widget_2x，
     // 意味着该小部件使用名为widget_2x的布局文件来进行界面显示布局定义，不同的布局文件可以包含不同的视图控件、排列方式等
+=======
+
+public class NoteWidgetProvider_2x extends NoteWidgetProvider {
+    @Override
+    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
+        super.update(context, appWidgetManager, appWidgetIds);
+    }
+
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
     @Override
     protected int getLayoutId() {
         return R.layout.widget_2x;
     }
 
+<<<<<<< HEAD
     // 实现父类中定义的抽象方法getBgResourceId，根据传入的背景颜色ID（bgId）获取对应的背景资源ID，
     // 这里通过调用ResourceParser.WidgetBgResources类中的方法来获取，具体是获取2倍尺寸小部件对应的背景资源ID，
     // 使得小部件能根据不同的背景颜色ID显示相应的背景图片等资源
+=======
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
     @Override
     protected int getBgResourceId(int bgId) {
         return ResourceParser.WidgetBgResources.getWidget2xBgResource(bgId);
     }
 
+<<<<<<< HEAD
     // 实现父类中定义的抽象方法getWidgetType，返回该小部件的类型标识，这里返回的是Notes.TYPE_WIDGET_2X，
     // 用于区分不同尺寸、不同类型的小部件，在应用中可以根据这个类型标识来进行不同的业务逻辑处理，比如不同的显示样式、功能操作等
+=======
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
     @Override
     protected int getWidgetType() {
         return Notes.TYPE_WIDGET_2X;
     }
-}
+<<<<<<< HEAD
+}
+=======
+}
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee

源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_4x.java

@@ -14,7 +14,10 @@
  * limitations under the License.
  */
 
+<<<<<<< HEAD
 // 包声明，表明该类所属的包名为net.micode.notes.widget，通常用于存放与桌面小部件相关的具体实现类，从类名NoteWidgetProvider_4x推测，这是针对特定尺寸（可能是4倍尺寸）小部件的相关实现类
+=======
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
 package net.micode.notes.widget;
 
 import android.appwidget.AppWidgetManager;
@@ -24,6 +27,7 @@ import net.micode.notes.R;
 import net.micode.notes.data.Notes;
 import net.micode.notes.tool.ResourceParser;
 
+<<<<<<< HEAD
 // NoteWidgetProvider_4x类继承自NoteWidgetProvider抽象类，需要实现抽象类中定义的抽象方法，以提供针对特定类型（这里可能是4倍尺寸小部件）的具体功能实现
 public class NoteWidgetProvider_4x extends NoteWidgetProvider {
 
@@ -37,23 +41,42 @@ public class NoteWidgetProvider_4x extends NoteWidgetProvider {
 
     // 重写父类中定义的抽象方法getLayoutId，用于返回该4倍尺寸小部件对应的布局资源ID，这里返回的是R.layout.widget_4x，
     // 意味着该小部件会使用名为widget_4x的布局文件来进行界面的显示布局设置，这个布局文件中定义了小部件在桌面上展示的具体视图结构、控件摆放等内容
+=======
+
+public class NoteWidgetProvider_4x extends NoteWidgetProvider {
+    @Override
+    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
+        super.update(context, appWidgetManager, appWidgetIds);
+    }
+
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
     protected int getLayoutId() {
         return R.layout.widget_4x;
     }
 
+<<<<<<< HEAD
     // 重写父类中定义的抽象方法getBgResourceId，该方法根据传入的背景颜色标识ID（bgId）来获取对应的背景资源ID，
     // 这里借助ResourceParser.WidgetBgResources类中的方法来获取，具体是获取适用于4倍尺寸小部件的背景资源ID，
     // 从而可以根据不同的背景颜色设置来展示相应的背景图片等资源，使小部件的外观符合预期的设计要求
+=======
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
     @Override
     protected int getBgResourceId(int bgId) {
         return ResourceParser.WidgetBgResources.getWidget4xBgResource(bgId);
     }
 
+<<<<<<< HEAD
     // 重写父类中定义的抽象方法getWidgetType，返回该小部件的类型标识，这里返回的是Notes.TYPE_WIDGET_4X，
     // 这个类型标识可以用于在整个应用中区分不同尺寸、不同功能特性的小部件，比如在处理小部件相关的业务逻辑时，根据不同的类型执行不同的操作，
     // 像显示不同的内容、提供不同的交互功能等，有助于实现小部件功能的差异化和定制化
+=======
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee
     @Override
     protected int getWidgetType() {
         return Notes.TYPE_WIDGET_4X;
     }
-}
+<<<<<<< HEAD
+}
+=======
+}
+>>>>>>> 2f825b58ba9952e086b1b4b76135e78208e7a2ee