p873bi2r9
/
minoteGPZ
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request '注释' (#2) from zyc_branch into main

Browse Source
pull/3/head
p873bi2r9 2 years ago
parent 7b21c09c68 9f9fe2da56
commit 6afd900f2f
2 changed files with 409 additions and 82 deletions
Show Stats Download Patch File Download Diff File

310
src/main/java/net/micode/notes/ui/NoteEditActivity.java
Unescape View File

@ -14,6 +14,8 @@
* limitations under the License.
*/
/*NoteEditActivity类实现了便签的编辑活动*/
package net.micode.notes.ui;
import android.app.Activity;
@ -71,19 +73,28 @@ import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**NoteEditActivity继承了Android库中的Activity类
*并实现了OnClickListener,NoteSettingChangedListener, OnTextViewChangeListener这三个接口
*这表明该活动可以处理单击事件、侦听笔记设置中的更改并响应文本视图中的更改。*/
public class NoteEditActivity extends Activity implements OnClickListener,
NoteSettingChangedListener, OnTextViewChangeListener {
/*此类用于保存对与活动头相关的各种 UI 元素的引用*/
private class HeadViewHolder {
public TextView tvModified;
//一个 TextView，用于显示关于笔记的最后一次修改的信息。
public ImageView ivAlertIcon;
//一个用于显示警告标识的 ImageView，可能指示提醒或重要注释状态。
public TextView tvAlertDate;
//用于显示与警报关联的日期的 TextView。
public ImageView ibSetBgColor;
//一个 ImageView，是一个用于设置背景颜色的按钮
}
/**函数定义了一个静态的、不可变的Map对象sBgSelectorBtnsMap，并在静态初始化块时往其中放入了键值对。
* 键是控件的id，R.id是用于访问应用程序资源的标识符，通过R.id可以在代码中引用对应的控件进行操作
* 值是ResourceParser类(界面元素的解析工具类，通过R.java这个类撷取资源供程序调用)中定义的有关颜色常量。
* 这样就可以通过控件的id快速获取对应的常量值，从而进行相应的操作*/
private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<Integer, Integer>();
static {
sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW);
@ -93,6 +104,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sBgSelectorBtnsMap.put(R.id.iv_bg_white, ResourceParser.WHITE);
}
/**初始化静态Map对象sBgSelectorSelectionMap
* 键是ResourceParser类中定义的有关颜色常量
* 值是控件的id
* 这样就可以通过常量值快速获取对应的控件的id，从而进行相应的操作*/
private static final Map<Integer, Integer> sBgSelectorSelectionMap = new HashMap<Integer, Integer>();
static {
sBgSelectorSelectionMap.put(ResourceParser.YELLOW, R.id.iv_bg_yellow_select);
@ -102,6 +117,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sBgSelectorSelectionMap.put(ResourceParser.WHITE, R.id.iv_bg_white_select);
}
/**初始化静态Map对象sFontSizeBtnsMap
* 键是控件的id
* 值是ResourceParser类中定义的有关字体大小常量
* 这样就可以通过控件的id快速获取对应的常量值，从而进行相应的操作*/
private static final Map<Integer, Integer> sFontSizeBtnsMap = new HashMap<Integer, Integer>();
static {
sFontSizeBtnsMap.put(R.id.ll_font_large, ResourceParser.TEXT_LARGE);
@ -110,6 +129,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sFontSizeBtnsMap.put(R.id.ll_font_super, ResourceParser.TEXT_SUPER);
}
/**初始化静态Map对象sFontSelectorSelectionMap
* 键是ResourceParser类中定义的有关字体大小常量
* 值是控件的id
* 这样就可以通过常量值快速获取对应的控件的id，从而进行相应的操作*/
private static final Map<Integer, Integer> sFontSelectorSelectionMap = new HashMap<Integer, Integer>();
static {
sFontSelectorSelectionMap.put(ResourceParser.TEXT_LARGE, R.id.iv_large_select);
@ -119,9 +142,15 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
private static final String TAG = "NoteEditActivity";
/**私有静态常量字符串TAG，并赋值为"NoteEditActivity"。
* 通常用于在代码中标识日志输出或调试信息的来源，可以帮助开发者更容易地识别和过滤特定的日志输出。
* Log.d和Log.e是Android中的日志记录方法。它们用于在开发过程中输出调试信息和错误信息。
* Log.d用于输出调试消息，通常用于输出一些调试信息，而Log.e用于输出错误消息，通常用于输出一些错误信息或异常信息。
* 这些日志信息可以帮助开发人员在开发和测试过程中进行调试和故障排除。*/
//保存头部视图的UI元素
private HeadViewHolder mNoteHeaderHolder;
//声明与注释编辑器相关的各种UI元素和数据的成员变量
private View mHeadViewPanel;
private View mNoteBgColorSelector;
@ -132,23 +161,37 @@ public class NoteEditActivity extends Activity implements OnClickListener,
private View mNoteEditorPanel;
//表示正在编辑的工作笔记的对象
private WorkingNote mWorkingNote;
// SharedPreferences用于存储和检索用户首选项
private SharedPreferences mSharedPrefs;
//变量存储选定的字体大小ID
private int mFontSizeId;
// SharedPreferences中与字体大小相关的首选项键的常量字符串
private static final String PREFERENCE_FONT_SIZE = "pref_font_size";
//常量定义快捷图标标题的最大长度
private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10;
//使用特殊的Unicode字符表示选中和未选中状态的常量
public static final String TAG_CHECKED = String.valueOf('\u221A');
public static final String TAG_UNCHECKED = String.valueOf('\u25A1');
//用于保存EditText元素列表的LinearLayout
private LinearLayout mEditTextList;
//存储用户查询的字符串变量
private String mUserQuery;
//用于模式匹配的模式对象(未在提供的代码片段中初始化)
private Pattern mPattern;
/**在创建活动时调用 onCreate 方法
* 并将内容视图设置为指定的布局。然后它检查活动是否是第一次创建
* 并根据意图初始化其状态。如果初始化失败，则活动完成*/
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
@ -165,6 +208,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
* Current activity may be killed when the memory is low. Once it is killed, for another time
* user load this activity, we should restore the former state
*/
/**
* 该方法在活动需要恢复其状态时调用，特别是在由于内存不足而被终止之后。
* 它检查保存的实例状态中是否存在密钥，并尝试基于意图恢复活动状态。
* 如果恢复失败，则活动完成。包括调试日志记录，以指示活动何时从先前已终止的状态恢复。
*/
@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState);
@ -179,6 +228,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
/**
* 这个函数主要实现了初始化Activity状态的功能。
* 它检查传入的Intent是否为ACTION_VIEW，如果是则从Intent中获取ID并进行相应的处理；如果不是则记录错误信息并结束Activity。
* 最后，它设置了监听器并返回了一个布尔值表示初始化状态的结果。*/
private boolean initActivityState(Intent intent) {
/**
* If the user specified the {@link Intent#ACTION_VIEW} but not provided with id,
@ -262,12 +315,17 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return true;
}
/**
*当activity恢复时，调用 initNoteScreen ()来设置便笺编辑器和相关的 UI 组件,初始化note屏幕*/
@Override
protected void onResume() {
super.onResume();
initNoteScreen();
}
/**
* InitNoteScreen方法根据笔记类型(检查表或常规文本)配置笔记编辑器的各个方面，
* 设置文本外观，处理背景视图，设置时间戳，并包括一个用于设置警报的占位符(由于 DateTimePicker 不可用，当前禁用)。*/
private void initNoteScreen() {
mNoteEditor.setTextAppearance(this, TextAppearanceResources
.getTexAppearanceResource(mFontSizeId));
@ -295,6 +353,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
showAlertHeader();
}
/**
* 此方法根据mWorkingNote中时钟警报的存在和过期状态处理UI中警报的可见性和文本设置。*/
private void showAlertHeader() {
if (mWorkingNote.hasClockAlert()) {
long time = System.currentTimeMillis();
@ -312,12 +372,17 @@ public class NoteEditActivity extends Activity implements OnClickListener,
};
}
/**
* 对于在清单中将 launchMode 设置为“ singleTop”的活动，调用此方法。这里使用它来初始化具有新意图的活动状态。*/
@Override
protected void onNewIntent(Intent intent) {
super.onNewIntent(intent);
initActivityState(intent);
}
/**
* 调用此方法以保存活动的当前状态。它检查数据库中是否存在工作说明。
* 如果没有，它将保存注释以生成 ID。注释 ID 随后添加到 outState 包，并添加一条日志语句以进行调试。*/
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
@ -333,6 +398,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
Log.d(TAG, "Save working note id: " + mWorkingNote.getNoteId() + " onSaveInstanceState");
}
/**检查背景颜色选择器是否可见，触摸事件是否在其边界之外*/
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
if (mNoteBgColorSelector.getVisibility() == View.VISIBLE
@ -349,6 +415,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return super.dispatchTouchEvent(ev);
}
/**检查MotionEvent是否在View的边界内的Helper方法
* 返回值是一个bool量*/
private boolean inRangeOfView(View view, MotionEvent ev) {
int []location = new int[2];
view.getLocationOnScreen(location);
@ -363,28 +431,39 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return true;
}
/**
* 初始化活动使用的资源。*/
private void initResources() {
//查找和设置头部视图面板
mHeadViewPanel = findViewById(R.id.note_title);
//初始化注释头视图的holder
mNoteHeaderHolder = new HeadViewHolder();
//在holder中查找并设置各种注释头视图
mNoteHeaderHolder.tvModified = (TextView) findViewById(R.id.tv_modified_date);
mNoteHeaderHolder.ivAlertIcon = (ImageView) findViewById(R.id.iv_alert_icon);
mNoteHeaderHolder.tvAlertDate = (TextView) findViewById(R.id.tv_alert_date);
mNoteHeaderHolder.ibSetBgColor = (ImageView) findViewById(R.id.btn_set_bg_color);
mNoteHeaderHolder.ibSetBgColor.setOnClickListener(this);
//查找并设置注释编辑器及其父面板
mNoteEditor = (EditText) findViewById(R.id.note_edit_view);
mNoteEditorPanel = findViewById(R.id.sv_note_edit);
//查找并设置音符背景颜色选择器
mNoteBgColorSelector = findViewById(R.id.note_bg_color_selector);
//遍历后台选择器按钮并设置点击监听器
for (int id : sBgSelectorBtnsMap.keySet()) {
ImageView iv = (ImageView) findViewById(id);
iv.setOnClickListener(this);
}
//查找并设置字体大小选择器
mFontSizeSelector = findViewById(R.id.font_size_selector);
//遍历字体大小按钮并设置单击侦听器
for (int id : sFontSizeBtnsMap.keySet()) {
View view = findViewById(id);
view.setOnClickListener(this);
};
//初始化SharedPreferences用于存储首选项
mSharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);
//使用默认值检索字体大小首选项
mFontSizeId = mSharedPrefs.getInt(PREFERENCE_FONT_SIZE, ResourceParser.BG_DEFAULT_FONT_SIZE);
/**
* HACKME: Fix bug of store the resource id in shared preference.
@ -394,53 +473,74 @@ public class NoteEditActivity extends Activity implements OnClickListener,
if(mFontSizeId >= TextAppearanceResources.getResourcesSize()) {
mFontSizeId = ResourceParser.BG_DEFAULT_FONT_SIZE;
}
//查找并设置edittext列表的线性布局
mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list);
}
/**
*当活动暂停时调用。覆盖Android生命周期中的onPause方法。
*在活动暂停之前执行必要的操作。*/
@Override
protected void onPause() {
super.onPause();
//如果saveNote()方法返回true，则保存当前笔记数据
if(saveNote()) {
Log.d(TAG, "Note data was saved with length:" + mWorkingNote.getContent().length());
}
//清除所有设置状态
clearSettingState();
}
/**
* 更新与当前笔记相关的应用程序小部件。
* 构造一个意图来更新应用小部件并广播它*/
private void updateWidget() {
//为应用小部件更新创建一个intent
Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
//根据小部件类型设置小部件提供程序的类
if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_2X) {
intent.setClass(this, NoteWidgetProvider_2x.class);
} else if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_4X) {
intent.setClass(this, NoteWidgetProvider_4x.class);
} else {
//记录不支持的小部件类型的错误，并从方法返回
Log.e(TAG, "Unspported widget type");
return;
}
//向intent中添加widget ID
intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] {
mWorkingNote.getWidgetId()
});
//广播更新应用小部件的意图
sendBroadcast(intent);
//设置活动的结果来表示成功
setResult(RESULT_OK, intent);
}
/**
*处理活动中各种视图的点击事件。
* @param v 被点击的视图 */
public void onClick(View v) {
int id = v.getId();
//检查“设置背景色”按钮是否被点击
if (id == R.id.btn_set_bg_color) {
//显示背景颜色选择器并设置所选颜色的可见性
mNoteBgColorSelector.setVisibility(View.VISIBLE);
findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
- View.VISIBLE);
View.VISIBLE);
} else if (sBgSelectorBtnsMap.containsKey(id)) {
//检查背景颜色选择器按钮是否被点击。隐藏当前选择的颜色，设置新颜色，隐藏选择器
findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
View.GONE);
mWorkingNote.setBgColorId(sBgSelectorBtnsMap.get(id));
mNoteBgColorSelector.setVisibility(View.GONE);
} else if (sFontSizeBtnsMap.containsKey(id)) {
//检查字体大小选择器按钮是否被点击。隐藏当前选择的字体大小，设置新的大小，并显示新的选择
findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.GONE);
mFontSizeId = sFontSizeBtnsMap.get(id);
mSharedPrefs.edit().putInt(PREFERENCE_FONT_SIZE, mFontSizeId).commit();
findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
//处理基于检查表模式或常规模式的字体大小更改
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
getWorkingText();
switchToListMode(mWorkingNote.getContent());
@ -448,31 +548,46 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mNoteEditor.setTextAppearance(this,
TextAppearanceResources.getTexAppearanceResource(mFontSizeId));
}
//隐藏字体大小选择器
mFontSizeSelector.setVisibility(View.GONE);
}
}
/**
*覆盖onBackPressed方法，在完成活动之前处理特定的动作。*/
@Override
public void onBackPressed() {
//在完成活动之前检查并清除任何设置状态
if(clearSettingState()) {
return;
}
//保存当前笔记并调用父类方法
saveNote();
super.onBackPressed();
}
/**
* 通过隐藏背景颜色或字体大小选择器(如果可见)清除设置状态。
* 返回True如果任何设置状态被清除，否则返回false。*/
private boolean clearSettingState() {
//如果背景颜色选择器可见，检查并隐藏
if (mNoteBgColorSelector.getVisibility() == View.VISIBLE) {
mNoteBgColorSelector.setVisibility(View.GONE);
return true;
} else if (mFontSizeSelector.getVisibility() == View.VISIBLE) {
//如果可见，检查并隐藏字体大小选择器
mFontSizeSelector.setVisibility(View.GONE);
return true;
}
//如果未清除设置状态，则返回false
return false;
}
/***
* 此方法负责处理便笺背景颜色的更改。
* 它找到与工作笔记的背景颜色 ID 对应的视图，并将其可见性设置为 VISIBLE。
* 它将笔记编辑器面板的背景资源和头视图面板分别设置为工作笔记的背景颜色和标题背景资源 ID。
*/
public void onBackgroundColorChanged() {
findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
View.VISIBLE);
@ -480,37 +595,51 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
}
/**
* 在显示选项菜单之前调用此方法。*/
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
//检查活动是否结束，如果是，返回true
if (isFinishing()) {
return true;
}
//清除设置状态并从菜单中删除所有项目
clearSettingState();
menu.clear();
//根据工作笔记的文件夹ID膨胀适当的菜单
if (mWorkingNote.getFolderId() == Notes.ID_CALL_RECORD_FOLDER) {
getMenuInflater().inflate(R.menu.call_note_edit, menu);
} else {
getMenuInflater().inflate(R.menu.note_edit, menu);
}
//检查工作笔记的checkListMode，并相应地设置菜单项的标题
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_normal_mode);
} else {
menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_list_mode);
}
//检查工作笔记是否有时钟提醒，并相应地设置菜单项的可见性
if (mWorkingNote.hasClockAlert()) {
menu.findItem(R.id.menu_alert).setVisible(false);
} else {
menu.findItem(R.id.menu_delete_remind).setVisible(false);
}
//返回true，表示选项菜单已经准备好
return true;
}
/**
* 这是adnriod小米便签生命周期的一部分。当用户在选择菜单选择一个像的时候调用*/
@Override
public boolean onOptionsItemSelected(MenuItem item) {
//获取选中菜单项的ID
int itemId = item.getItemId();
//检查哪个菜单项被选中
//如果选择了“New Note”，则创建新笔记
if (itemId == R.id.menu_new_note) {
createNewNote();
} else if (itemId == R.id.menu_delete) {
//如果选择“删除”，显示一个确认对话框，如果确认删除笔记
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle(getString(R.string.alert_title_delete));
builder.setIcon(android.R.drawable.ic_dialog_alert);
@ -518,6 +647,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
builder.setPositiveButton(android.R.string.ok,
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
//如果点击“OK”，删除当前笔记并完成活动
deleteCurrentNote();
finish();
}
@ -525,31 +655,45 @@ public class NoteEditActivity extends Activity implements OnClickListener,
builder.setNegativeButton(android.R.string.cancel, null);
builder.show();
} else if (itemId == R.id.menu_font_size) {
//如果选择了“字体大小”，显示字体大小选择器
mFontSizeSelector.setVisibility(View.VISIBLE);
findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
} else if (itemId == R.id.menu_list_mode) {
//如果选择“列表模式”，可以在检查表模式和常规模式之间切换
mWorkingNote.setCheckListMode(mWorkingNote.getCheckListMode() == 0 ?
TextNote.MODE_CHECK_LIST : 0);
} else if (itemId == R.id.menu_share) {
//如果选择“分享”，检索笔记内容并发送
getWorkingText();
sendTo(this, mWorkingNote.getContent());
} else if (itemId == R.id.menu_send_to_desktop) {
//如果选择“发送到桌面”，则将笔记发送到桌面
sendToDesktop();
} else if (itemId == R.id.menu_alert) {
//选择“设置提醒”，设置提醒
setReminder();
} else if (itemId == R.id.menu_delete_remind) {
//如果选择“删除提醒”，则删除该笔记的提醒
mWorkingNote.setAlertDate(0, false);
}
return true;
}
/**
*这个函数通过启动DateTimePickerDialog来设置当前工作笔记的提醒。
*对话框允许用户选择提醒的日期和时间。
*一旦用户选择了日期和时间，就会设置工作笔记的提醒日期。*/
private void setReminder() {
//创建一个新的DateTimePickerDialog实例，将当前系统时间作为默认时间。
DateTimePickerDialog d = new DateTimePickerDialog(this, System.currentTimeMillis());
//设置监听器从DateTimePickerDialog中捕获选定的日期和时间。
d.setOnDateTimeSetListener(new OnDateTimeSetListener() {
public void OnDateTimeSet(AlertDialog dialog, long date) {
//设置工作笔记的提醒日期与所选日期并启用提醒。
mWorkingNote.setAlertDate(date , true);
}
});
//向用户显示DateTimePickerDialog。
d.show();
}
@ -557,25 +701,50 @@ public class NoteEditActivity extends Activity implements OnClickListener,
* Share note to apps that support {@link Intent#ACTION_SEND} action
* and {@text/plain} type
*/
/**
*此功能允许用户共享提供的文本信息(注内容)
*到其他可以处理ACTION_SEND意图的MIME类型为“text/plain”的应用程序。
* @param context 调用函数的上下文。
* @param info 需要共享的文本信息(注内容)。
*/
private void sendTo(Context context, String info) {
///创建一个带有ACTION_SEND动作的Intent来共享数据。
Intent intent = new Intent(Intent.ACTION_SEND);
//添加文本信息(注内容)作为一个额外的意图。
intent.putExtra(Intent.EXTRA_TEXT, info);
//设置intent的MIME类型为"text/plain"来指定要发送的数据类型。
intent.setType("text/plain");
//以共享数据为目的启动activity
context.startActivity(intent);
}
/**
*这个函数通过启动一个新的NoteEditActivity来创建一个新的笔记。
*在开始新活动之前，它会保存任何当前编辑的笔记，以确保安全。
*在插入或编辑模式下，根据意图设置的动作开始新的笔记。*/
private void createNewNote() {
// Firstly, save current editing notes
saveNote();
// For safety, start a new NoteEditActivity
finish();
//创建一个新的意图来启动NoteEditActivity来插入或编辑注释。
Intent intent = new Intent(this, NoteEditActivity.class);
//设置插入或编辑注释的意图动作。
intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
//将当前工作笔记的文件夹ID作为额外参数传递给新活动。
intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mWorkingNote.getFolderId());
//启动NoteEditActivity，创建一个新的注释。
startActivity(intent);
}
/**
*此方法负责删除当前工作笔记。
*如果该笔记在数据库中存在，则判断该笔记是否处于同步模式。
*如果不在同步模式，它要么删除笔记或移动到垃圾文件夹。
*如果在同步模式下，它会将笔记移动到垃圾文件夹。
*最后，将工作笔记标记为已删除。*/
private void deleteCurrentNote() {
if (mWorkingNote.existInDatabase()) {
HashSet<Long> ids = new HashSet<Long>();
@ -598,10 +767,22 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mWorkingNote.markDeleted(true);
}
/**
*这个方法检查应用程序是否处于同步模式。
*它通过在首选项中检查同步帐户名称的长度来实现。
＊如果应用程序处于同步模式，则返回True，否则返回false。*/
private boolean isSyncMode() {
return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
}
/**
*这个方法被触发时，时钟警报为一个笔记被改变。
*它首先检查工作笔记是否存在于数据库中。如果没有，则保存该注释。
*然后，它创建一个由告警触发的意图，设置一个PendingIntent，然后
*管理AlarmManager处理调度或取消告警。
* @param date 告警产生的日期。
* @param set 布尔值，表示设置或取消告警。*/
public void onClockAlertChanged(long date, boolean set) {
/**
* User could set clock to an unsaved note, so before setting the
@ -610,12 +791,18 @@ public class NoteEditActivity extends Activity implements OnClickListener,
if (!mWorkingNote.existInDatabase()) {
saveNote();
}
//检查笔记是否有一个有效的ID。
if (mWorkingNote.getNoteId() > 0) {
//创建一个由告警触发的意图。
Intent intent = new Intent(this, AlarmReceiver.class);
intent.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mWorkingNote.getNoteId()));
//为广播创建PendingIntent
PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, intent, 0);
//获取AlarmManager服务
AlarmManager alarmManager = ((AlarmManager) getSystemService(ALARM_SERVICE));
//显示一个警告头(假设它是一个UI操作)
showAlertHeader();
//检查是否取消或设置告警。
if(!set) {
alarmManager.cancel(pendingIntent);
} else {
@ -632,33 +819,47 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
/**这个方法在小部件被改变时被调用。
*它更新小部件以反映底层数据的任何更改。*/
public void onWidgetChanged() {
updateWidget();
}
public void onEditTextDelete(int index, String text) {
// 获取 mEditTextList 中子视图的数量
int childCount = mEditTextList.getChildCount();
// 如果容器中只有一个子视图，直接返回，避免操作这个唯一的子视图
if (childCount == 1) {
return;
}
// 对容器中从 index + 1 到末尾的子视图进行操作
for (int i = index + 1; i < childCount; i++) {
((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text))
.setIndex(i - 1);
}
// 从容器中删除索引为 index 的子视图
mEditTextList.removeViewAt(index);
// 找到需要修改的 NoteEditText 对象
NoteEditText edit = null;
if(index == 0) {
// 如果删除的是第一个子视图，获取容器中的第一个子视图的 NoteEditText 对象
edit = (NoteEditText) mEditTextList.getChildAt(0).findViewById(
R.id.et_edit_text);
} else {
// 否则获取索引为 index - 1 的子视图的 NoteEditText 对象
edit = (NoteEditText) mEditTextList.getChildAt(index - 1).findViewById(
R.id.et_edit_text);
}
// 获取当前文本长度
int length = edit.length();
// 在找到的 NoteEditText 对象的末尾追加传入的文本
edit.append(text);
// 请求焦点
edit.requestFocus();
// 将光标设置在追加文本后的位置（即之前文本的长度）
edit.setSelection(length);
}
@ -666,44 +867,75 @@ public class NoteEditActivity extends Activity implements OnClickListener,
/**
* Should not happen, check for debug
*/
// 检查传入的索引是否超出 mEditTextList 中子视图的范围，如果超出则打印错误日志
if(index > mEditTextList.getChildCount()) {
Log.e(TAG, "Index out of mEditTextList boundrary, should not happen");
}
// 根据传入的文本和索引获取一个新的视图
View view = getListItem(text, index);
// 将新创建的视图插入到 mEditTextList 容器的指定位置 index
mEditTextList.addView(view, index);
// 获取新插入的视图中的 NoteEditText 对象
NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
// 请求焦点
edit.requestFocus();
// 将光标设置在编辑框的开头位置
edit.setSelection(0);
// 对 mEditTextList 中从 index + 1 到末尾的子视图进行操作
for (int i = index + 1; i < mEditTextList.getChildCount(); i++) {
((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text))
.setIndex(i);
}
}
/**
* 切换到列表模式的方法，根据传入的文本生成列表视图。
* @param text 要显示的文本，其中每行作为一个列表项。
*/
private void switchToListMode(String text) {
// 移除列表视图中的所有子视图
mEditTextList.removeAllViews();
// 将传入的文本按换行符分割成数组
String[] items = text.split("\n");
// 初始化索引
int index = 0;
// 遍历文本数组，生成列表项并添加到列表视图中
for (String item : items) {
if(!TextUtils.isEmpty(item)) {
mEditTextList.addView(getListItem(item, index));
index++;
}
}
// 添加一个空的列表项作为新的可编辑项
mEditTextList.addView(getListItem("", index));
// 获取新添加的可编辑项中的编辑框，并请求焦点
mEditTextList.getChildAt(index).findViewById(R.id.et_edit_text).requestFocus();
// 隐藏笔记编辑器视图
mNoteEditor.setVisibility(View.GONE);
// 显示列表视图
mEditTextList.setVisibility(View.VISIBLE);
}
/**
* 获取带有查询结果高亮的 Spannable 对象。
* @param fullText 完整的文本内容。
* @param userQuery 用户的查询字符串。
* @return 包含高亮效果的 Spannable 对象。
*/
private Spannable getHighlightQueryResult(String fullText, String userQuery) {
// 创建一个 SpannableString 对象，用于处理富文本
SpannableString spannable = new SpannableString(fullText == null ? "" : fullText);
// 检查用户查询字符串是否非空
if (!TextUtils.isEmpty(userQuery)) {
// 使用正则表达式创建匹配用户查询的 Pattern 对象
mPattern = Pattern.compile(userQuery);
// 使用 Pattern 对象在完整文本中查找匹配项
Matcher m = mPattern.matcher(fullText);
// 初始化起始位置
int start = 0;
// 遍历匹配项并添加背景色高亮效果
while (m.find(start)) {
spannable.setSpan(
new BackgroundColorSpan(this.getResources().getColor(
@ -712,14 +944,22 @@ public class NoteEditActivity extends Activity implements OnClickListener,
start = m.end();
}
}
// 返回包含高亮效果的 Spannable 对象
return spannable;
}
/**
* 方法用于创建具有可编辑文本字段和复选框的自定义列表项视图。
* 它还包括处理复选框更改和调整相关文本外观的逻辑。*/
private View getListItem(String item, int index) {
// 从布局文件中实例化列表项视图
View view = LayoutInflater.from(this).inflate(R.layout.note_edit_list_item, null);
// 查找NoteEditText并根据资源ID设置其文本外观
final NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
edit.setTextAppearance(this, TextAppearanceResources.getTexAppearanceResource(mFontSizeId));
// 查找视图中的复选框
CheckBox cb = ((CheckBox) view.findViewById(R.id.cb_edit_item));
// 设置复选框更改监听器以切换相关文本的删除线
cb.setOnCheckedChangeListener(new OnCheckedChangeListener() {
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
if (isChecked) {
@ -730,6 +970,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
});
// 检查项目中是否包含特定标签，并相应地调整复选框和文本
if (item.startsWith(TAG_CHECKED)) {
cb.setChecked(true);
edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
@ -740,17 +981,24 @@ public class NoteEditActivity extends Activity implements OnClickListener,
item = item.substring(TAG_UNCHECKED.length(), item.length()).trim();
}
// 设置NoteEditText的监听器和属性
edit.setOnTextViewChangeListener(this);
edit.setIndex(index);
edit.setText(getHighlightQueryResult(item, mUserQuery));
// 返回定制的列表项视图
return view;
}
/**
* 回调方法 ，通过显示或隐藏基于文本存在的相关复选框
* 对可编辑文本字段中的文本更改作出反应。*/
public void onTextChange(int index, boolean hasText) {
// 检查提供的索引是否在父布局中子视图的范围内
if (index >= mEditTextList.getChildCount()) {
Log.e(TAG, "Wrong index, should not happen");
return;
}
// 根据相关文本是否存在，显示或隐藏复选框
if(hasText) {
mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.VISIBLE);
} else {
@ -758,28 +1006,46 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
/**
* 处理检查列表模式变化的方法。当检查列表模式从旧模式变为新模式时调用。
* @param oldMode 之前的模式
* @param newMode 新的模式
*/
public void onCheckListModeChanged(int oldMode, int newMode) {
// 如果新模式为检查列表模式
if (newMode == TextNote.MODE_CHECK_LIST) {
// 切换到列表模式并将当前编辑器文本传递给切换方法
switchToListMode(mNoteEditor.getText().toString());
} else {
// 如果不是检查列表模式
if (!getWorkingText()) {
mWorkingNote.setWorkingText(mWorkingNote.getContent().replace(TAG_UNCHECKED + " ",
""));
// 如果没有获取工作文本成功，则将工作笔记的工作文本设置为替换未选中标签后的内容
mWorkingNote.setWorkingText(mWorkingNote.getContent().replace(TAG_UNCHECKED + " ", ""));
}
// 将笔记编辑器文本设置为高亮查询结果
mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));
// 隐藏编辑文本列表，显示笔记编辑器
mEditTextList.setVisibility(View.GONE);
mNoteEditor.setVisibility(View.VISIBLE);
}
}
/**
* 获取工作文本的方法，用于在不同模式下保存当前编辑的文本。
* @return 如果有已选中的项目，则返回true，否则返回false
*/
private boolean getWorkingText() {
boolean hasChecked = false;
// 如果工作笔记处于检查列表模式
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
StringBuilder sb = new StringBuilder();
// 遍历编辑文本列表的所有子项
for (int i = 0; i < mEditTextList.getChildCount(); i++) {
View view = mEditTextList.getChildAt(i);
NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
// 如果编辑文本非空
if (!TextUtils.isEmpty(edit.getText())) {
// 检查复选框是否被选中，根据情况添加已选中或未选中标签
if (((CheckBox) view.findViewById(R.id.cb_edit_item)).isChecked()) {
sb.append(TAG_CHECKED).append(" ").append(edit.getText()).append("\n");
hasChecked = true;
@ -788,16 +1054,20 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
}
// 将构建的文本设置为工作笔记的工作文本
mWorkingNote.setWorkingText(sb.toString());
} else {
// 如果不是检查列表模式，直接将笔记编辑器的文本设置为工作文本
mWorkingNote.setWorkingText(mNoteEditor.getText().toString());
}
// 返回是否有已选中的项目
return hasChecked;
}
private boolean saveNote() {
getWorkingText();
boolean saved = mWorkingNote.saveNote();
getWorkingText();// 获取正在编辑的文本内容
boolean saved = mWorkingNote.saveNote();// 保存当前笔记
if (saved) {
/**
* There are two modes from List view to edit view, open one note,
@ -808,9 +1078,13 @@ public class NoteEditActivity extends Activity implements OnClickListener,
*/
setResult(RESULT_OK);
}
return saved;
return saved;// 返回保存状态
}
/**将当前编辑的笔记发送到桌面，前提是该笔记已存在于数据库中。
*如果存在，它会尝试创建一个桌面快捷方式，并显示相关提示消息。
* 如果笔记不存在或内容为空，会记录错误并提醒用户。
*/
private void sendToDesktop() {
/**
* Before send message to home, we should make sure that current
@ -846,6 +1120,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
/**生成快捷方式图标的标题。
* 它会移除特定标记后，根据设定的最大长度返回缩短后的标题。
*/
private String makeShortcutIconTitle(String content) {
content = content.replace(TAG_CHECKED, "");
content = content.replace(TAG_UNCHECKED, "");
@ -853,6 +1130,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
SHORTCUT_ICON_TITLE_MAX_LEN) : content;
}
/**用于显示 Toast（提示消息）。
* 第一个函数显示短暂时长的消息，而第二个函数则允许指定显示时长。
*/
private void showToast(int resId) {
showToast(resId, Toast.LENGTH_SHORT);
}

181
src/main/java/net/micode/notes/ui/NoteItemData.java
Unescape View File

@ -27,72 +27,85 @@ import net.micode.notes.tool.DataUtils;
public class NoteItemData {
static final String [] PROJECTION = new String [] {
NoteColumns.ID,
NoteColumns.ALERTED_DATE,
NoteColumns.BG_COLOR_ID,
NoteColumns.CREATED_DATE,
NoteColumns.HAS_ATTACHMENT,
NoteColumns.MODIFIED_DATE,
NoteColumns.NOTES_COUNT,
NoteColumns.PARENT_ID,
NoteColumns.SNIPPET,
NoteColumns.TYPE,
NoteColumns.WIDGET_ID,
NoteColumns.WIDGET_TYPE,
//一个静态的投影数组 PROJECTION，用于在数据库查询时指定返回的列
static final String[] PROJECTION = new String[]{
NoteColumns.ID,
NoteColumns.ALERTED_DATE,
NoteColumns.BG_COLOR_ID,
NoteColumns.CREATED_DATE,
NoteColumns.HAS_ATTACHMENT,
NoteColumns.MODIFIED_DATE,
NoteColumns.NOTES_COUNT,
NoteColumns.PARENT_ID,
NoteColumns.SNIPPET,
NoteColumns.TYPE,
NoteColumns.WIDGET_ID,
NoteColumns.WIDGET_TYPE,
};
private static final int ID_COLUMN = 0;
private static final int ALERTED_DATE_COLUMN = 1;
private static final int BG_COLOR_ID_COLUMN = 2;
private static final int CREATED_DATE_COLUMN = 3;
private static final int HAS_ATTACHMENT_COLUMN = 4;
private static final int MODIFIED_DATE_COLUMN = 5;
private static final int NOTES_COUNT_COLUMN = 6;
private static final int PARENT_ID_COLUMN = 7;
private static final int SNIPPET_COLUMN = 8;
private static final int TYPE_COLUMN = 9;
private static final int WIDGET_ID_COLUMN = 10;
private static final int WIDGET_TYPE_COLUMN = 11;
private long mId;
private long mAlertDate;
private int mBgColorId;
private long mCreatedDate;
private boolean mHasAttachment;
private long mModifiedDate;
private int mNotesCount;
private long mParentId;
private String mSnippet;
private int mType;
private int mWidgetId;
private int mWidgetType;
private String mName;
private String mPhoneNumber;
private boolean mIsLastItem;
private boolean mIsFirstItem;
private boolean mIsOnlyOneItem;
private boolean mIsOneNoteFollowingFolder;
private boolean mIsMultiNotesFollowingFolder;
//定义了一系列静态常量，表示 PROJECTION 中对应列的索引位置。
private static final int ID_COLUMN = 0;
private static final int ALERTED_DATE_COLUMN = 1;
private static final int BG_COLOR_ID_COLUMN = 2;
private static final int CREATED_DATE_COLUMN = 3;
private static final int HAS_ATTACHMENT_COLUMN = 4;
private static final int MODIFIED_DATE_COLUMN = 5;
private static final int NOTES_COUNT_COLUMN = 6;
private static final int PARENT_ID_COLUMN = 7;
private static final int SNIPPET_COLUMN = 8;
private static final int TYPE_COLUMN = 9;
private static final int WIDGET_ID_COLUMN = 10;
private static final int WIDGET_TYPE_COLUMN = 11;
//用于存储笔记项各种属性的成员变量
private long mId; // 笔记ID
private long mAlertDate; // 提醒日期
private int mBgColorId; // 背景颜色ID
private long mCreatedDate; // 创建日期
private boolean mHasAttachment; // 是否有附件
private long mModifiedDate; // 修改日期
private int mNotesCount; // 子笔记数量
private long mParentId; // 父笔记ID
private String mSnippet; // 摘要
private int mType; // 笔记类型
private int mWidgetId; // 笔记关联的小部件ID
private int mWidgetType; // 小部件类型
private String mName; // 笔记名称
private String mPhoneNumber; // 电话号码
private boolean mIsLastItem; // 是否为列表中的最后一项
private boolean mIsFirstItem; // 是否为列表中的第一项
private boolean mIsOnlyOneItem; // 是否为列表中的唯一一项
private boolean mIsOneNoteFollowingFolder; // 是否是文件夹后的单个笔记
private boolean mIsMultiNotesFollowingFolder; // 是否是文件夹后的多个笔记
/**
* 构造函数，通过数据库查询结果的Cursor初始化NoteItemData对象。
*
* @param context 上下文环境
* @param cursor 数据库查询结果的Cursor
*/
public NoteItemData(Context context, Cursor cursor) {
mId = cursor.getLong(ID_COLUMN);
mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN);
mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN);
mCreatedDate = cursor.getLong(CREATED_DATE_COLUMN);
mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0) ? true : false;
mModifiedDate = cursor.getLong(MODIFIED_DATE_COLUMN);
mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN);
mParentId = cursor.getLong(PARENT_ID_COLUMN);
mSnippet = cursor.getString(SNIPPET_COLUMN);
// 从Cursor中提取数据并初始化成员变量
mId = cursor.getLong(ID_COLUMN); // 笔记ID
mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN); // 提醒日期
mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN); // 背景颜色ID
mCreatedDate = cursor.getLong(CREATED_DATE_COLUMN); // 创建日期
mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0); // 是否有附件
mModifiedDate = cursor.getLong(MODIFIED_DATE_COLUMN); // 修改日期
mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN); // 子笔记数量
mParentId = cursor.getLong(PARENT_ID_COLUMN); // 父笔记ID
mSnippet = cursor.getString(SNIPPET_COLUMN); // 摘要
mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(
NoteEditActivity.TAG_UNCHECKED, "");
mType = cursor.getInt(TYPE_COLUMN);
mWidgetId = cursor.getInt(WIDGET_ID_COLUMN);
mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN);
NoteEditActivity.TAG_UNCHECKED, ""); // 移除摘要中的特殊标记
mType = cursor.getInt(TYPE_COLUMN); // 笔记类型
mWidgetId = cursor.getInt(WIDGET_ID_COLUMN); // 笔记关联的小部件ID
mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN); // 小部件类型
mPhoneNumber = "";
// 如果笔记所属文件夹为通话记录文件夹，则获取通话号码并设置笔记名称
if (mParentId == Notes.ID_CALL_RECORD_FOLDER) {
mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId);
if (!TextUtils.isEmpty(mPhoneNumber)) {
@ -103,30 +116,50 @@ public class NoteItemData {
}
}
// 如果笔记名称为null，则设置为空字符串
if (mName == null) {
mName = "";
}
// 检查笔记在列表中的位置
checkPostion(cursor);
}
/**
* 检查当前笔记在列表中的位置，并设置相应的位置标识。
*
* @param cursor 数据库查询结果的Cursor
*/
private void checkPostion(Cursor cursor) {
mIsLastItem = cursor.isLast() ? true : false;
mIsFirstItem = cursor.isFirst() ? true : false;
// 判断当前笔记是否为最后一项
mIsLastItem = cursor.isLast();
// 判断当前笔记是否为第一项
mIsFirstItem = cursor.isFirst();
// 判断列表中是否只有一项笔记
mIsOnlyOneItem = (cursor.getCount() == 1);
// 初始化位置相关标识为false
mIsMultiNotesFollowingFolder = false;
mIsOneNoteFollowingFolder = false;
// 如果笔记类型为普通笔记且不是第一项笔记
if (mType == Notes.TYPE_NOTE && !mIsFirstItem) {
int position = cursor.getPosition();
if (cursor.moveToPrevious()) {
int position = cursor.getPosition(); // 获取当前位置
if (cursor.moveToPrevious()) { // 移动Cursor到上一项
// 如果上一项为文件夹或系统类型
if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER
|| cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) {
// 判断当前位置后是否还有多个笔记
if (cursor.getCount() > (position + 1)) {
mIsMultiNotesFollowingFolder = true;
mIsMultiNotesFollowingFolder = true; // 当前文件夹后有多个笔记
} else {
mIsOneNoteFollowingFolder = true;
mIsOneNoteFollowingFolder = true; // 当前文件夹后只有一个笔记
}
}
// 如果无法移动到下一项，抛出异常
if (!cursor.moveToNext()) {
throw new IllegalStateException("cursor move to previous but can't move back");
}
@ -134,6 +167,8 @@ public class NoteItemData {
}
}
//以下函数用于返回笔记项各种属性对应的成员变量
public boolean isOneFollowingFolder() {
return mIsOneNoteFollowingFolder;
}
@ -190,7 +225,7 @@ public class NoteItemData {
return mNotesCount;
}
public long getFolderId () {
public long getFolderId() {
return mParentId;
}
@ -214,10 +249,22 @@ public class NoteItemData {
return (mAlertDate > 0);
}
/**
* 判断当前笔记是否为通话记录。
* 笔记为通话记录的条件是：父文件夹ID为通话记录文件夹ID且电话号码非空。
*
* @return 如果是通话记录，返回true；否则，返回false。
*/
public boolean isCallRecord() {
return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber));
}
/**
* 从数据库查询结果的Cursor中获取笔记的类型。
*
* @param cursor 包含笔记类型信息的Cursor
* @return 笔记类型，通常为 Notes.TYPE_NOTE 或 Notes.TYPE_FOLDER
*/
public static int getNoteType(Cursor cursor) {
return cursor.getInt(TYPE_COLUMN);
}

Write Preview
Loading…
Cancel
Save