pcs8ovtw5
/
test
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity

注释代码

Browse Source 
Signed-off-by: 张建忠 <a17853992082@163.com>
zjz
zjz 8 months ago
parent 85491d31c4
commit abe758f08e
10 changed files with 680 additions and 456 deletions
Show Stats Download Patch File Download Diff File

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

@ -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;
}
}
}

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

@ -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<Long> 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<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
// 遍历要删除的笔记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<Long> ids,
long folderId) {
// 如果传入的笔记ID集合为null，记录日志并返回true（可能表示无需进行移动操作的情况）
if (ids == null) {
Log.d(TAG, "the ids is null");
return true;
}
// 创建一个用于存储内容提供器操作的列表，后续将批量执行这些操作来移动笔记
ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
// 遍历要移动的笔记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<AppWidgetAttribute> 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<AppWidgetAttribute> set = null;
if (c != null) {
// 如果游标不为null，表示查询到了结果
if (c!= null) {
// 将游标移动到第一条记录
if (c.moveToFirst()) {
set = new HashSet<AppWidgetAttribute>();
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获取对应的摘要信息的方法

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

@ -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";
}
}

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

@ -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;
}
}
}
}

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

@ -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;
}
}
}
}

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

@ -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();
}
}
}
}

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

@ -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);
}
}
}

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

@ -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();
}
}

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

@ -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;
}
}
}

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

@ -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;
}
}
}
Write Preview
Loading…
Cancel
Save