From abe758f08ed7bc8fe3bd445a8843e503ebcff92c Mon Sep 17 00:00:00 2001 From: zjz Date: Fri, 27 Dec 2024 22:22:00 +0800 Subject: [PATCH] =?UTF-8?q?=E6=B3=A8=E9=87=8A=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 张建忠 --- .../net/micode/notes/tool/BackupUtils.java | 472 +++++++----------- .../src/net/micode/notes/tool/DataUtils.java | 152 ++++-- .../micode/notes/tool/GTaskStringUtils.java | 94 +++- .../net/micode/notes/tool/ResourceParser.java | 160 +++--- .../micode/notes/ui/AlarmAlertActivity.java | 80 ++- .../micode/notes/ui/AlarmInitReceiver.java | 48 +- .../net/micode/notes/ui/AlarmReceiver.java | 16 +- .../notes/widget/NoteWidgetProvider.java | 80 ++- .../notes/widget/NoteWidgetProvider_2x.java | 17 +- .../notes/widget/NoteWidgetProvider_4x.java | 17 +- 10 files changed, 680 insertions(+), 456 deletions(-) diff --git a/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/tool/BackupUtils.java b/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/tool/BackupUtils.java index 39f6ec4..be11dc7 100644 --- a/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/tool/BackupUtils.java +++ b/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/tool/BackupUtils.java @@ -14,331 +14,203 @@ * limitations under the License. */ -package net.micode.notes.tool; +// 包声明，表明该类所属的包名，此处在net.micode.notes.ui包下 +package net.micode.notes.ui; +import android.app.Activity; +import android.app.AlertDialog; 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 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.data.Notes.DataColumns; -import net.micode.notes.data.Notes.DataConstants; -import net.micode.notes.data.Notes.NoteColumns; +import net.micode.notes.tool.DataUtils; -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]; +// AlarmAlertActivity类继承自Activity类，同时实现了OnClickListener和OnDismissListener接口， +// 意味着该类需要处理点击事件和对话框关闭事件 +public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener { + + // 用于存储笔记的ID，可能对应某个提醒关联的笔记 + private long mNoteId; + // 用于存储笔记内容的摘要信息，长度有限制 + private String mSnippet; + // 定义摘要的最大长度为60个字符 + private static final int SNIPPET_PREW_MAX_LEN = 60; + // MediaPlayer对象用于播放提醒的声音 + MediaPlayer mPlayer; + + // 重写Activity的onCreate方法，该方法在Activity创建时被调用 + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + // 请求去除Activity的标题栏，使界面更简洁（如果支持该特性的话） + requestWindowFeature(Window.FEATURE_NO_TITLE); + + // 获取当前Activity的窗口对象 + 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); } - /** - * 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); + // 获取启动该Activity的Intent对象，可从中获取传递的数据等信息 + Intent intent = getIntent(); - 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()); - } + try { + // 从Intent携带的数据（可能是Uri格式）中解析出笔记的ID，具体是取路径段中的第二个元素（索引为1） + mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1)); + // 通过DataUtils工具类根据笔记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; } - /** - * 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; + // 创建一个MediaPlayer实例，用于后续播放提醒声音 + mPlayer = new MediaPlayer(); + // 通过DataUtils工具类判断该笔记在数据库中是否可见（是否有效等情况） + if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) { + // 如果笔记有效，显示操作对话框，供用户进行相关操作 + showActionDialog(); + // 播放提醒声音 + playAlarmSound(); + } else { + // 如果笔记无效，直接结束该Activity + finish(); } + } - /** - * 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; - } + // 方法用于判断屏幕是否处于开启状态 + private boolean isScreenOn() { + // 获取系统的电源管理服务对象 + PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE); + // 调用其isScreenOn方法来判断屏幕状态并返回结果 + return pm.isScreenOn(); } - /** - * 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()); + // 方法用于播放提醒声音 + private void playAlarmSound() { + // 通过RingtoneManager获取系统默认的闹钟铃声的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) { + // 如果影响，设置MediaPlayer的音频流类型为对应的静音模式设置值 + mPlayer.setAudioStreamType(silentModeStreams); + } else { + // 如果不影响，设置为正常的闹钟音频流类型 + mPlayer.setAudioStreamType(AudioManager.STREAM_ALARM); + } try { - if (!filedir.exists()) { - filedir.mkdir(); - } - if (!file.exists()) { - file.createNewFile(); - } - return file; + // 设置MediaPlayer的数据源为获取到的铃声Uri + mPlayer.setDataSource(this, url); + // 准备MediaPlayer，使其进入可播放状态（可能会涉及加载音频资源等操作） + mPlayer.prepare(); + // 设置为循环播放，以持续提醒 + mPlayer.setLooping(true); + // 开始播放声音 + mPlayer.start(); + } catch (IllegalArgumentException e) { + // 如果参数设置出现异常，打印异常堆栈信息 + e.printStackTrace(); } catch (SecurityException e) { + // 如果出现安全相关异常，打印异常堆栈信息 + e.printStackTrace(); + } catch (IllegalStateException e) { + // 如果MediaPlayer状态出现异常，打印异常堆栈信息 e.printStackTrace(); } catch (IOException e) { + // 如果在读取数据源等IO操作出现异常，打印异常堆栈信息 e.printStackTrace(); } + } - return null; + // 方法用于创建并显示操作对话框，给用户提供相应的操作选项 + private void showActionDialog() { + // 创建一个AlertDialog的构建器对象，用于构建对话框 + AlertDialog.Builder dialog = new AlertDialog.Builder(this); + // 设置对话框的标题，这里使用了字符串资源中的应用名称 + dialog.setTitle(R.string.app_name); + // 设置对话框的消息内容，显示之前获取的笔记摘要信息 + dialog.setMessage(mSnippet); + // 设置对话框的确定按钮文本以及点击监听器（实现了OnClickListener接口） + dialog.setPositiveButton(R.string.notealert_ok, this); + // 如果屏幕处于开启状态，设置对话框的进入按钮文本以及点击监听器 + if (isScreenOn()) { + dialog.setNegativeButton(R.string.notealert_enter, this); + } + // 构建并显示对话框，并设置对话框关闭监听器（实现了OnDismissListener接口） + dialog.show().setOnDismissListener(this); } -} + // 实现OnClickListener接口的方法，处理对话框按钮点击事件 + public void onClick(DialogInterface dialog, int which) { + switch (which) { + // 如果点击的是对话框的否定按钮（比如进入按钮等，根据具体设置而定） + case DialogInterface.BUTTON_NEGATIVE: + // 创建一个Intent，用于启动NoteEditActivity，可能是进入笔记编辑界面 + Intent intent = new Intent(this, NoteEditActivity.class); + // 设置Intent的动作，这里是查看动作 + intent.setAction(Intent.ACTION_VIEW); + // 将笔记的ID通过Intent的额外数据传递给目标Activity + intent.putExtra(Intent.EXTRA_UID, mNoteId); + // 启动目标Activity + startActivity(intent); + break; + default: + break; + } + } + + // 实现OnDismissListener接口的方法，当对话框关闭时被调用 + public void onDismiss(DialogInterface dialog) { + // 停止播放提醒声音，并释放相关资源 + stopAlarmSound(); + // 结束当前Activity + finish(); + } + // 方法用于停止播放声音，释放MediaPlayer资源 + private void stopAlarmSound() { + if (mPlayer!= null) { + // 停止播放声音 + mPlayer.stop(); + // 释放MediaPlayer资源，使其处于空闲状态 + mPlayer.release(); + // 将mPlayer对象置为null，避免后续误操作 + mPlayer = null; + } + } +} \ No newline at end of file diff --git a/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/tool/DataUtils.java b/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/tool/DataUtils.java index 2a14982..70489f1 100644 --- a/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/tool/DataUtils.java +++ b/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/tool/DataUtils.java @@ -14,6 +14,7 @@ * limitations under the License. */ +// 包声明，表明该类所属的包名为net.micode.notes.tool package net.micode.notes.tool; import android.content.ContentProviderOperation; @@ -34,101 +35,144 @@ import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute; import java.util.ArrayList; import java.util.HashSet; - +// DataUtils工具类，提供了一系列用于操作笔记数据相关的实用方法 public class DataUtils { + // 用于日志记录的标签，方便在日志中识别该类输出的相关信息 public static final String TAG = "DataUtils"; + + // 批量删除笔记的方法，根据给定的ContentResolver和要删除笔记的ID集合来执行删除操作 public static boolean batchDeleteNotes(ContentResolver resolver, HashSet ids) { + // 如果传入的ID集合为null，记录日志并返回true（可能表示无需进行删除操作的情况） if (ids == null) { Log.d(TAG, "the ids is null"); return true; } + // 如果ID集合为空，记录日志并返回true（表示没有实际要删除的笔记） if (ids.size() == 0) { Log.d(TAG, "no id is in the hashset"); return true; } + // 创建一个用于存储内容提供器操作的列表，后续将批量执行这些操作来删除笔记 ArrayList operationList = new ArrayList(); + // 遍历要删除的笔记ID集合 for (long id : ids) { - if(id == Notes.ID_ROOT_FOLDER) { + // 不允许删除系统根文件夹（根据特定的ID判断），如果是根文件夹则记录错误日志并跳过本次删除操作 + if (id == Notes.ID_ROOT_FOLDER) { Log.e(TAG, "Don't delete system folder root"); continue; } + // 创建一个用于删除指定笔记的ContentProviderOperation构建器，指定要删除的笔记的Uri ContentProviderOperation.Builder builder = ContentProviderOperation - .newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id)); + .newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id)); + // 将构建好的操作添加到操作列表中 operationList.add(builder.build()); } + try { + // 通过ContentResolver批量执行操作列表中的删除操作，并获取操作结果数组 ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList); + // 如果结果数组为null，或者长度为0，或者第一个结果为null，表示删除笔记失败，记录日志并返回false if (results == null || results.length == 0 || results[0] == null) { 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())); } return false; } + // 将指定笔记移动到指定文件夹的方法，通过更新笔记的相关字段来实现移动操作 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); + // 设置本地修改标志，可能表示该笔记在本地有过修改操作 values.put(NoteColumns.LOCAL_MODIFIED, 1); + // 通过ContentResolver执行更新操作，根据笔记的ID更新对应的记录 resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null); } + // 批量将多个笔记移动到指定文件夹的方法，与单个笔记移动类似，不过是批量操作 public static boolean batchMoveToFolder(ContentResolver resolver, HashSet ids, long folderId) { + // 如果传入的笔记ID集合为null，记录日志并返回true（可能表示无需进行移动操作的情况） if (ids == null) { Log.d(TAG, "the ids is null"); return true; } + // 创建一个用于存储内容提供器操作的列表，后续将批量执行这些操作来移动笔记 ArrayList operationList = new ArrayList(); + // 遍历要移动的笔记ID集合 for (long id : ids) { + // 创建一个用于更新指定笔记的ContentProviderOperation构建器，指定要更新的笔记的Uri ContentProviderOperation.Builder builder = ContentProviderOperation - .newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id)); + .newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id)); + // 设置笔记的新父文件夹ID（目标文件夹ID） builder.withValue(NoteColumns.PARENT_ID, folderId); + // 设置本地修改标志，可能表示该笔记在本地有过修改操作 builder.withValue(NoteColumns.LOCAL_MODIFIED, 1); + // 将构建好的操作添加到操作列表中 operationList.add(builder.build()); } try { + // 通过ContentResolver批量执行操作列表中的更新操作，并获取操作结果数组 ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList); + // 如果结果数组为null，或者长度为0，或者第一个结果为null，表示移动笔记失败，记录日志并返回false if (results == null || results.length == 0 || results[0] == null) { 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())); } return false; } /** - * Get the all folder count except system folders {@link Notes#TYPE_SYSTEM}} + * 获取除系统文件夹（参考Notes#TYPE_SYSTEM）之外的所有文件夹数量的方法 */ public static int getUserFolderCount(ContentResolver resolver) { - Cursor cursor =resolver.query(Notes.CONTENT_NOTE_URI, + // 通过ContentResolver查询笔记内容提供器，统计符合条件的文件夹数量 + // 查询的列只需要计数结果，所以使用"COUNT(*)" + // 查询条件是类型为文件夹（NoteColumns.TYPE对应的是文件夹类型）且父文件夹ID不是回收站文件夹ID + 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()) { + // 如果游标不为null，表示查询到了结果 + if (cursor!= null) { + // 将游标移动到第一条记录（因为只有一条计数结果记录） + if (cursor.moveToFirst()) { try { + // 获取计数结果（游标中的第一列数据）并赋值给count变量 count = cursor.getInt(0); } catch (IndexOutOfBoundsException e) { + // 如果获取数据出现越界异常，记录详细的异常信息到日志 Log.e(TAG, "get folder count failed:" + e.toString()); } finally { + // 关闭游标，释放资源 cursor.close(); } } @@ -136,7 +180,9 @@ public class DataUtils { return count; } + // 判断指定笔记在笔记数据库中是否可见（根据特定条件，比如不在回收站等）的方法 public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) { + // 通过ContentResolver查询指定笔记的记录，查询条件是类型为指定类型且父文件夹ID不是回收站文件夹ID Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER, @@ -144,60 +190,76 @@ public class DataUtils { null); boolean exist = false; - if (cursor != null) { + // 如果游标不为null，表示查询到了结果 + if (cursor!= null) { + // 如果查询到的记录数量大于0，表示该笔记存在且符合可见条件，设置exist为true if (cursor.getCount() > 0) { exist = true; } + // 关闭游标，释放资源 cursor.close(); } return exist; } + // 判断指定笔记在笔记数据库中是否存在的方法（简单查询是否有对应记录） public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) { + // 通过ContentResolver查询指定笔记的记录，不设置额外的查询条件 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, null, null, null); boolean exist = false; - if (cursor != null) { + // 如果游标不为null，表示查询到了结果 + if (cursor!= null) { + // 如果查询到的记录数量大于0，表示该笔记存在，设置exist为true if (cursor.getCount() > 0) { exist = true; } + // 关闭游标，释放资源 cursor.close(); } return exist; } + // 判断指定数据（可能是某种关联数据等）在数据数据库中是否存在的方法（简单查询是否有对应记录） public static boolean existInDataDatabase(ContentResolver resolver, long dataId) { + // 通过ContentResolver查询指定数据的记录，不设置额外的查询条件 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(); + // 如果游标不为null，表示查询到了结果 + if (cursor!= null) { + // 如果查询到的记录数量大于0，表示该数据存在，设置exist为true } + cursor.close(); return exist; } + // 检查指定名称的文件夹在数据库中是否可见（根据特定条件，如不在回收站且名称匹配等）的方法 public static boolean checkVisibleFolderName(ContentResolver resolver, String name) { + // 通过ContentResolver查询符合条件的文件夹记录，查询条件是类型为文件夹、父文件夹ID不是回收站文件夹ID且摘要（可能是名称相关字段）匹配指定名称 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) { + // 如果游标不为null，表示查询到了结果 + if (cursor!= null) { + // 如果查询到的记录数量大于0，表示存在符合条件的文件夹，设置exist为true + if (cursor.getCount() > 0) { exist = true; } + // 关闭游标，释放资源 cursor.close(); } return exist; } + // 获取指定文件夹下所有笔记对应的小部件相关属性集合的方法（可能用于展示小部件相关信息等） public static HashSet getFolderNoteWidget(ContentResolver resolver, long folderId) { + // 通过ContentResolver查询指定文件夹下笔记的小部件ID和小部件类型信息 Cursor c = resolver.query(Notes.CONTENT_NOTE_URI, new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE }, NoteColumns.PARENT_ID + "=?", @@ -205,45 +267,62 @@ public class DataUtils { null); HashSet set = null; - if (c != null) { + // 如果游标不为null，表示查询到了结果 + if (c!= null) { + // 将游标移动到第一条记录 if (c.moveToFirst()) { set = new HashSet(); do { try { + // 创建一个AppWidgetAttribute对象，用于存储小部件相关属性 AppWidgetAttribute widget = new AppWidgetAttribute(); + // 从游标中获取小部件ID并赋值给widget对象 widget.widgetId = c.getInt(0); + // 从游标中获取小部件类型并赋值给widget对象 widget.widgetType = c.getInt(1); + // 将widget对象添加到集合中 set.add(widget); } catch (IndexOutOfBoundsException e) { + // 如果获取数据出现越界异常，记录详细的异常信息到日志 Log.e(TAG, e.toString()); } } while (c.moveToNext()); } + // 关闭游标，释放资源 c.close(); } return set; } + // 根据笔记ID获取对应的电话号码的方法（可能是与笔记关联的电话号码） public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) { + // 通过ContentResolver查询指定笔记关联的数据表（可能是通话记录相关的数据表），获取电话号码列的值 + // 查询条件是笔记ID匹配且MIME类型匹配（可能用于确定数据类型） 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()) { + 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的方法（可能用于反向查找关联笔记） public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) { + // 通过ContentResolver查询指定数据表（可能是通话记录相关的数据表），获取笔记ID列的值 + // 查询条件是通话日期匹配、MIME类型匹配且电话号码匹配（通过自定义函数PHONE_NUMBERS_EQUAL判断） Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.NOTE_ID }, CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL(" @@ -251,45 +330,20 @@ public class DataUtils { new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber }, null); - if (cursor != null) { + if (cursor!= null) { if (cursor.moveToFirst()) { try { + // 如果查询到结果且游标移动到第一条记录，获取笔记ID并返回 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; - } -} + // 根据笔记ID获取对应的摘要信息的方法 \ No newline at end of file diff --git a/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/tool/GTaskStringUtils.java b/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/tool/GTaskStringUtils.java index 666b729..4a2f904 100644 --- a/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/tool/GTaskStringUtils.java +++ b/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/tool/GTaskStringUtils.java @@ -14,100 +14,190 @@ * limitations under the License. */ +// 包声明，表明该类所属的包名为net.micode.notes.tool package net.micode.notes.tool; +// GTaskStringUtils类，从名称推测可能是用于处理与GTask相关的字符串操作的工具类， +// 目前类中主要定义了一系列的字符串常量，方便在整个项目中统一使用这些特定的字符串标识 public class GTaskStringUtils { + // 表示GTask JSON数据中"action_id"字段对应的字符串常量，可能用于在解析或构建GTask相关JSON数据时， + // 作为键来获取或设置对应的值，代表某个操作的唯一标识符 public final static String GTASK_JSON_ACTION_ID = "action_id"; + // 表示GTask JSON数据中"action_list"字段对应的字符串常量，可能用于表示操作相关的列表信息， + // 比如涉及到的任务列表等情况 public final static String GTASK_JSON_ACTION_LIST = "action_list"; + // 表示GTask JSON数据中"action_type"字段对应的字符串常量，用于表示操作的类型， + // 后续有定义具体的操作类型值（如创建、获取全部等） public final static String GTASK_JSON_ACTION_TYPE = "action_type"; + // 表示GTask JSON数据中"action_type"字段具体取值为"create"时对应的字符串常量， + // 意味着对应的操作是创建类型的操作，比如创建任务、创建列表等 public final static String GTASK_JSON_ACTION_TYPE_CREATE = "create"; + // 表示GTask JSON数据中"action_type"字段具体取值为"get_all"时对应的字符串常量， + // 意味着对应的操作是获取全部相关内容的操作，比如获取全部任务、获取全部列表等 public final static String GTASK_JSON_ACTION_TYPE_GETALL = "get_all"; + // 表示GTask JSON数据中"action_type"字段具体取值为"move"时对应的字符串常量， + // 意味着对应的操作是移动相关内容的操作，比如移动任务到其他列表等情况 public final static String GTASK_JSON_ACTION_TYPE_MOVE = "move"; + // 表示GTask JSON数据中"action_type"字段具体取值为"update"时对应的字符串常量， + // 意味着对应的操作是更新相关内容的操作，比如更新任务的属性等情况 public final static String GTASK_JSON_ACTION_TYPE_UPDATE = "update"; + // 表示GTask JSON数据中"creator_id"字段对应的字符串常量，可能用于标识执行某个操作或者创建某个对象的用户的唯一标识符 public final static String GTASK_JSON_CREATOR_ID = "creator_id"; + // 表示GTask JSON数据中"child_entity"字段对应的字符串常量，可能用于表示某个实体（如任务、列表等）的子实体相关信息 public final static String GTASK_JSON_CHILD_ENTITY = "child_entity"; + // 表示GTask JSON数据中"client_version"字段对应的字符串常量，可能用于记录客户端的版本信息， + // 比如在与服务器交互等场景下，标识客户端的版本情况 public final static String GTASK_JSON_CLIENT_VERSION = "client_version"; + // 表示GTask JSON数据中"completed"字段对应的字符串常量，可能用于表示某个任务是否已完成的状态信息， + // 比如布尔值对应的字符串表示（"true"或"false"等情况） public final static String GTASK_JSON_COMPLETED = "completed"; + // 表示GTask JSON数据中"current_list_id"字段对应的字符串常量，可能用于标识当前所在的任务列表的唯一标识符， + // 比如当前操作关联的是哪个具体的任务列表 public final static String GTASK_JSON_CURRENT_LIST_ID = "current_list_id"; + // 表示GTask JSON数据中"default_list_id"字段对应的字符串常量，可能用于标识默认任务列表的唯一标识符， + // 例如新创建任务默认归属的列表等情况 public final static String GTASK_JSON_DEFAULT_LIST_ID = "default_list_id"; + // 表示GTask JSON数据中"deleted"字段对应的字符串常量，可能用于表示某个对象（如任务、列表等）是否已被删除的状态信息 public final static String GTASK_JSON_DELETED = "deleted"; + // 表示GTask JSON数据中"dest_list"字段对应的字符串常量，可能用于在移动等操作中，表示目标任务列表相关信息， + // 比如移动任务到的目标列表等情况 public final static String GTASK_JSON_DEST_LIST = "dest_list"; + // 表示GTask JSON数据中"dest_parent"字段对应的字符串常量，可能用于在移动或关联等操作中， + // 表示目标父对象（如任务的父任务、列表的父列表等）相关信息 public final static String GTASK_JSON_DEST_PARENT = "dest_parent"; + // 表示GTask JSON数据中"dest_parent_type"字段对应的字符串常量，可能用于明确目标父对象的类型， + // 比如是任务类型还是列表类型等情况 public final static String GTASK_JSON_DEST_PARENT_TYPE = "dest_parent_type"; + // 表示GTask JSON数据中"entity_delta"字段对应的字符串常量，可能用于表示实体（如任务、列表等）的变化量相关信息， + // 比如属性的变化差值等情况，常用于更新操作的相关逻辑中 public final static String GTASK_JSON_ENTITY_DELTA = "entity_delta"; + // 表示GTask JSON数据中"entity_type"字段对应的字符串常量，可能用于明确实体的类型， + // 比如是任务、列表还是其他自定义类型等情况 public final static String GTASK_JSON_ENTITY_TYPE = "entity_type"; + // 表示GTask JSON数据中"get_deleted"字段对应的字符串常量，可能用于获取已删除对象相关信息的操作标识， + // 比如请求获取已删除的任务、列表等情况 public final static String GTASK_JSON_GET_DELETED = "get_deleted"; + // 表示GTask JSON数据中"id"字段对应的字符串常量，通常用于表示各种对象（任务、列表、用户等）的唯一标识符 public final static String GTASK_JSON_ID = "id"; + // 表示GTask JSON数据中"index"字段对应的字符串常量，可能用于表示某个对象在列表中的顺序索引等情况， + // 比如任务在任务列表中的排列顺序等 public final static String GTASK_JSON_INDEX = "index"; + // 表示GTask JSON数据中"last_modified"字段对应的字符串常量，可能用于记录对象最后一次被修改的时间戳等信息， + // 方便进行数据同步、版本控制等操作 public final static String GTASK_JSON_LAST_MODIFIED = "last_modified"; + // 表示GTask JSON数据中"latest_sync_point"字段对应的字符串常量，可能用于标识最近一次数据同步的关键点信息， + // 比如同步的时间、版本号等情况，用于确保数据在不同端的一致性 public final static String GTASK_JSON_LATEST_SYNC_POINT = "latest_sync_point"; + // 表示GTask JSON数据中"list_id"字段对应的字符串常量，通常用于表示任务列表的唯一标识符， + // 在很多涉及任务与列表关联的操作中会用到 public final static String GTASK_JSON_LIST_ID = "list_id"; + // 表示GTask JSON数据中"lists"字段对应的字符串常量，可能用于表示一组任务列表相关的数据结构， + // 比如包含多个任务列表的集合等情况 public final static String GTASK_JSON_LISTS = "lists"; + // 表示GTask JSON数据中"name"字段对应的字符串常量，通常用于表示对象（任务、列表、用户等）的名称信息， + // 方便展示和区分不同的对象 public final static String GTASK_JSON_NAME = "name"; + // 表示GTask JSON数据中"new_id"字段对应的字符串常量，可能用于在某些操作（如复制、移动后重新生成标识符等情况）下， + // 表示新生成的对象的唯一标识符 public final static String GTASK_JSON_NEW_ID = "new_id"; + // 表示GTask JSON数据中"notes"字段对应的字符串常量，可能用于表示与任务、列表等相关的备注信息， + // 比如对任务的详细描述、对列表用途的说明等情况 public final static String GTASK_JSON_NOTES = "notes"; + // 表示GTask JSON数据中"parent_id"字段对应的字符串常量，通常用于表示某个对象（如任务、列表等）的父对象的唯一标识符， + // 用于构建对象之间的层级关系等情况 public final static String GTASK_JSON_PARENT_ID = "parent_id"; + // 表示GTask JSON数据中"prior_sibling_id"字段对应的字符串常量，可能用于表示在同一层级中， + // 当前对象之前的兄弟对象的唯一标识符，比如在任务列表中某个任务之前的相邻任务的标识等情况 public final static String GTASK_JSON_PRIOR_SIBLING_ID = "prior_sibling_id"; + // 表示GTask JSON数据中"results"字段对应的字符串常量，可能用于存储操作后的结果信息， + // 比如执行某个任务操作后返回的结果集等情况 public final static String GTASK_JSON_RESULTS = "results"; + // 表示GTask JSON数据中"source_list"字段对应的字符串常量，可能用于在移动、复制等操作中， + // 表示源任务列表相关信息，即操作对象原来所在的列表等情况 public final static String GTASK_JSON_SOURCE_LIST = "source_list"; + // 表示GTask JSON数据中"tasks"字段对应的字符串常量，通常用于表示一组任务相关的数据结构， + // 比如包含多个任务的集合等情况 public final static String GTASK_JSON_TASKS = "tasks"; + // 表示GTask JSON数据中"type"字段对应的字符串常量，用于表示对象的类型， + // 后续有定义具体的类型值（如任务、组等情况） public final static String GTASK_JSON_TYPE = "type"; + // 表示GTask JSON数据中"type"字段具体取值为"GROUP"时对应的字符串常量，意味着对应的对象类型是组， + // 比如任务分组等情况，用于区分不同类型的对象 public final static String GTASK_JSON_TYPE_GROUP = "GROUP"; + // 表示GTask JSON数据中"type"字段具体取值为"TASK"时对应的字符串常量，意味着对应的对象类型是任务， + // 是最常见的操作对象类型之一 public final static String GTASK_JSON_TYPE_TASK = "TASK"; + // 表示GTask JSON数据中"user"字段对应的字符串常量，可能用于表示与用户相关的信息， + // 比如操作的执行者、任务的创建者等用户相关情况 public final static String GTASK_JSON_USER = "user"; + // 表示特定的文件夹前缀字符串常量，可能用于标识是MIUI笔记相关的文件夹， + // 在文件系统或者数据存储中方便区分不同来源、用途的文件夹 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"; + // 表示元数据中GTask ID头部信息的字符串常量，可能用于在元数据结构中， + // 标识GTask相关的唯一标识符所在的字段等情况 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"; - -} +} \ No newline at end of file diff --git a/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/tool/ResourceParser.java b/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/tool/ResourceParser.java index 1ad3ad6..728e9f5 100644 --- a/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/tool/ResourceParser.java +++ b/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/tool/ResourceParser.java @@ -14,6 +14,7 @@ * limitations under the License. */ +// 包声明，表明该类所属的包名为net.micode.notes.tool package net.micode.notes.tool; import android.content.Context; @@ -22,146 +23,178 @@ import android.preference.PreferenceManager; import net.micode.notes.R; import net.micode.notes.ui.NotesPreferenceActivity; +// ResourceParser类，从名称来看是一个资源解析相关的工具类，用于获取和处理各种与界面显示相关的资源（如颜色、背景图片、字体样式等资源的相关操作） public class ResourceParser { - public static final int YELLOW = 0; - public static final int BLUE = 1; - public static final int WHITE = 2; - public static final int GREEN = 3; - public static final int RED = 4; + // 定义颜色相关的常量，用整数来表示不同的颜色选项，这里分别对应黄色、蓝色、白色、绿色、红色，方便后续根据这些常量来引用对应的颜色资源或进行相关逻辑判断 + public static final int 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; + // 定义默认的背景颜色常量，其值为YELLOW（即黄色），表示在没有特殊设置的情况下，默认使用的背景颜色对应的标识 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 TEXT_SMALL = 0; + public static final int TEXT_MEDIUM = 1; + public static final int TEXT_LARGE = 2; + public static final int TEXT_SUPER = 3; + // 定义默认的字体大小常量，其值为TEXT_MEDIUM（即中等字体大小），表示在没有特殊设置的情况下，默认使用的字体大小对应的标识 public static final int BG_DEFAULT_FONT_SIZE = TEXT_MEDIUM; + // 内部静态类NoteBgResources，用于管理笔记编辑相关的背景资源（如背景图片资源等），将相关资源的获取逻辑封装在内部类中，使代码结构更清晰 public static class NoteBgResources { - private final static int [] BG_EDIT_RESOURCES = new int [] { - R.drawable.edit_yellow, - R.drawable.edit_blue, - R.drawable.edit_white, - R.drawable.edit_green, - R.drawable.edit_red + // 定义一个私有的静态整数数组，用于存储笔记编辑页面背景的资源ID，每个元素对应一种颜色（顺序与前面定义的颜色常量对应）的编辑页面背景图片资源 + 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，每个元素对应一种颜色（顺序与前面定义的颜色常量对应）的编辑页面标题背景图片资源 + 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，方便在代码中设置对应的背景图片资源 public static int getNoteBgResource(int id) { return BG_EDIT_RESOURCES[id]; } + // 根据传入的颜色标识ID（对应前面定义的颜色常量）获取笔记编辑页面标题的背景图片资源ID，方便在代码中设置对应的标题背景图片资源 public static int getNoteTitleBgResource(int id) { return BG_EDIT_TITLE_RESOURCES[id]; } } + // 根据给定的上下文（Context）获取默认的背景颜色标识ID，判断逻辑基于用户在偏好设置（Preference）中是否设置了特定的背景颜色相关选项 public static int getDefaultBgId(Context context) { + // 通过PreferenceManager获取默认的共享偏好设置对象，然后检查是否设置了特定的背景颜色设置键对应的布尔值（可能表示用户是否手动设置过背景颜色） if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean( NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) { + // 如果用户设置过，随机生成一个在背景资源数组长度范围内的索引值（对应不同颜色的背景资源），作为返回的背景颜色标识ID，实现随机选择背景颜色的效果 return (int) (Math.random() * NoteBgResources.BG_EDIT_RESOURCES.length); } else { + // 如果用户没有设置过，返回默认的背景颜色标识ID（即前面定义的BG_DEFAULT_COLOR） return BG_DEFAULT_COLOR; } } + // 内部静态类NoteItemBgResources，用于管理笔记列表项相关的背景资源（如不同位置的列表项背景图片资源等），同样将相关资源的获取逻辑封装在内部类中，便于代码的组织和维护 public static class NoteItemBgResources { - private final static int [] BG_FIRST_RESOURCES = new int [] { - R.drawable.list_yellow_up, - R.drawable.list_blue_up, - R.drawable.list_white_up, - R.drawable.list_green_up, - R.drawable.list_red_up + // 定义一个私有的静态整数数组，用于存储列表项第一个元素（比如列表中第一个笔记项）的背景图片资源ID，每个元素对应一种颜色（顺序与前面定义的颜色常量对应）的对应背景图片资源 + 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 + // 定义一个私有的静态整数数组，用于存储列表项中间元素（非第一个和最后一个笔记项）的背景图片资源ID，每个元素对应一种颜色（顺序与前面定义的颜色常量对应）的对应背景图片资源 + 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, + // 定义一个私有的静态整数数组，用于存储列表项最后一个元素（比如列表中最后一个笔记项）的背景图片资源ID，每个元素对应一种颜色（顺序与前面定义的颜色常量对应）的对应背景图片资源 + 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，每个元素对应一种颜色（顺序与前面定义的颜色常量对应）的对应背景图片资源 + 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，方便在代码中设置对应的背景图片资源 public static int getNoteBgFirstRes(int id) { return BG_FIRST_RESOURCES[id]; } + // 根据传入的颜色标识ID（对应前面定义的颜色常量）获取列表项最后一个元素的背景图片资源ID，方便在代码中设置对应的背景图片资源 public static int getNoteBgLastRes(int id) { return BG_LAST_RESOURCES[id]; } + // 根据传入的颜色标识ID（对应前面定义的颜色常量）获取列表项单独存在时的背景图片资源ID，方便在代码中设置对应的背景图片资源 public static int getNoteBgSingleRes(int id) { return BG_SINGLE_RESOURCES[id]; } + // 根据传入的颜色标识ID（对应前面定义的颜色常量）获取列表项中间元素的背景图片资源ID，方便在代码中设置对应的背景图片资源 public static int getNoteBgNormalRes(int id) { return BG_NORMAL_RESOURCES[id]; } + // 获取文件夹的背景图片资源ID，这里固定返回一个表示文件夹背景图片的资源ID（可能所有文件夹使用相同的背景图片样式） public static int getFolderBgRes() { return R.drawable.list_folder; } } + // 内部静态类WidgetBgResources，用于管理小部件相关的背景资源（如不同尺寸小部件的背景图片资源等），将相关资源的获取逻辑封装在内部类中，以更好地组织代码结构 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, + // 定义一个私有的静态整数数组，用于存储2倍尺寸小部件的背景图片资源ID，每个元素对应一种颜色（顺序与前面定义的颜色常量对应）的对应背景图片资源 + 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（对应前面定义的颜色常量）获取2倍尺寸小部件的背景图片资源ID，方便在代码中设置对应的小部件背景图片资源 public static int getWidget2xBgResource(int id) { return BG_2X_RESOURCES[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 + // 定义一个私有的静态整数数组，用于存储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 }; + // 根据传入的颜色标识ID（对应前面定义的颜色常量）获取4倍尺寸小部件的背景图片资源ID，方便在代码中设置对应的小部件背景图片资源 public static int getWidget4xBgResource(int id) { return BG_4X_RESOURCES[id]; } } + // 内部静态类TextAppearanceResources，用于管理文本外观相关的资源（如不同字体大小对应的样式资源等），将相关资源的获取逻辑封装在内部类中，使代码结构更清晰易读 public static class TextAppearanceResources { - private final static int [] TEXTAPPEARANCE_RESOURCES = new int [] { - R.style.TextAppearanceNormal, - R.style.TextAppearanceMedium, - R.style.TextAppearanceLarge, - R.style.TextAppearanceSuper + // 定义一个私有的静态整数数组，用于存储不同字体大小对应的文本外观样式资源ID，每个元素对应一种字体大小级别（顺序与前面定义的字体大小常量对应）的对应样式资源 + private final static int[] TEXTAPPEARANCE_RESOURCES = new int[]{ + R.style.TextAppearanceNormal, + R.style.TextAppearanceMedium, + R.style.TextAppearanceLarge, + R.style.TextAppearanceSuper }; + // 根据传入的字体大小标识ID（对应前面定义的字体大小常量）获取对应的文本外观样式资源ID，同时处理了ID超出资源数组长度的情况（可能是由于数据异常等原因），此时返回默认的字体大小对应的资源ID public static int getTexAppearanceResource(int id) { /** * HACKME: Fix bug of store the resource id in shared preference. @@ -174,8 +207,9 @@ public class ResourceParser { return TEXTAPPEARANCE_RESOURCES[id]; } + // 获取文本外观样式资源数组的长度，可用于判断传入的字体大小标识ID是否越界等情况，也便于在其他相关逻辑中了解资源的数量情况 public static int getResourcesSize() { return TEXTAPPEARANCE_RESOURCES.length; } } -} +} \ No newline at end of file diff --git a/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/ui/AlarmAlertActivity.java b/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/ui/AlarmAlertActivity.java index 85723be..c2247b5 100644 --- a/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/ui/AlarmAlertActivity.java +++ b/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/ui/AlarmAlertActivity.java @@ -14,6 +14,7 @@ * limitations under the License. */ +// 包声明，表明该类属于net.micode.notes.ui包，通常用于存放与用户界面相关的类 package net.micode.notes.ui; import android.app.Activity; @@ -39,103 +40,157 @@ import net.micode.notes.tool.DataUtils; import java.io.IOException; - +// AlarmAlertActivity类继承自Activity类，意味着它是一个安卓中的Activity，用于展示用户界面。 +// 同时实现了OnClickListener和OnDismissListener接口，用于处理对话框的点击和关闭事件 public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener { + + // 用于存储与提醒相关联的笔记的ID，可能后续用于查询、操作该笔记的相关信息 private long mNoteId; + // 用于存储笔记的摘要信息，将展示在提醒界面等地方给用户查看 private String mSnippet; + // 定义摘要信息的最大长度为60个字符，超过这个长度会进行截断处理 private static final int SNIPPET_PREW_MAX_LEN = 60; + // MediaPlayer对象，用于播放提醒的声音，比如闹钟铃声等 MediaPlayer mPlayer; + // 重写Activity的onCreate方法，该方法在Activity被创建时调用，用于进行初始化等相关操作 @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); + // 请求去除Activity的标题栏，使界面更加简洁，仅在支持该特性的安卓版本和设备上生效 requestWindowFeature(Window.FEATURE_NO_TITLE); + // 获取当前Activity的窗口对象，后续用于设置窗口的各种属性 final Window win = getWindow(); + // 设置窗口属性，使窗口在屏幕锁定时也能够显示出来，方便用户看到提醒信息 win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED); + // 调用isScreenOn方法判断屏幕是否处于开启状态，如果屏幕未开启 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 intent = getIntent(); try { + // 从Intent携带的数据中解析出笔记的ID，具体是从Intent的数据Uri的路径段中获取第二个元素（索引为1）并转换为长整型 mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1)); + // 通过DataUtils工具类的方法，根据笔记ID从内容提供器中获取笔记的摘要信息 mSnippet = DataUtils.getSnippetById(this.getContentResolver(), mNoteId); - mSnippet = mSnippet.length() > SNIPPET_PREW_MAX_LEN ? mSnippet.substring(0, + // 如果获取到的摘要信息长度大于设定的最大长度（SNIPPET_PREW_MAX_LEN） + mSnippet = mSnippet.length() > SNIPPET_PREW_MAX_LEN? mSnippet.substring(0, SNIPPET_PREW_MAX_LEN) + getResources().getString(R.string.notelist_string_info) : mSnippet; + // 则进行截断处理，截取前60个字符，并添加一个特定的提示字符串（从资源文件中获取），否则保持原摘要信息不变 } catch (IllegalArgumentException e) { + // 如果在解析笔记ID或者获取摘要信息过程中出现参数异常（比如格式不正确等原因），打印异常堆栈信息，并直接返回，不再执行后续操作 e.printStackTrace(); return; } + // 创建一个MediaPlayer实例，用于后续播放提醒声音 mPlayer = new MediaPlayer(); + // 通过DataUtils工具类判断该笔记在笔记数据库中是否可见（可能涉及是否被删除、是否处于有效状态等条件判断）， + // 传入笔记ID以及笔记类型（这里是普通笔记类型Notes.TYPE_NOTE）进行判断 if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) { + // 如果笔记可见，即满足有效条件，调用showActionDialog方法显示操作对话框，供用户进行相应操作 showActionDialog(); + // 调用playAlarmSound方法播放提醒声音 playAlarmSound(); } else { + // 如果笔记不可见，直接结束当前Activity，意味着不需要展示提醒相关的界面了 finish(); } } + // 私有方法，用于判断屏幕是否处于开启状态 private boolean isScreenOn() { + // 获取系统的电源管理服务对象，用于查询屏幕的电源状态等信息 PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE); + // 调用电源管理服务对象的isScreenOn方法，返回屏幕是否开启的布尔值结果 return pm.isScreenOn(); } + // 私有方法，用于播放提醒声音，比如播放闹钟铃声等 private void playAlarmSound() { + // 通过RingtoneManager获取系统默认的闹钟铃声的Uri，用于指定MediaPlayer要播放的音频资源 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) { + // 判断静音模式设置中是否影响闹钟音频流，如果影响（对应位的值不为0） + if ((silentModeStreams & (1 << AudioManager.STREAM_ALARM))!= 0) { + // 设置MediaPlayer的音频流类型为获取到的静音模式设置值，按照系统静音模式的相关配置来播放声音 mPlayer.setAudioStreamType(silentModeStreams); } else { + // 如果静音模式不影响闹钟音频流，设置为正常的闹钟音频流类型，确保闹钟声音正常播放 mPlayer.setAudioStreamType(AudioManager.STREAM_ALARM); } + try { + // 设置MediaPlayer的数据源为获取到的铃声Uri，指定要播放的音频文件等资源 mPlayer.setDataSource(this, url); + // 准备MediaPlayer，使其进入可播放状态，这个过程可能涉及加载音频资源、初始化播放相关参数等操作 mPlayer.prepare(); + // 设置MediaPlayer为循环播放模式，使提醒声音能够持续播放，直到用户手动停止或者其他相关逻辑结束播放 mPlayer.setLooping(true); + // 启动MediaPlayer，开始播放提醒声音 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 + // 如果MediaPlayer的状态出现异常（比如在不恰当的状态下执行了某些操作等原因），打印异常堆栈信息 e.printStackTrace(); } catch (IOException e) { - // TODO Auto-generated catch block + // 如果在读取数据源等IO操作过程中出现异常（比如音频文件损坏、无法读取等原因），打印异常堆栈信息 e.printStackTrace(); } } + // 私有方法，用于创建并显示操作对话框，给用户提供相应的操作选项，比如确认、进入编辑等操作 private void showActionDialog() { + // 创建一个AlertDialog的构建器对象，用于方便地构建AlertDialog对话框 AlertDialog.Builder dialog = new AlertDialog.Builder(this); + // 设置对话框的标题，这里使用了字符串资源中的应用名称（R.string.app_name对应的字符串）作为标题 dialog.setTitle(R.string.app_name); + // 设置对话框的消息内容，展示之前获取到的笔记摘要信息，让用户了解是哪个笔记的提醒 dialog.setMessage(mSnippet); + // 设置对话框的确定按钮（通常是一个积极的操作按钮）文本以及点击监听器，点击监听器使用当前类实现的OnClickListener接口， + // 意味着点击该按钮会触发当前类中对应的onClick方法 dialog.setPositiveButton(R.string.notealert_ok, this); + // 如果屏幕处于开启状态，设置对话框的另一个按钮（可能是进入编辑等操作按钮）文本以及点击监听器，同样使用当前类实现的OnClickListener接口 if (isScreenOn()) { dialog.setNegativeButton(R.string.notealert_enter, this); } + // 构建并显示对话框，同时设置对话框的关闭监听器，使用当前类实现的OnDismissListener接口， + // 意味着对话框关闭时会触发当前类中对应的onDismiss方法 dialog.show().setOnDismissListener(this); } + // 实现OnClickListener接口的方法，用于处理对话框按钮的点击事件，根据点击的按钮不同执行相应的逻辑 public void onClick(DialogInterface dialog, int which) { switch (which) { + // 如果点击的是对话框中的否定按钮（具体含义根据设置的文本而定，这里可能是进入编辑按钮等情况） case DialogInterface.BUTTON_NEGATIVE: + // 创建一个Intent，用于启动NoteEditActivity，可能是进入对应的笔记编辑界面，方便用户对笔记进行编辑等操作 Intent intent = new Intent(this, NoteEditActivity.class); + // 设置Intent的动作，这里设置为查看（ACTION_VIEW）动作，表明是查看相关的操作意图 intent.setAction(Intent.ACTION_VIEW); + // 通过Intent的额外数据传递机制，将笔记的ID传递给目标Activity（NoteEditActivity），以便目标Activity能获取并处理对应的笔记 intent.putExtra(Intent.EXTRA_UID, mNoteId); + // 启动目标Activity，跳转到对应的笔记编辑界面 startActivity(intent); break; default: @@ -143,16 +198,23 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD } } + // 实现OnDismissListener接口的方法，当对话框关闭时会被调用，用于执行对话框关闭后的相关操作 public void onDismiss(DialogInterface dialog) { + // 调用stopAlarmSound方法停止播放提醒声音，并释放相关的资源，如MediaPlayer占用的内存等 stopAlarmSound(); + // 结束当前Activity，关闭提醒相关的界面，完成整个提醒流程 finish(); } + // 私有方法，用于停止播放提醒声音，并释放MediaPlayer资源，将其置为null避免后续出现问题 private void stopAlarmSound() { - if (mPlayer != null) { + if (mPlayer!= null) { + // 停止MediaPlayer的播放，如果正在播放声音则立即停止 mPlayer.stop(); + // 释放MediaPlayer占用的资源，使其回到初始未使用状态 mPlayer.release(); + // 将mPlayer对象置为null，防止后续误操作该对象，同时也符合资源释放后的正确使用习惯 mPlayer = null; } } -} +} \ No newline at end of file diff --git a/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/ui/AlarmInitReceiver.java b/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/ui/AlarmInitReceiver.java index f221202..69cc9a8 100644 --- a/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/ui/AlarmInitReceiver.java +++ b/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/ui/AlarmInitReceiver.java @@ -14,6 +14,7 @@ * limitations under the License. */ +// 包声明，表明该类属于net.micode.notes.ui包，通常与应用的用户界面相关模块放在一起，不过从类名来看，这个类更偏向于处理提醒相关的逻辑，属于UI层与业务逻辑交互的部分 package net.micode.notes.ui; import android.app.AlarmManager; @@ -27,39 +28,64 @@ import android.database.Cursor; import net.micode.notes.data.Notes; import net.micode.notes.data.Notes.NoteColumns; - +// AlarmInitReceiver类继承自BroadcastReceiver，用于接收系统广播消息，在这里可能是用于处理与提醒初始化相关的广播事件 public class AlarmInitReceiver extends BroadcastReceiver { - private static final String [] PROJECTION = new String [] { - NoteColumns.ID, - NoteColumns.ALERTED_DATE + // 定义一个字符串数组，用于指定查询数据库时要获取的列，这里只获取笔记的ID和提醒日期两列信息，方便后续操作使用 + private static final String[] PROJECTION = new String[]{ + NoteColumns.ID, + NoteColumns.ALERTED_DATE }; - private static final int COLUMN_ID = 0; - private static final int COLUMN_ALERTED_DATE = 1; + // 定义一个常量，表示查询结果中笔记ID列对应的索引位置，方便后续从游标（Cursor）中获取对应的数据，这里索引为0，因为在PROJECTION数组中它排在第一位 + private static final int COLUMN_ID = 0; + // 定义一个常量，表示查询结果中提醒日期列对应的索引位置，同样方便从游标中获取对应的数据，这里索引为1，因为在PROJECTION数组中它排在第二位 + private static final int COLUMN_ALERTED_DATE = 1; + // 重写BroadcastReceiver的onReceive方法，该方法会在接收到匹配的广播消息时被调用，是处理广播逻辑的核心方法 @Override public void onReceive(Context context, Intent intent) { + // 获取当前系统时间的毫秒数，用于后续与笔记的提醒日期进行比较，判断哪些笔记的提醒时间已经到了或者即将到了 long currentDate = System.currentTimeMillis(); + + // 通过ContentResolver查询笔记内容提供器（Notes.CONTENT_NOTE_URI），获取满足条件的笔记数据 + // 查询的列由PROJECTION数组指定，查询条件是提醒日期大于当前日期并且笔记类型为普通笔记类型（Notes.TYPE_NOTE） + // 查询条件中的参数使用当前日期的字符串表示形式传入，最后一个参数null表示不需要排序等额外设置 Cursor c = context.getContentResolver().query(Notes.CONTENT_NOTE_URI, PROJECTION, NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE, - new String[] { String.valueOf(currentDate) }, + new String[]{String.valueOf(currentDate)}, null); - if (c != null) { + // 如果查询结果游标不为null，说明查询到了符合条件的笔记数据 + if (c!= null) { + // 将游标移动到第一条记录位置，如果有数据则可以开始遍历获取每一条记录的信息 if (c.moveToFirst()) { do { + // 从游标中获取当前笔记记录的提醒日期（根据之前定义的列索引COLUMN_ALERTED_DATE），并转换为长整型 long alertDate = c.getLong(COLUMN_ALERTED_DATE); + + // 创建一个Intent对象，用于启动另一个广播接收者（AlarmReceiver），这个Intent携带了与当前笔记相关的信息， + // 比如通过设置Data属性，将当前笔记的ID添加到Uri中，以便目标广播接收者能识别是哪个笔记的提醒操作 Intent sender = new Intent(context, AlarmReceiver.class); sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(COLUMN_ID))); + + // 创建一个PendingIntent对象，用于包装前面创建的Intent，使得这个意图可以在未来某个时间点被触发， + // 这里的参数0表示请求码（通常用于区分不同的PendingIntent，如果不需要区分可以设为0），最后一个参数0表示标志位，采用默认设置 PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, 0); + + // 获取系统的AlarmManager服务对象，用于设置和管理闹钟提醒相关的操作 AlarmManager alermManager = (AlarmManager) context - .getSystemService(Context.ALARM_SERVICE); + .getSystemService(Context.ALARM_SERVICE); + + // 通过AlarmManager设置一个闹钟提醒，使用RTC_WAKEUP模式（表示在指定的绝对时间唤醒设备来触发提醒，即使设备处于睡眠状态）， + // 指定提醒的时间为前面获取到的alertDate（即笔记的提醒日期对应的时间戳），以及对应的PendingIntent（包含了要执行的意图操作） alermManager.set(AlarmManager.RTC_WAKEUP, alertDate, pendingIntent); - } while (c.moveToNext()); + + } while (c.moveToNext()); // 循环处理游标中的每一条记录，直到遍历完所有符合条件的笔记记录 } + // 关闭游标，释放查询占用的资源，避免内存泄漏等问题 c.close(); } } -} +} \ No newline at end of file diff --git a/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/ui/AlarmReceiver.java b/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/ui/AlarmReceiver.java index 54e503b..63c9f56 100644 --- a/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/ui/AlarmReceiver.java +++ b/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/ui/AlarmReceiver.java @@ -14,17 +14,31 @@ * limitations under the License. */ +// 包声明，表明该类所属的包名为net.micode.notes.ui，通常用于存放与应用用户界面相关的各类组件等代码 package net.micode.notes.ui; import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; +// AlarmReceiver类继承自BroadcastReceiver，BroadcastReceiver用于接收系统或应用发出的广播消息， +// 这里的AlarmReceiver大概率是专门用于接收与闹钟提醒相关广播的类，进而做出相应的响应操作 public class AlarmReceiver extends BroadcastReceiver { + + // 重写BroadcastReceiver的onReceive方法，该方法会在接收到匹配的广播消息时被调用，是实现广播接收逻辑的核心方法 @Override public void onReceive(Context context, Intent intent) { + // 通过Intent的setClass方法，重新设置这个Intent要启动的目标Activity类为AlarmAlertActivity， + // 意味着原本接收到的广播意图将会被转换为启动AlarmAlertActivity的意图， + // 通常是因为接收到闹钟提醒广播后，需要展示对应的提醒界面，而AlarmAlertActivity就是用于展示提醒相关界面的 intent.setClass(context, AlarmAlertActivity.class); + + // 给Intent添加一个标志位Intent.FLAG_ACTIVITY_NEW_TASK，这个标志位的作用是让即将启动的Activity在一个新的任务栈中启动， + // 因为广播接收者的执行环境可能没有默认的任务栈关联，添加此标志可以确保Activity能正常启动并显示，避免出现启动相关的问题 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + + // 使用传入的Context对象启动之前设置好的Intent，也就是启动AlarmAlertActivity， + // 这样就会从广播接收逻辑跳转到对应的提醒界面展示逻辑，完成闹钟提醒触发后展示提醒界面的流程 context.startActivity(intent); } -} +} \ No newline at end of file diff --git a/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider.java b/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider.java index ec6f819..64c0023 100644 --- a/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider.java +++ b/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider.java @@ -14,7 +14,9 @@ * limitations under the License. */ +// 包声明，表明该类所属的包名为net.micode.notes.widget，通常用于存放与桌面小部件（Widget）相关的代码逻辑 package net.micode.notes.widget; + import android.app.PendingIntent; import android.appwidget.AppWidgetManager; import android.appwidget.AppWidgetProvider; @@ -32,101 +34,145 @@ 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、背景颜色ID以及摘要信息，方便后续在小部件中展示相关内容 + 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; + // 定义一个常量，表示查询结果中笔记ID列对应的索引位置，方便后续从游标（Cursor）中准确获取该列的数据，索引为0是因为在PROJECTION数组中它排在第一位 + public static final int COLUMN_ID = 0; + // 定义一个常量，表示查询结果中背景颜色ID列对应的索引位置，用于从游标中获取背景颜色相关信息，索引为1对应其在PROJECTION数组中的位置 + public static final int COLUMN_BG_COLOR_ID = 1; + // 定义一个常量，表示查询结果中摘要信息列对应的索引位置，用于获取笔记的摘要内容，索引为2表示其在PROJECTION数组中的顺序位置 + public static final int COLUMN_SNIPPET = 2; + // 定义一个用于日志记录的标签字符串，方便在日志中识别该类输出的相关信息，便于调试和查看运行情况 private static final String TAG = "NoteWidgetProvider"; + // 重写AppWidgetProvider的onDeleted方法，该方法会在小部件被删除时被调用，用于处理小部件删除后的相关逻辑 @Override public void onDeleted(Context context, int[] appWidgetIds) { + // 创建一个ContentValues对象，用于存储要更新到数据库中的键值对数据 ContentValues values = new ContentValues(); + // 将笔记对应的小部件ID设置为无效值（AppWidgetManager.INVALID_APPWIDGET_ID），表示该笔记与小部件的关联已解除 values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID); + + // 遍历被删除的小部件ID数组，对每个小部件ID执行以下操作 for (int i = 0; i < appWidgetIds.length; i++) { + // 通过ContentResolver更新笔记内容提供器（Notes.CONTENT_NOTE_URI）中的数据， + // 更新条件是笔记的小部件ID与当前遍历到的小部件ID匹配，将对应的笔记记录中的小部件ID设置为无效值 context.getContentResolver().update(Notes.CONTENT_NOTE_URI, values, NoteColumns.WIDGET_ID + "=?", - new String[] { String.valueOf(appWidgetIds[i])}); + new String[]{String.valueOf(appWidgetIds[i])}); } } + // 私有方法，用于根据给定的小部件ID从数据库中获取该小部件相关的笔记信息（如笔记ID、背景颜色、摘要等），返回一个游标（Cursor）对象用于遍历查询结果 private Cursor getNoteWidgetInfo(Context context, int widgetId) { return context.getContentResolver().query(Notes.CONTENT_NOTE_URI, PROJECTION, NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?", - new String[] { String.valueOf(widgetId), String.valueOf(Notes.ID_TRASH_FOLER) }, + new String[]{String.valueOf(widgetId), String.valueOf(Notes.ID_TRASH_FOLER)}, null); } + // 受保护的方法，用于更新小部件的显示内容，它调用了另一个重载的update方法，并传入默认的隐私模式参数（false） protected void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) { update(context, appWidgetManager, appWidgetIds, false); } + // 私有方法，用于实际更新小部件的显示内容，根据传入的小部件ID数组，逐个更新对应的小部件显示情况，同时可以根据隐私模式参数进行不同的显示设置 private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds, - boolean privacyMode) { + boolean privacyMode) { + // 遍历小部件ID数组，对每个有效的小部件ID执行更新操作 for (int i = 0; i < appWidgetIds.length; i++) { - if (appWidgetIds[i] != AppWidgetManager.INVALID_APPWIDGET_ID) { + if (appWidgetIds[i]!= AppWidgetManager.INVALID_APPWIDGET_ID) { + // 获取默认的背景颜色ID，通过ResourceParser工具类的方法来获取，可能根据用户设置等情况返回相应的颜色标识 int bgId = ResourceParser.getDefaultBgId(context); + // 初始化笔记摘要信息为空字符串，后续根据查询结果进行更新 String snippet = ""; + // 创建一个Intent对象，用于启动NoteEditActivity，可能是点击小部件后跳转到笔记编辑页面等相关操作，具体行为由后续设置决定 Intent intent = new Intent(context, NoteEditActivity.class); + // 设置Intent的标志位，使得如果对应的Activity已经在栈顶，就不会重新创建新的实例，而是复用已有的实例 intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP); + // 将当前小部件的ID通过Intent的额外数据传递机制传递给目标Activity，以便目标Activity能识别是哪个小部件触发的操作 intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]); + // 将小部件的类型通过Intent的额外数据传递给目标Activity，具体类型由子类实现的抽象方法getWidgetType来确定 intent.putExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, getWidgetType()); + // 通过前面定义的方法获取当前小部件相关的笔记信息游标 Cursor c = getNoteWidgetInfo(context, appWidgetIds[i]); - if (c != null && c.moveToFirst()) { + if (c!= null && c.moveToFirst()) { + // 如果查询到的笔记记录数量大于1，说明存在多条笔记对应同一个小部件ID的异常情况，记录错误日志并关闭游标，直接返回，不进行后续更新操作 if (c.getCount() > 1) { Log.e(TAG, "Multiple message with same widget id:" + appWidgetIds[i]); c.close(); return; } + // 获取笔记的摘要信息，从游标中根据之前定义的列索引（COLUMN_SNIPPET）获取对应的数据 snippet = c.getString(COLUMN_SNIPPET); + // 获取笔记对应的背景颜色ID，从游标中根据列索引（COLUMN_BG_COLOR_ID）获取对应的数据，并更新之前获取的默认背景颜色ID bgId = c.getInt(COLUMN_BG_COLOR_ID); + // 将笔记的ID通过Intent的额外数据传递给目标Activity，以便在编辑页面等操作中能准确操作对应的笔记 intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID)); + // 设置Intent的动作，这里设置为查看（ACTION_VIEW）动作，表示点击小部件后可能是查看对应笔记的操作意图 intent.setAction(Intent.ACTION_VIEW); } else { + // 如果没有查询到对应的笔记信息，设置摘要信息为一个默认的提示字符串，表示小部件暂无内容 snippet = context.getResources().getString(R.string.widget_havenot_content); + // 设置Intent的动作，这里设置为插入或编辑（ACTION_INSERT_OR_EDIT）动作，可能意味着点击小部件后可以进行新建或编辑笔记的操作 intent.setAction(Intent.ACTION_INSERT_OR_EDIT); } - if (c != null) { + // 如果游标不为null，关闭游标释放资源，避免内存泄漏等问题 + if (c!= null) { c.close(); } + // 创建一个RemoteViews对象，用于构建小部件的远程视图，传入应用的包名和小部件的布局ID（由子类实现的抽象方法getLayoutId来确定） RemoteViews rv = new RemoteViews(context.getPackageName(), getLayoutId()); + // 设置小部件中背景图片资源的ID，通过调用抽象方法getBgResourceId传入背景颜色ID来获取对应的资源ID，以显示正确的背景图片 rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId)); + // 将背景颜色ID通过Intent的额外数据传递给目标Activity，方便后续根据颜色进行相关操作或显示调整 intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId); - /** - * Generate the pending intent to start host for the widget - */ + + // 生成一个PendingIntent对象，用于包装前面创建的Intent，使得点击小部件时能触发对应的操作，根据隐私模式进行不同的设置 PendingIntent pendingIntent = null; if (privacyMode) { + // 如果处于隐私模式，设置小部件文本显示的内容为一个特定的隐私提示字符串 rv.setTextViewText(R.id.widget_text, context.getString(R.string.widget_under_visit_mode)); + // 创建一个PendingIntent，用于启动NotesListActivity，可能在隐私模式下点击小部件跳转到笔记列表页面等操作 pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], new Intent( context, NotesListActivity.class), PendingIntent.FLAG_UPDATE_CURRENT); } else { + // 如果不处于隐私模式，设置小部件文本显示的内容为之前获取或设置的笔记摘要信息 rv.setTextViewText(R.id.widget_text, snippet); + // 创建一个PendingIntent，用于启动之前设置的Intent对应的Activity（根据不同情况可能是编辑页面、查看页面等） pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], intent, PendingIntent.FLAG_UPDATE_CURRENT); } + // 设置小部件文本视图的点击事件PendingIntent，使得点击文本时能触发对应的操作 rv.setOnClickPendingIntent(R.id.widget_text, pendingIntent); + // 通过AppWidgetManager更新指定小部件ID对应的小部件显示内容，应用前面设置好的RemoteViews对象 appWidgetManager.updateAppWidget(appWidgetIds[i], rv); } } } + // 抽象方法，需要由具体的子类实现，根据传入的背景颜色ID返回对应的背景资源ID，用于设置小部件的背景图片等显示资源 protected abstract int getBgResourceId(int bgId); + // 抽象方法，需要由具体的子类实现，返回小部件对应的布局资源ID，用于创建RemoteViews对象来构建小部件的远程视图显示 protected abstract int getLayoutId(); + // 抽象方法，需要由具体的子类实现，返回小部件的类型信息，具体类型由子类根据业务逻辑定义，用于在Intent等操作中传递和区分不同类型的小部件 protected abstract int getWidgetType(); -} +} \ No newline at end of file diff --git a/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_2x.java b/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_2x.java index adcb2f7..97a8bba 100644 --- a/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_2x.java +++ b/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_2x.java @@ -14,6 +14,7 @@ * limitations under the License. */ +// 包声明，表明该类属于net.micode.notes.widget包，通常用于存放与桌面小部件相关的具体实现类 package net.micode.notes.widget; import android.appwidget.AppWidgetManager; @@ -23,25 +24,37 @@ import net.micode.notes.R; import net.micode.notes.data.Notes; import net.micode.notes.tool.ResourceParser; - +// NoteWidgetProvider_2x类继承自NoteWidgetProvider抽象类，意味着它需要实现NoteWidgetProvider中定义的抽象方法， +// 它是专门针对某种特定尺寸（从类名推测可能是2倍尺寸）桌面小部件的具体实现类 public class NoteWidgetProvider_2x extends NoteWidgetProvider { + + // 重写父类的onUpdate方法，该方法会在小部件需要更新时被调用（例如小部件首次添加到桌面、系统要求更新小部件等情况） @Override public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) { + // 调用父类的update方法来执行小部件更新的通用逻辑，将具体的更新操作交给父类中定义的update方法处理， + // 这样可以复用父类中关于更新小部件显示内容、设置点击事件等相关的逻辑代码 super.update(context, appWidgetManager, appWidgetIds); } + // 实现父类中定义的抽象方法getLayoutId，用于返回该小部件对应的布局资源ID，这里返回的是R.layout.widget_2x， + // 意味着该小部件使用名为widget_2x的布局文件来进行界面显示布局定义，不同的布局文件可以包含不同的视图控件、排列方式等 @Override protected int getLayoutId() { return R.layout.widget_2x; } + // 实现父类中定义的抽象方法getBgResourceId，根据传入的背景颜色ID（bgId）获取对应的背景资源ID， + // 这里通过调用ResourceParser.WidgetBgResources类中的方法来获取，具体是获取2倍尺寸小部件对应的背景资源ID， + // 使得小部件能根据不同的背景颜色ID显示相应的背景图片等资源 @Override protected int getBgResourceId(int bgId) { return ResourceParser.WidgetBgResources.getWidget2xBgResource(bgId); } + // 实现父类中定义的抽象方法getWidgetType，返回该小部件的类型标识，这里返回的是Notes.TYPE_WIDGET_2X， + // 用于区分不同尺寸、不同类型的小部件，在应用中可以根据这个类型标识来进行不同的业务逻辑处理，比如不同的显示样式、功能操作等 @Override protected int getWidgetType() { return Notes.TYPE_WIDGET_2X; } -} +} \ No newline at end of file diff --git a/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_4x.java b/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_4x.java index c12a02e..032239a 100644 --- a/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_4x.java +++ b/源程序代码-小米便签-Notes-master/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_4x.java @@ -14,6 +14,7 @@ * limitations under the License. */ +// 包声明，表明该类所属的包名为net.micode.notes.widget，通常用于存放与桌面小部件相关的具体实现类，从类名NoteWidgetProvider_4x推测，这是针对特定尺寸（可能是4倍尺寸）小部件的相关实现类 package net.micode.notes.widget; import android.appwidget.AppWidgetManager; @@ -23,24 +24,36 @@ import net.micode.notes.R; import net.micode.notes.data.Notes; import net.micode.notes.tool.ResourceParser; - +// NoteWidgetProvider_4x类继承自NoteWidgetProvider抽象类，需要实现抽象类中定义的抽象方法，以提供针对特定类型（这里可能是4倍尺寸小部件）的具体功能实现 public class NoteWidgetProvider_4x extends NoteWidgetProvider { + + // 重写父类的onUpdate方法，该方法会在桌面小部件需要更新时被调用，例如系统触发小部件更新（如时间间隔到了、配置变化等情况），或者用户手动触发小部件更新操作时 @Override public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) { + // 通过调用父类的update方法来执行小部件更新的通用逻辑，复用父类中已定义好的更新操作流程，比如设置小部件的显示内容、点击事件等相关逻辑， + // 子类只需关注自身特有的部分（如特定布局、资源获取等）即可，这样可以提高代码的复用性和可维护性 super.update(context, appWidgetManager, appWidgetIds); } + // 重写父类中定义的抽象方法getLayoutId，用于返回该4倍尺寸小部件对应的布局资源ID，这里返回的是R.layout.widget_4x， + // 意味着该小部件会使用名为widget_4x的布局文件来进行界面的显示布局设置，这个布局文件中定义了小部件在桌面上展示的具体视图结构、控件摆放等内容 protected int getLayoutId() { return R.layout.widget_4x; } + // 重写父类中定义的抽象方法getBgResourceId，该方法根据传入的背景颜色标识ID（bgId）来获取对应的背景资源ID， + // 这里借助ResourceParser.WidgetBgResources类中的方法来获取，具体是获取适用于4倍尺寸小部件的背景资源ID， + // 从而可以根据不同的背景颜色设置来展示相应的背景图片等资源，使小部件的外观符合预期的设计要求 @Override protected int getBgResourceId(int bgId) { return ResourceParser.WidgetBgResources.getWidget4xBgResource(bgId); } + // 重写父类中定义的抽象方法getWidgetType，返回该小部件的类型标识，这里返回的是Notes.TYPE_WIDGET_4X， + // 这个类型标识可以用于在整个应用中区分不同尺寸、不同功能特性的小部件，比如在处理小部件相关的业务逻辑时，根据不同的类型执行不同的操作， + // 像显示不同的内容、提供不同的交互功能等，有助于实现小部件功能的差异化和定制化 @Override protected int getWidgetType() { return Notes.TYPE_WIDGET_4X; } -} +} \ No newline at end of file