From 758794b7efdb7b4dd545cd770506c047aa39f78b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9B=B9=E9=A6=A8=E8=AF=AD?= <3462336976@qq.com> Date: Tue, 1 Apr 2025 18:42:33 +0800 Subject: [PATCH] add --- src/代码注释/ui/DateTimePickerDialog.java | 175 +++ src/代码注释/ui/DropdownMenu.java | 116 ++ src/代码注释/ui/FoldersListAdapter.java | 135 ++ src/代码注释/ui/NoteEditActivity.java | 1343 +++++++++++++++++ src/代码注释/ui/NoteEditText.java | 309 ++++ src/代码注释/ui/NoteItemData.java | 346 +++++ 6 files changed, 2424 insertions(+) create mode 100644 src/代码注释/ui/DateTimePickerDialog.java create mode 100644 src/代码注释/ui/DropdownMenu.java create mode 100644 src/代码注释/ui/FoldersListAdapter.java create mode 100644 src/代码注释/ui/NoteEditActivity.java create mode 100644 src/代码注释/ui/NoteEditText.java create mode 100644 src/代码注释/ui/NoteItemData.java diff --git a/src/代码注释/ui/DateTimePickerDialog.java b/src/代码注释/ui/DateTimePickerDialog.java new file mode 100644 index 0000000..e2ea576 --- /dev/null +++ b/src/代码注释/ui/DateTimePickerDialog.java @@ -0,0 +1,175 @@ +/* + * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// net.micode.notes.ui +package net.micode.notes.ui; + +// Java ׼е Calendar ࣬ڴںʱ +import java.util.Calendar; + +// ĿеԴ R +import net.micode.notes.R; +// Զ DateTimePicker +import net.micode.notes.ui.DateTimePicker; +// Զ DateTimePicker е OnDateTimeChangedListener ӿ +import net.micode.notes.ui.DateTimePicker.OnDateTimeChangedListener; + +// Android ϵͳ AlertDialog ࣬ڴԻ +import android.app.AlertDialog; +// Android ϵͳ Context ࣬ڻȡӦóϢ +import android.content.Context; +// Android ϵͳ DialogInterface ࣬ڴԻĽ¼ +import android.content.DialogInterface; +// DialogInterface е OnClickListener ӿڣڴ¼ +import android.content.DialogInterface.OnClickListener; +// Android ϵͳ DateFormat ࣬ڸʽںʱ +import android.text.format.DateFormat; +// Android ϵͳ DateUtils ࣬ڴںʱĹ +import android.text.format.DateUtils; + +/** + * DateTimePickerDialog ̳ AlertDialogڴһںʱѡĶԻ + * öԻûѡںʱ䣬ṩ˻صӿ OnDateTimeSetListener ûѡĽ + */ +public class DateTimePickerDialog extends AlertDialog implements OnClickListener { + + // ڴ洢ǰѡںʱ + private Calendar mDate = Calendar.getInstance(); + // Ƿʹ 24 Сʱʾʱ + private boolean mIs24HourView; + // ںʱѡɺĻصӿ + private OnDateTimeSetListener mOnDateTimeSetListener; + // Զںʱѡͼ + private DateTimePicker mDateTimePicker; + + /** + * OnDateTimeSetListener ӿڶһص OnDateTimeSet + * ûڶԻںʱѡ񲢵ȷťʱø÷ + */ + public interface OnDateTimeSetListener { + /** + * ûѡںʱ󣬵ø÷ѡĽ + * @param dialog ûصĶԻʵ + * @param date ûѡںʱĺ + */ + void OnDateTimeSet(AlertDialog dialog, long date); + } + + /** + * 캯ڴ DateTimePickerDialog ʵ + * @param context ӦóϢ + * @param date ʼʾںʱĺ + */ + public DateTimePickerDialog(Context context, long date) { + // ø AlertDialog Ĺ캯 + super(context); + // Զ DateTimePicker ʵ + mDateTimePicker = new DateTimePicker(context); + // DateTimePicker ΪԻͼ + setView(mDateTimePicker); + // Ϊ DateTimePicker ںʱıļ + mDateTimePicker.setOnDateTimeChangedListener(new OnDateTimeChangedListener() { + /** + * ںʱ䷢ıʱø÷ mDate 󣬲¶Իı⡣ + * @param view ¼ DateTimePicker ͼ + * @param year ѡ + * @param month ѡ· + * @param dayOfMonth ѡ + * @param hourOfDay ѡСʱ + * @param minute ѡķ + */ + public void onDateTimeChanged(DateTimePicker view, int year, int month, + int dayOfMonth, int hourOfDay, int minute) { + // mDate + mDate.set(Calendar.YEAR, year); + // mDate · + mDate.set(Calendar.MONTH, month); + // mDate + mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth); + // mDate Сʱ + mDate.set(Calendar.HOUR_OF_DAY, hourOfDay); + // mDate ķ + mDate.set(Calendar.MINUTE, minute); + // updateTitle ¶Իı + updateTitle(mDate.getTimeInMillis()); + } + }); + // mDate ʱΪںʱ + mDate.setTimeInMillis(date); + // Ϊ 0 + mDate.set(Calendar.SECOND, 0); + // DateTimePicker ĵǰںʱ + mDateTimePicker.setCurrentDate(mDate.getTimeInMillis()); + // öԻȷťõΪǰʵ + setButton(context.getString(R.string.datetime_dialog_ok), this); + // öԻȡťõ + setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener)null); + // ϵͳжǷʹ 24 Сʱ + set24HourView(DateFormat.is24HourFormat(this.getContext())); + // updateTitle ¶Իı + updateTitle(mDate.getTimeInMillis()); + } + + /** + * Ƿʹ 24 Сʱʾʱ䡣 + * @param is24HourView Ƿʹ 24 СʱƵı־ + */ + public void set24HourView(boolean is24HourView) { + mIs24HourView = is24HourView; + } + + /** + * ںʱѡɺĻصӿڡ + * @param callBack ʵ OnDateTimeSetListener ӿڵĻص + */ + public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) { + mOnDateTimeSetListener = callBack; + } + + /** + * ¶Իı⣬ʾǰѡںʱ䡣 + * @param date ǰѡںʱĺ + */ + private void updateTitle(long date) { + // ںʱʽı־ + int flag = + // ʾ + DateUtils.FORMAT_SHOW_YEAR | + // ʾ + DateUtils.FORMAT_SHOW_DATE | + // ʾʱ + DateUtils.FORMAT_SHOW_TIME; + // Ƿʹ 24 СʱӦı־ + flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_24HOUR; + // ʹ DateUtils ʽںʱ䣬ΪԻı + setTitle(DateUtils.formatDateTime(this.getContext(), date, flag)); + } + + /** + * Իťĵ¼ + * ûȷťʱûصӿڵ OnDateTimeSet ѡĽ + * @param arg0 ¼ DialogInterface ʵ + * @param arg1 ¼ıʶ + */ + public void onClick(DialogInterface arg0, int arg1) { + // صӿǷΪ + if (mOnDateTimeSetListener != null) { + // ûصӿڵ OnDateTimeSet ѡںʱ + mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis()); + } + } + +} \ No newline at end of file diff --git a/src/代码注释/ui/DropdownMenu.java b/src/代码注释/ui/DropdownMenu.java new file mode 100644 index 0000000..4cd99aa --- /dev/null +++ b/src/代码注释/ui/DropdownMenu.java @@ -0,0 +1,116 @@ +/* + * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// ڵİ net.micode.notes.ui ģ +package net.micode.notes.ui; + +// Android ࣬ڻȡӦó򻷾Ϣ +import android.content.Context; +// Android ˵࣬ڴ͹˵ +import android.view.Menu; +// Android ˵࣬ڱʾ˵еÿһ +import android.view.MenuItem; +// Android ͼ࣬ UI Ļ +import android.view.View; +// Android ͼӿڣڴͼĵ¼ +import android.view.View.OnClickListener; +// Android ť࣬ڴɵİť +import android.widget.Button; +// Android ˵࣬ڴʽ˵ +import android.widget.PopupMenu; +// Android ˵ӿڣڴ˵ĵ¼ +import android.widget.PopupMenu.OnMenuItemClickListener; + +// ӦԴ࣬ڷӦеԴ粼ַ֡ +import net.micode.notes.R; + +/** + * DropdownMenu ڴһ˵ͨťʾʽ˵ + */ +public class DropdownMenu { + // һťڴ˵ʾ + private Button mButton; + // һ˵ʾ˵ + private PopupMenu mPopupMenu; + // һ˵ڹ˵еIJ˵ + private Menu mMenu; + + /** + * 캯ڳʼ˵ + * + * @param context Ӧóģڴ˵ + * @param button ˵İť + * @param menuId ˵Դ IDָ˵IJ + */ + public DropdownMenu(Context context, Button button, int menuId) { + // İťֵԱ mButton + mButton = button; + // ΪťñԴʹͼ + mButton.setBackgroundResource(R.drawable.dropdown_icon); + // һ˵󣬹İť + mPopupMenu = new PopupMenu(context, mButton); + // ȡ˵IJ˵ + mMenu = mPopupMenu.getMenu(); + // ʹò˵Դ ID ˵ + mPopupMenu.getMenuInflater().inflate(menuId, mMenu); + // Ϊťõ + mButton.setOnClickListener(new OnClickListener() { + /** + * ťʱʾ˵ + * + * @param v ͼ + */ + public void onClick(View v) { + // ʾ˵ + mPopupMenu.show(); + } + }); + } + + /** + * ˵ĵ + * + * @param listener ˵ + */ + public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) { + // 鵯˵ǷΪ + if (mPopupMenu != null) { + // Ϊ˵ò˵ + mPopupMenu.setOnMenuItemClickListener(listener); + } + } + + /** + * ݲ˵ ID Ҳ˵ + * + * @param id ˵ ID + * @return ҵIJ˵δҵ򷵻 null + */ + public MenuItem findItem(int id) { + // ڲ˵вָ ID IJ˵ + return mMenu.findItem(id); + } + + /** + * ðťı⡣ + * + * @param title ťıı + */ + public void setTitle(CharSequence title) { + // ðťıΪı + mButton.setText(title); + } +} \ No newline at end of file diff --git a/src/代码注释/ui/FoldersListAdapter.java b/src/代码注释/ui/FoldersListAdapter.java new file mode 100644 index 0000000..cb2569c --- /dev/null +++ b/src/代码注释/ui/FoldersListAdapter.java @@ -0,0 +1,135 @@ +/* + * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package net.micode.notes.ui; + +import android.content.Context; +import android.database.Cursor; +import android.view.View; +import android.view.ViewGroup; +import android.widget.CursorAdapter; +import android.widget.LinearLayout; +import android.widget.TextView; + +import net.micode.notes.R; +import net.micode.notes.data.Notes; +import net.micode.notes.data.Notes.NoteColumns; + +/** + * FoldersListAdapter 类继承自 CursorAdapter，用于将数据库中的文件夹数据绑定到视图上。 + * CursorAdapter 是一个抽象类，用于将 Cursor 中的数据显示在 AdapterView 中。 + */ +public class FoldersListAdapter extends CursorAdapter { + + // 定义从数据库中查询所需的列，这里查询了笔记的 ID 和摘要 + public static final String [] PROJECTION = { + NoteColumns.ID, + NoteColumns.SNIPPET + }; + + // 定义 PROJECTION 数组中 ID 列的索引 + public static final int ID_COLUMN = 0; + // 定义 PROJECTION 数组中名称列的索引 + public static final int NAME_COLUMN = 1; + + /** + * 构造函数，初始化 FoldersListAdapter。 + * @param context 上下文对象，用于获取资源和服务 + * @param c 包含文件夹数据的 Cursor 对象 + */ + public FoldersListAdapter(Context context, Cursor c) { + super(context, c); + // TODO Auto-generated constructor stub + } + + /** + * 创建一个新的视图对象，用于显示 Cursor 中的数据。 + * 当 Adapter 需要创建一个新的视图来显示数据时，会调用此方法。 + * @param context 上下文对象 + * @param cursor 包含数据的 Cursor 对象 + * @param parent 新视图的父视图 + * @return 新创建的视图对象 + */ + @Override + public View newView(Context context, Cursor cursor, ViewGroup parent) { + // 创建一个新的 FolderListItem 视图 + return new FolderListItem(context); + } + + /** + * 将 Cursor 中的数据绑定到已有的视图上。 + * 当 Adapter 需要更新一个已有的视图来显示新的数据时，会调用此方法。 + * @param view 要绑定数据的视图 + * @param context 上下文对象 + * @param cursor 包含数据的 Cursor 对象 + */ + @Override + public void bindView(View view, Context context, Cursor cursor) { + // 检查视图是否为 FolderListItem 类型 + if (view instanceof FolderListItem) { + // 获取文件夹名称，如果是根文件夹，则显示特定的文本，否则显示从数据库中获取的名称 + String folderName = (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context + .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN); + // 调用 FolderListItem 的 bind 方法，将文件夹名称绑定到视图上 + ((FolderListItem) view).bind(folderName); + } + } + + /** + * 根据位置获取文件夹的名称。 + * @param context 上下文对象 + * @param position 要获取名称的文件夹的位置 + * @return 文件夹的名称 + */ + public String getFolderName(Context context, int position) { + // 获取指定位置的 Cursor 对象 + Cursor cursor = (Cursor) getItem(position); + // 获取文件夹名称，如果是根文件夹，则显示特定的文本，否则显示从数据库中获取的名称 + return (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context + .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN); + } + + /** + * FolderListItem 类继承自 LinearLayout，用于显示文件夹的名称。 + * 它是 FoldersListAdapter 中每个列表项的视图。 + */ + private class FolderListItem extends LinearLayout { + // 用于显示文件夹名称的 TextView + private TextView mName; + + /** + * 构造函数，初始化 FolderListItem。 + * @param context 上下文对象 + */ + public FolderListItem(Context context) { + super(context); + // 加载布局文件 folder_list_item.xml 到当前视图 + inflate(context, R.layout.folder_list_item, this); + // 查找布局文件中的 TextView 控件 + mName = (TextView) findViewById(R.id.tv_folder_name); + } + + /** + * 将文件夹名称绑定到 TextView 上。 + * @param name 文件夹的名称 + */ + public void bind(String name) { + // 设置 TextView 的文本为文件夹名称 + mName.setText(name); + } + } + +} \ No newline at end of file diff --git a/src/代码注释/ui/NoteEditActivity.java b/src/代码注释/ui/NoteEditActivity.java new file mode 100644 index 0000000..f0ada31 --- /dev/null +++ b/src/代码注释/ui/NoteEditActivity.java @@ -0,0 +1,1343 @@ +/* + * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package net.micode.notes.ui; + +import android.app.Activity; +import android.app.AlarmManager; +import android.app.AlertDialog; +import android.app.PendingIntent; +import android.app.SearchManager; +import android.appwidget.AppWidgetManager; +import android.content.ContentUris; +import android.content.Context; +import android.content.DialogInterface; +import android.content.Intent; +import android.content.SharedPreferences; +import android.graphics.Paint; +import android.os.Bundle; +import android.preference.PreferenceManager; +import android.text.Spannable; +import android.text.SpannableString; +import android.text.TextUtils; +import android.text.format.DateUtils; +import android.text.style.BackgroundColorSpan; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.Menu; +import android.view.MenuItem; +import android.view.MotionEvent; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.WindowManager; +import android.widget.CheckBox; +import android.widget.CompoundButton; +import android.widget.CompoundButton.OnCheckedChangeListener; +import android.widget.EditText; +import android.widget.ImageView; +import android.widget.LinearLayout; +import android.widget.TextView; +import android.widget.Toast; + +import net.micode.notes.R; +import net.micode.notes.data.Notes; +import net.micode.notes.data.Notes.TextNote; +import net.micode.notes.model.WorkingNote; +import net.micode.notes.model.WorkingNote.NoteSettingChangedListener; +import net.micode.notes.tool.DataUtils; +import net.micode.notes.tool.ResourceParser; +import net.micode.notes.tool.ResourceParser.TextAppearanceResources; +import net.micode.notes.ui.DateTimePickerDialog.OnDateTimeSetListener; +import net.micode.notes.ui.NoteEditText.OnTextViewChangeListener; +import net.micode.notes.widget.NoteWidgetProvider_2x; +import net.micode.notes.widget.NoteWidgetProvider_4x; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + + +/** + * NoteEditActivity 是一个用于编辑便签的活动类。 + * 它处理便签的创建、加载、编辑和保存等操作，同时支持便签背景颜色、字体大小的设置，以及提醒功能。 + */ +public class NoteEditActivity extends Activity implements OnClickListener, + NoteSettingChangedListener, OnTextViewChangeListener { + + /** + * HeadViewHolder 是一个内部类，用于持有便签头部视图的引用，方便管理和操作。 + */ + private class HeadViewHolder { + // 显示便签修改日期的 TextView + public TextView tvModified; + // 提醒图标 ImageView + public ImageView ivAlertIcon; + // 显示提醒日期的 TextView + public TextView tvAlertDate; + // 设置便签背景颜色的按钮 ImageView + public ImageView ibSetBgColor; + } + + // 背景选择按钮与背景资源 ID 的映射 + private static final Map sBgSelectorBtnsMap = new HashMap(); + static { + // 黄色背景按钮与黄色背景资源 ID 映射 + sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW); + // 红色背景按钮与红色背景资源 ID 映射 + sBgSelectorBtnsMap.put(R.id.iv_bg_red, ResourceParser.RED); + // 蓝色背景按钮与蓝色背景资源 ID 映射 + sBgSelectorBtnsMap.put(R.id.iv_bg_blue, ResourceParser.BLUE); + // 绿色背景按钮与绿色背景资源 ID 映射 + sBgSelectorBtnsMap.put(R.id.iv_bg_green, ResourceParser.GREEN); + // 白色背景按钮与白色背景资源 ID 映射 + sBgSelectorBtnsMap.put(R.id.iv_bg_white, ResourceParser.WHITE); + } + + // 背景资源 ID 与背景选择状态视图 ID 的映射 + private static final Map sBgSelectorSelectionMap = new HashMap(); + static { + // 黄色背景资源 ID 与黄色背景选择状态视图 ID 映射 + sBgSelectorSelectionMap.put(ResourceParser.YELLOW, R.id.iv_bg_yellow_select); + // 红色背景资源 ID 与红色背景选择状态视图 ID 映射 + sBgSelectorSelectionMap.put(ResourceParser.RED, R.id.iv_bg_red_select); + // 蓝色背景资源 ID 与蓝色背景选择状态视图 ID 映射 + sBgSelectorSelectionMap.put(ResourceParser.BLUE, R.id.iv_bg_blue_select); + // 绿色背景资源 ID 与绿色背景选择状态视图 ID 映射 + sBgSelectorSelectionMap.put(ResourceParser.GREEN, R.id.iv_bg_green_select); + // 白色背景资源 ID 与白色背景选择状态视图 ID 映射 + sBgSelectorSelectionMap.put(ResourceParser.WHITE, R.id.iv_bg_white_select); + } + + // 字体大小按钮与字体大小资源 ID 的映射 + private static final Map sFontSizeBtnsMap = new HashMap(); + static { + // 大字体按钮与大字体资源 ID 映射 + sFontSizeBtnsMap.put(R.id.ll_font_large, ResourceParser.TEXT_LARGE); + // 小字体按钮与小字体资源 ID 映射 + sFontSizeBtnsMap.put(R.id.ll_font_small, ResourceParser.TEXT_SMALL); + // 正常字体按钮与正常字体资源 ID 映射 + sFontSizeBtnsMap.put(R.id.ll_font_normal, ResourceParser.TEXT_MEDIUM); + // 超大字体按钮与超大字体资源 ID 映射 + sFontSizeBtnsMap.put(R.id.ll_font_super, ResourceParser.TEXT_SUPER); + } + + // 字体大小资源 ID 与字体选择状态视图 ID 的映射 + private static final Map sFontSelectorSelectionMap = new HashMap(); + static { + // 大字体资源 ID 与大字体选择状态视图 ID 映射 + sFontSelectorSelectionMap.put(ResourceParser.TEXT_LARGE, R.id.iv_large_select); + // 小字体资源 ID 与小字体选择状态视图 ID 映射 + sFontSelectorSelectionMap.put(ResourceParser.TEXT_SMALL, R.id.iv_small_select); + // 正常字体资源 ID 与正常字体选择状态视图 ID 映射 + sFontSelectorSelectionMap.put(ResourceParser.TEXT_MEDIUM, R.id.iv_medium_select); + // 超大字体资源 ID 与超大字体选择状态视图 ID 映射 + sFontSelectorSelectionMap.put(ResourceParser.TEXT_SUPER, R.id.iv_super_select); + } + + // 日志标签 + private static final String TAG = "NoteEditActivity"; + + // 便签头部视图持有者 + private HeadViewHolder mNoteHeaderHolder; + // 便签头部视图面板 + private View mHeadViewPanel; + // 便签背景颜色选择器视图 + private View mNoteBgColorSelector; + // 字体大小选择器视图 + private View mFontSizeSelector; + // 便签编辑器 EditText + private EditText mNoteEditor; + // 便签编辑器面板视图 + private View mNoteEditorPanel; + // 正在编辑的便签对象 + private WorkingNote mWorkingNote; + // 共享偏好设置对象 + private SharedPreferences mSharedPrefs; + // 当前字体大小资源 ID + private int mFontSizeId; + + // 共享偏好设置中保存字体大小的键 + private static final String PREFERENCE_FONT_SIZE = "pref_font_size"; + // 快捷图标标题的最大长度 + private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10; + // 已勾选标记 + public static final String TAG_CHECKED = String.valueOf('\u221A'); + // 未勾选标记 + public static final String TAG_UNCHECKED = String.valueOf('\u25A1'); + // 便签编辑文本列表的 LinearLayout + private LinearLayout mEditTextList; + // 用户查询关键词 + private String mUserQuery; + // 用于匹配查询关键词的正则表达式模式 + private Pattern mPattern; + + /** + * Activity 创建时调用的方法，进行初始化操作。 + * @param savedInstanceState 保存的实例状态 + */ + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + // 设置当前 Activity 的布局 + this.setContentView(R.layout.note_edit); + + // 如果 savedInstanceState 为空且初始化 Activity 状态失败，则结束当前 Activity + if (savedInstanceState == null && !initActivityState(getIntent())) { + finish(); + return; + } + // 初始化资源 + initResources(); + } + + /** + * 当 Activity 因内存不足被杀死后，再次启动时恢复之前的状态。 + * @param savedInstanceState 保存的实例状态 + */ + @Override + protected void onRestoreInstanceState(Bundle savedInstanceState) { + super.onRestoreInstanceState(savedInstanceState); + // 如果 savedInstanceState 不为空且包含 Intent.EXTRA_UID，则恢复便签状态 + if (savedInstanceState != null && savedInstanceState.containsKey(Intent.EXTRA_UID)) { + Intent intent = new Intent(Intent.ACTION_VIEW); + intent.putExtra(Intent.EXTRA_UID, savedInstanceState.getLong(Intent.EXTRA_UID)); + // 如果初始化 Activity 状态失败，则结束当前 Activity + if (!initActivityState(intent)) { + finish(); + return; + } + Log.d(TAG, "Restoring from killed activity"); + } + } + + /** + * 初始化 Activity 状态，根据 Intent 中的操作类型加载或创建便签。 + * @param intent 启动 Activity 的 Intent + * @return 如果初始化成功返回 true，否则返回 false + */ + private boolean initActivityState(Intent intent) { + // 清空正在编辑的便签对象 + mWorkingNote = null; + // 如果 Intent 的操作是查看便签 + if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) { + // 获取便签 ID + long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0); + // 初始化用户查询关键词为空 + mUserQuery = ""; + + // 如果 Intent 包含搜索结果数据 + if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) { + // 从搜索结果数据中获取便签 ID + noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY)); + // 获取用户查询关键词 + mUserQuery = intent.getStringExtra(SearchManager.USER_QUERY); + } + + // 检查便签是否在数据库中可见 + if (!DataUtils.visibleInNoteDatabase(getContentResolver(), noteId, Notes.TYPE_NOTE)) { + // 如果不可见，跳转到便签列表 Activity + Intent jump = new Intent(this, NotesListActivity.class); + startActivity(jump); + // 显示便签不存在的提示信息 + showToast(R.string.error_note_not_exist); + // 结束当前 Activity + finish(); + return false; + } else { + // 加载便签 + mWorkingNote = WorkingNote.load(this, noteId); + if (mWorkingNote == null) { + Log.e(TAG, "load note failed with note id" + noteId); + finish(); + return false; + } + } + // 设置软键盘隐藏并调整布局 + getWindow().setSoftInputMode( + WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN + | WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE); + } + // 如果 Intent 的操作是插入或编辑便签 + else if(TextUtils.equals(Intent.ACTION_INSERT_OR_EDIT, intent.getAction())) { + // 获取文件夹 ID + long folderId = intent.getLongExtra(Notes.INTENT_EXTRA_FOLDER_ID, 0); + // 获取小部件 ID + int widgetId = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_ID, + AppWidgetManager.INVALID_APPWIDGET_ID); + // 获取小部件类型 + int widgetType = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, + Notes.TYPE_WIDGET_INVALIDE); + // 获取背景资源 ID + int bgResId = intent.getIntExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, + ResourceParser.getDefaultBgId(this)); + + // 解析通话记录便签 + String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER); + long callDate = intent.getLongExtra(Notes.INTENT_EXTRA_CALL_DATE, 0); + if (callDate != 0 && phoneNumber != null) { + if (TextUtils.isEmpty(phoneNumber)) { + Log.w(TAG, "The call record number is null"); + } + long noteId = 0; + // 根据电话号码和通话日期查找便签 ID + if ((noteId = DataUtils.getNoteIdByPhoneNumberAndCallDate(getContentResolver(), + phoneNumber, callDate)) > 0) { + // 加载通话记录便签 + mWorkingNote = WorkingNote.load(this, noteId); + if (mWorkingNote == null) { + Log.e(TAG, "load call note failed with note id" + noteId); + finish(); + return false; + } + } else { + // 创建新的通话记录便签 + mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId, + widgetType, bgResId); + mWorkingNote.convertToCallNote(phoneNumber, callDate); + } + } else { + // 创建新的便签 + mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId, widgetType, + bgResId); + } + + // 设置软键盘可见并调整布局 + getWindow().setSoftInputMode( + WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE + | WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE); + } + // 如果 Intent 未指定操作类型 + else { + Log.e(TAG, "Intent not specified action, should not support"); + finish(); + return false; + } + // 设置便签设置状态改变监听器 + mWorkingNote.setOnSettingStatusChangedListener(this); + return true; + } + + /** + * Activity 恢复可见时调用的方法，初始化便签界面。 + */ + @Override + protected void onResume() { + super.onResume(); + // 初始化便签界面 + initNoteScreen(); + } + + /** + * 初始化便签界面，设置便签编辑器的文本样式、内容，以及背景颜色、修改日期等信息。 + */ + private void initNoteScreen() { + // 设置便签编辑器的文本样式 + mNoteEditor.setTextAppearance(this, TextAppearanceResources + .getTexAppearanceResource(mFontSizeId)); + // 如果便签是复选列表模式 + if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) { + // 切换到列表模式 + switchToListMode(mWorkingNote.getContent()); + } else { + // 设置便签编辑器的文本，并高亮显示查询关键词 + mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery)); + // 将光标移动到文本末尾 + mNoteEditor.setSelection(mNoteEditor.getText().length()); + } + // 隐藏所有背景选择状态视图 + for (Integer id : sBgSelectorSelectionMap.keySet()) { + findViewById(sBgSelectorSelectionMap.get(id)).setVisibility(View.GONE); + } + // 设置便签头部视图的背景资源 + mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId()); + // 设置便签编辑器面板的背景资源 + mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId()); + + // 设置便签修改日期的显示 + mNoteHeaderHolder.tvModified.setText(DateUtils.formatDateTime(this, + mWorkingNote.getModifiedDate(), DateUtils.FORMAT_SHOW_DATE + | DateUtils.FORMAT_NUMERIC_DATE | DateUtils.FORMAT_SHOW_TIME + | DateUtils.FORMAT_SHOW_YEAR)); + + /** + * TODO: Add the menu for setting alert. Currently disable it because the DateTimePicker + * is not ready + */ + // 显示提醒头部信息 + showAlertHeader(); + } + + /** + * 显示提醒相关的头部信息 + * 根据笔记是否设置了提醒以及提醒时间是否过期，更新提醒日期文本和提醒图标 + */ + private void showAlertHeader() { + // 检查笔记是否设置了提醒 + if (mWorkingNote.hasClockAlert()) { + // 获取当前时间 + long time = System.currentTimeMillis(); + // 检查提醒时间是否已过期 + if (time > mWorkingNote.getAlertDate()) { + // 如果已过期，设置提醒日期文本为“提醒已过期” + mNoteHeaderHolder.tvAlertDate.setText(R.string.note_alert_expired); + } else { + // 如果未过期，设置提醒日期文本为相对时间（如“1 分钟后”） + mNoteHeaderHolder.tvAlertDate.setText(DateUtils.getRelativeTimeSpanString( + mWorkingNote.getAlertDate(), time, DateUtils.MINUTE_IN_MILLIS)); + } + // 显示提醒日期文本 + mNoteHeaderHolder.tvAlertDate.setVisibility(View.VISIBLE); + // 显示提醒图标 + mNoteHeaderHolder.ivAlertIcon.setVisibility(View.VISIBLE); + } else { + // 如果笔记未设置提醒，隐藏提醒日期文本 + mNoteHeaderHolder.tvAlertDate.setVisibility(View.GONE); + // 隐藏提醒图标 + mNoteHeaderHolder.ivAlertIcon.setVisibility(View.GONE); + } + } + + /** + * 当接收到新的 Intent 时调用 + * 重新初始化活动状态以处理新的 Intent + * @param intent 新的 Intent + */ + @Override + protected void onNewIntent(Intent intent) { + // 调用父类的 onNewIntent 方法 + super.onNewIntent(intent); + // 初始化活动状态 + initActivityState(intent); + } + + /** + * 在活动状态保存时调用 + * 保存笔记 ID 到 Bundle 中，并在必要时保存笔记 + * @param outState 用于保存状态的 Bundle + */ + @Override + protected void onSaveInstanceState(Bundle outState) { + // 调用父类的 onSaveInstanceState 方法 + super.onSaveInstanceState(outState); + /** + * 对于没有笔记 ID 的新笔记，我们应该首先保存它以生成一个 ID + * 如果正在编辑的笔记不值得保存，则没有 ID，这相当于创建新笔记 + */ + if (!mWorkingNote.existInDatabase()) { + // 保存笔记 + saveNote(); + } + // 将笔记 ID 保存到 Bundle 中 + outState.putLong(Intent.EXTRA_UID, mWorkingNote.getNoteId()); + // 记录日志，显示保存的笔记 ID + Log.d(TAG, "Save working note id: " + mWorkingNote.getNoteId() + " onSaveInstanceState"); + } + + /** + * 分发触摸事件 + * 当背景颜色选择器或字体大小选择器可见且触摸事件不在其范围内时，隐藏选择器 + * @param ev 触摸事件 + * @return 如果事件已处理则返回 true，否则返回父类的 dispatchTouchEvent 方法的结果 + */ + @Override + public boolean dispatchTouchEvent(MotionEvent ev) { + // 检查背景颜色选择器是否可见且触摸事件不在其范围内 + if (mNoteBgColorSelector.getVisibility() == View.VISIBLE + && !inRangeOfView(mNoteBgColorSelector, ev)) { + // 隐藏背景颜色选择器 + mNoteBgColorSelector.setVisibility(View.GONE); + return true; + } + // 检查字体大小选择器是否可见且触摸事件不在其范围内 + if (mFontSizeSelector.getVisibility() == View.VISIBLE + && !inRangeOfView(mFontSizeSelector, ev)) { + // 隐藏字体大小选择器 + mFontSizeSelector.setVisibility(View.GONE); + return true; + } + // 调用父类的 dispatchTouchEvent 方法 + return super.dispatchTouchEvent(ev); + } + + /** + * 检查触摸事件是否在指定视图的范围内 + * @param view 要检查的视图 + * @param ev 触摸事件 + * @return 如果触摸事件在视图范围内则返回 true，否则返回 false + */ + private boolean inRangeOfView(View view, MotionEvent ev) { + // 获取视图在屏幕上的位置 + int []location = new int[2]; + view.getLocationOnScreen(location); + int x = location[0]; + int y = location[1]; + // 检查触摸事件的坐标是否在视图范围内 + if (ev.getX() < x + || ev.getX() > (x + view.getWidth()) + || ev.getY() < y + || ev.getY() > (y + view.getHeight())) { + return false; + } + return true; + } + + /** + * 初始化资源 + * 查找视图组件并设置监听器，同时初始化共享偏好和字体大小 + */ + private void initResources() { + // 查找笔记标题视图 + mHeadViewPanel = findViewById(R.id.note_title); + // 初始化头部视图持有者 + mNoteHeaderHolder = new HeadViewHolder(); + // 查找修改日期文本视图 + 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); + } + // 获取默认的共享偏好 + mSharedPrefs = PreferenceManager.getDefaultSharedPreferences(this); + // 从共享偏好中获取字体大小 ID，如果不存在则使用默认值 + mFontSizeId = mSharedPrefs.getInt(PREFERENCE_FONT_SIZE, ResourceParser.BG_DEFAULT_FONT_SIZE); + /** + * 修复在共享偏好中存储资源 ID 的 bug + * 如果 ID 大于资源的长度，则返回默认字体大小 + */ + if(mFontSizeId >= TextAppearanceResources.getResourcesSize()) { + mFontSizeId = ResourceParser.BG_DEFAULT_FONT_SIZE; + } + // 查找笔记编辑列表视图 + mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list); + } + + /** + * 在活动暂停时调用 + * 保存笔记数据并清除设置状态 + */ + @Override + protected void onPause() { + // 调用父类的 onPause 方法 + super.onPause(); + // 保存笔记数据 + 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); + // 根据笔记的小部件类型设置 Intent 的类 + 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; + } + // 将笔记的小部件 ID 添加到 Intent 中 + intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] { + mWorkingNote.getWidgetId() + }); + // 发送广播更新小部件 + sendBroadcast(intent); + // 设置活动结果为成功，并返回更新小部件的 Intent + setResult(RESULT_OK, intent); + } + + /** + * 处理视图的点击事件 + * 根据点击的视图 ID 执行相应的操作，如显示背景颜色选择器、设置背景颜色、设置字体大小等 + * @param v 被点击的视图 + */ + public void onClick(View v) { + // 获取被点击视图的 ID + int id = v.getId(); + // 如果点击的是设置背景颜色按钮 + if (id == R.id.btn_set_bg_color) { + // 显示背景颜色选择器 + mNoteBgColorSelector.setVisibility(View.VISIBLE); + // 显示当前背景颜色的选中状态 + findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility( + View.VISIBLE); + } else if (sBgSelectorBtnsMap.containsKey(id)) { + // 如果点击的是背景颜色选择器中的按钮 + // 隐藏当前背景颜色的选中状态 + findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility( + View.GONE); + // 设置笔记的背景颜色 ID + mWorkingNote.setBgColorId(sBgSelectorBtnsMap.get(id)); + // 隐藏背景颜色选择器 + mNoteBgColorSelector.setVisibility(View.GONE); + } else if (sFontSizeBtnsMap.containsKey(id)) { + // 如果点击的是字体大小选择器中的按钮 + // 隐藏当前字体大小的选中状态 + findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.GONE); + // 设置新的字体大小 ID + mFontSizeId = sFontSizeBtnsMap.get(id); + // 将新的字体大小 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()); + } else { + // 如果笔记不处于列表模式，设置笔记编辑器的字体外观 + mNoteEditor.setTextAppearance(this, + TextAppearanceResources.getTexAppearanceResource(mFontSizeId)); + } + // 隐藏字体大小选择器 + mFontSizeSelector.setVisibility(View.GONE); + } + } + + /** + * 处理返回按钮事件 + * 在返回之前保存笔记数据并清除设置状态 + */ + @Override + public void onBackPressed() { + // 清除设置状态，如果设置状态已清除则返回 + if(clearSettingState()) { + return; + } + // 保存笔记数据 + saveNote(); + // 调用父类的 onBackPressed 方法 + super.onBackPressed(); + } + + /** + * 清除设置状态 + * 如果背景颜色选择器或字体大小选择器可见，则隐藏它们并返回 true，否则返回 false + * @return 如果设置状态已清除则返回 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; + } + return false; + } + + /** + * 当背景颜色改变时调用 + * 更新背景颜色选择器的选中状态，并更新笔记编辑器面板和标题的背景资源 + */ + public void onBackgroundColorChanged() { + // 显示当前背景颜色的选中状态 + findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility( + View.VISIBLE); + // 更新笔记编辑器面板的背景资源 + mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId()); + // 更新笔记标题的背景资源 + mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId()); + } + @Override + /** + * 当选项菜单即将显示时调用此方法，用于对菜单进行准备工作， + * 包括清除现有菜单、根据笔记类型和状态调整菜单项等操作。 + * + * @param menu 要准备的菜单对象 + * @return 如果菜单应该显示，则返回 true；否则返回 false + */ + public boolean onPrepareOptionsMenu(Menu menu) { + // 检查当前 Activity 是否正在结束，如果是则直接返回 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); + } + // 检查笔记是否处于清单模式 + 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; + } + + @Override + /** + * 当菜单项被选中时调用此方法，根据选中的菜单项 ID 执行相应的操作。 + * + * @param item 被选中的菜单项 + * @return 如果菜单项的选择事件已被处理，则返回 true；否则返回 false + */ + public boolean onOptionsItemSelected(MenuItem item) { + // 根据菜单项的 ID 进行不同的操作 + switch (item.getItemId()) { + case R.id.menu_new_note: + // 点击新建笔记菜单项，调用创建新笔记的方法 + createNewNote(); + break; + case 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); + // 设置对话框的消息内容 + builder.setMessage(getString(R.string.alert_message_delete_note)); + // 设置对话框的确定按钮及其点击事件 + builder.setPositiveButton(android.R.string.ok, + new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int which) { + // 点击确定按钮，调用删除当前笔记的方法，并关闭当前 Activity + deleteCurrentNote(); + finish(); + } + }); + // 设置对话框的取消按钮，点击后不做任何操作 + builder.setNegativeButton(android.R.string.cancel, null); + // 显示对话框 + builder.show(); + break; + case R.id.menu_font_size: + // 点击字体大小菜单项，显示字体大小选择器，并高亮显示当前选中的字体大小 + mFontSizeSelector.setVisibility(View.VISIBLE); + findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE); + break; + case R.id.menu_list_mode: + // 点击列表模式菜单项，切换笔记的清单模式状态 + mWorkingNote.setCheckListMode(mWorkingNote.getCheckListMode() == 0 ? + TextNote.MODE_CHECK_LIST : 0); + break; + case R.id.menu_share: + // 点击分享菜单项，获取当前笔记的文本内容并调用分享方法 + getWorkingText(); + sendTo(this, mWorkingNote.getContent()); + break; + case R.id.menu_send_to_desktop: + // 点击发送到桌面菜单项，调用发送到桌面的方法 + sendToDesktop(); + break; + case R.id.menu_alert: + // 点击设置提醒菜单项，调用设置提醒的方法 + setReminder(); + break; + case R.id.menu_delete_remind: + // 点击删除提醒菜单项，将笔记的提醒日期设置为 0，表示取消提醒 + mWorkingNote.setAlertDate(0, false); + break; + default: + // 如果点击的菜单项 ID 不在上述范围内，不做任何操作 + break; + } + // 返回 true 表示菜单项的选择事件已被处理 + return true; + } + + /** + * 设置笔记的提醒时间，弹出日期时间选择对话框，用户选择时间后设置提醒。 + */ + private void setReminder() { + // 创建一个日期时间选择对话框，初始时间为当前时间 + DateTimePickerDialog d = new DateTimePickerDialog(this, System.currentTimeMillis()); + // 设置对话框的时间选择监听器 + d.setOnDateTimeSetListener(new OnDateTimeSetListener() { + public void OnDateTimeSet(AlertDialog dialog, long date) { + // 用户选择时间后，将笔记的提醒日期设置为选择的时间，并标记为已设置提醒 + mWorkingNote.setAlertDate(date, true); + } + }); + // 显示日期时间选择对话框 + d.show(); + } + + /** + * 将笔记内容分享到支持 ACTION_SEND 动作和 text/plain 类型的应用中。 + * + * @param context 上下文对象 + * @param info 要分享的笔记内容 + */ + private void sendTo(Context context, String info) { + // 创建一个分享意图 + Intent intent = new Intent(Intent.ACTION_SEND); + // 将笔记内容添加到意图的额外数据中 + intent.putExtra(Intent.EXTRA_TEXT, info); + // 设置意图的数据类型为文本 + intent.setType("text/plain"); + // 启动分享意图 + context.startActivity(intent); + } + + /** + * 创建一个新的笔记，首先保存当前正在编辑的笔记，然后启动一个新的笔记编辑 Activity。 + */ + private void createNewNote() { + // 保存当前正在编辑的笔记 + saveNote(); + // 关闭当前 Activity + finish(); + // 创建一个新的笔记编辑意图 + Intent intent = new Intent(this, NoteEditActivity.class); + // 设置意图的动作类型为插入或编辑 + intent.setAction(Intent.ACTION_INSERT_OR_EDIT); + // 将当前笔记所在的文件夹 ID 添加到意图的额外数据中 + intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mWorkingNote.getFolderId()); + // 启动新的笔记编辑 Activity + startActivity(intent); + } + + /** + * 删除当前笔记，根据同步模式的不同，执行不同的删除操作。 + */ + private void deleteCurrentNote() { + // 检查笔记是否存在于数据库中 + if (mWorkingNote.existInDatabase()) { + // 创建一个用于存储笔记 ID 的集合 + HashSet ids = new HashSet(); + // 获取当前笔记的 ID + long id = mWorkingNote.getNoteId(); + // 检查笔记 ID 是否不是根文件夹 ID + if (id != Notes.ID_ROOT_FOLDER) { + // 将笔记 ID 添加到集合中 + ids.add(id); + } else { + // 如果笔记 ID 是根文件夹 ID，记录错误日志 + Log.d(TAG, "Wrong note id, should not happen"); + } + // 检查是否处于同步模式 + if (!isSyncMode()) { + // 如果不是同步模式，直接从数据库中批量删除笔记 + if (!DataUtils.batchDeleteNotes(getContentResolver(), ids)) { + // 如果删除失败，记录错误日志 + Log.e(TAG, "Delete Note error"); + } + } else { + // 如果是同步模式，将笔记批量移动到垃圾桶文件夹 + if (!DataUtils.batchMoveToFolder(getContentResolver(), ids, Notes.ID_TRASH_FOLER)) { + // 如果移动失败，记录错误日志 + Log.e(TAG, "Move notes to trash folder error, should not happens"); + } + } + } + // 标记当前笔记为已删除 + mWorkingNote.markDeleted(true); + } + + /** + * 检查是否处于同步模式，通过获取同步账户名来判断。 + * + * @return 如果存在有效的同步账户名，则返回 true；否则返回 false + */ + private boolean isSyncMode() { + // 获取同步账户名并去除首尾空格，检查长度是否大于 0 + return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0; + } + + /** + * 当笔记的提醒设置发生变化时调用此方法，处理提醒的设置和取消操作。 + * + * @param date 提醒的日期时间 + * @param set 是否设置提醒 + */ + public void onClockAlertChanged(long date, boolean set) { + /** + * 用户可能会对未保存的笔记设置提醒，所以在设置提醒之前， + * 应该先保存笔记以确保笔记有有效的 ID。 + */ + if (!mWorkingNote.existInDatabase()) { + // 如果笔记不存在于数据库中，保存笔记 + saveNote(); + } + // 检查笔记的 ID 是否大于 0 + if (mWorkingNote.getNoteId() > 0) { + // 创建一个用于接收提醒广播的意图 + Intent intent = new Intent(this, AlarmReceiver.class); + // 设置意图的数据为笔记的 URI，包含笔记的 ID + intent.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mWorkingNote.getNoteId())); + // 创建一个用于广播的待定意图 + PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, intent, 0); + // 获取系统的闹钟服务 + AlarmManager alarmManager = ((AlarmManager) getSystemService(ALARM_SERVICE)); + // 更新提醒头部的显示信息 + showAlertHeader(); + // 根据是否设置提醒的标志进行不同的操作 + if(!set) { + // 如果取消提醒，取消闹钟服务中的待定意图 + alarmManager.cancel(pendingIntent); + } else { + // 如果设置提醒，设置闹钟服务在指定的日期时间触发待定意图 + alarmManager.set(AlarmManager.RTC_WAKEUP, date, pendingIntent); + } + } else { + /** + * 存在用户没有输入任何内容的情况（笔记不值得保存），此时没有笔记 ID， + * 提醒用户应该输入一些内容。 + */ + Log.e(TAG, "Clock alert setting error"); + // 显示错误提示信息 + showToast(R.string.error_note_empty_for_clock); + } + } + + /** + * 当笔记的小部件设置发生变化时调用此方法，更新小部件的显示内容。 + */ + public void onWidgetChanged() { + // 调用更新小部件的方法 + updateWidget(); + } + + /** + * 当编辑文本被删除时调用此方法，处理文本删除后的布局和索引调整。 + * + * @param index 被删除文本的索引 + * @param text 被删除的文本内容 + */ + public void onEditTextDelete(int index, String text) { + // 获取编辑文本列表的子视图数量 + int childCount = mEditTextList.getChildCount(); + // 如果子视图数量为 1，不进行任何操作 + if (childCount == 1) { + return; + } + // 从被删除文本的下一个索引开始，更新后续编辑文本的索引 + for (int i = index + 1; i < childCount; i++) { + ((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text)) + .setIndex(i - 1); + } + // 从编辑文本列表中移除指定索引的视图 + mEditTextList.removeViewAt(index); + // 声明一个 NoteEditText 对象用于后续操作 + NoteEditText edit = null; + // 如果被删除的是第一个文本，获取第一个编辑文本视图 + if(index == 0) { + edit = (NoteEditText) mEditTextList.getChildAt(0).findViewById( + R.id.et_edit_text); + } else { + // 否则，获取被删除文本的前一个编辑文本视图 + edit = (NoteEditText) mEditTextList.getChildAt(index - 1).findViewById( + R.id.et_edit_text); + } + // 获取编辑文本的当前长度 + int length = edit.length(); + // 将被删除的文本追加到获取的编辑文本后面 + edit.append(text); + // 让编辑文本获取焦点 + edit.requestFocus(); + // 设置编辑文本的光标位置为追加文本后的末尾 + edit.setSelection(length); + } + + /** + * 当编辑文本中按下回车键时调用此方法，处理插入新的编辑文本视图和索引调整。 + * + * @param index 插入位置的索引 + * @param text 要插入的文本内容 + */ + public void onEditTextEnter(int index, String text) { + /** + * 这种情况不应该发生，用于调试时检查索引是否超出编辑文本列表的范围。 + */ + if(index > mEditTextList.getChildCount()) { + // 如果索引超出范围，记录错误日志 + Log.e(TAG, "Index out of mEditTextList boundrary, should not happen"); + } + // 获取一个新的编辑文本列表项视图 + View view = getListItem(text, index); + // 将新的视图插入到指定索引位置 + mEditTextList.addView(view, index); + // 获取新视图中的编辑文本视图 + NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text); + // 让编辑文本获取焦点 + edit.requestFocus(); + // 设置编辑文本的光标位置为开头 + edit.setSelection(0); + // 从插入位置的下一个索引开始，更新后续编辑文本的索引 + 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"); + // 初始化索引为 0 + int index = 0; + // 遍历分割后的条目 + for (String item : items) { + // 检查条目是否不为空 + if(!TextUtils.isEmpty(item)) { + // 如果不为空，将条目添加到编辑文本列表中 + mEditTextList.addView(getListItem(item, index)); + // 索引加 1 + 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)) { + // 编译用户查询的关键字为正则表达式模式 + mPattern = Pattern.compile(userQuery); + // 创建一个匹配器对象，用于在完整文本中查找匹配的关键字 + Matcher m = mPattern.matcher(fullText); + // 初始化查找的起始位置为 0 + int start = 0; + // 循环查找所有匹配的关键字 + while (m.find(start)) { + // 在匹配的关键字位置设置背景颜色跨度，实现高亮显示 + spannable.setSpan( + new BackgroundColorSpan(this.getResources().getColor( + R.color.user_query_highlight)), m.start(), m.end(), + Spannable.SPAN_INCLUSIVE_EXCLUSIVE); + start = m.end(); + } + } + return spannable; + } + /** + * 创建并配置列表项视图 + * + * @param item 列表项的文本内容 + * @param index 列表项的索引 + * @return 配置好的列表项视图 + */ + private View getListItem(String item, int index) { + // 从布局文件 note_edit_list_item 中加载视图 + View view = LayoutInflater.from(this).inflate(R.layout.note_edit_list_item, null); + // 找到列表项中的编辑文本视图 + 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() { + /** + * 当复选框的选中状态改变时调用此方法 + * + * @param buttonView 复选框视图 + * @param isChecked 新的选中状态 + */ + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { + if (isChecked) { + // 如果复选框被选中，为编辑文本添加删除线效果 + edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG); + } else { + // 如果复选框未被选中，移除编辑文本的删除线效果，并设置抗锯齿和字距调整 + edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG); + } + } + }); + + // 如果列表项文本以已选中标记开头 + if (item.startsWith(TAG_CHECKED)) { + // 设置复选框为选中状态 + cb.setChecked(true); + // 为编辑文本添加删除线效果 + edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG); + // 去除已选中标记并去除首尾空格 + item = item.substring(TAG_CHECKED.length(), item.length()).trim(); + } else if (item.startsWith(TAG_UNCHECKED)) { + // 如果列表项文本以未选中标记开头，设置复选框为未选中状态 + cb.setChecked(false); + // 移除编辑文本的删除线效果，并设置抗锯齿和字距调整 + edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG); + // 去除未选中标记并去除首尾空格 + item = item.substring(TAG_UNCHECKED.length(), item.length()).trim(); + } + + // 为编辑文本视图设置文本内容改变的监听器 + edit.setOnTextViewChangeListener(this); + // 设置编辑文本视图的索引 + edit.setIndex(index); + // 设置编辑文本视图的文本，并对查询关键字进行高亮显示 + edit.setText(getHighlightQueryResult(item, mUserQuery)); + // 返回配置好的列表项视图 + return view; + } + + /** + * 当编辑文本的内容发生变化时调用此方法 + * + * @param index 编辑文本所在的索引 + * @param hasText 编辑文本是否有内容 + */ + 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 { + // 如果编辑文本没有内容，隐藏对应的复选框 + mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.GONE); + } + } + + /** + * 当清单模式发生变化时调用此方法 + * + * @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 + " ", + "")); + } + // 设置编辑文本的内容，并对查询关键字进行高亮显示 + 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; + } else { + // 如果对应的复选框未被选中，添加未选中标记 + sb.append(TAG_UNCHECKED).append(" ").append(edit.getText()).append("\n"); + } + } + } + // 设置工作笔记的文本内容 + mWorkingNote.setWorkingText(sb.toString()); + } else { + // 如果不是清单模式，直接设置工作笔记的文本内容为编辑文本视图的内容 + mWorkingNote.setWorkingText(mNoteEditor.getText().toString()); + } + return hasChecked; + } + + /** + * 保存当前编辑的笔记 + * + * @return 如果保存成功返回 true，否则返回 false + */ + private boolean saveNote() { + // 获取当前工作笔记的文本内容 + getWorkingText(); + // 调用工作笔记的保存方法 + boolean saved = mWorkingNote.saveNote(); + if (saved) { + /** + * 存在两种从列表视图进入编辑视图的模式，打开一个笔记或创建/编辑一个笔记。 + * 打开笔记需要在从编辑视图返回时回到列表中的原始位置，而创建新笔记需要回到列表顶部。 + * 此 RESULT_OK 代码用于标识创建/编辑状态 + */ + setResult(RESULT_OK); + } + return saved; + } + + /** + * 将当前笔记发送到桌面作为快捷方式 + */ + private void sendToDesktop() { + /** + * 在向主屏幕发送消息之前，需要确保当前编辑的笔记已存在于数据库中。 + * 因此，对于新笔记，首先保存它 + */ + if (!mWorkingNote.existInDatabase()) { + saveNote(); + } + + if (mWorkingNote.getNoteId() > 0) { + // 如果笔记有有效的 ID + Intent sender = new Intent(); + // 创建一个打开笔记编辑界面的意图 + Intent shortcutIntent = new Intent(this, NoteEditActivity.class); + shortcutIntent.setAction(Intent.ACTION_VIEW); + shortcutIntent.putExtra(Intent.EXTRA_UID, mWorkingNote.getNoteId()); + // 将打开笔记的意图添加到快捷方式意图中 + sender.putExtra(Intent.EXTRA_SHORTCUT_INTENT, shortcutIntent); + // 设置快捷方式的名称 + sender.putExtra(Intent.EXTRA_SHORTCUT_NAME, + makeShortcutIconTitle(mWorkingNote.getContent())); + // 设置快捷方式的图标 + sender.putExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE, + Intent.ShortcutIconResource.fromContext(this, R.drawable.icon_app)); + // 允许创建重复的快捷方式 + sender.putExtra("duplicate", true); + // 设置意图的动作为安装快捷方式 + sender.setAction("com.android.launcher.action.INSTALL_SHORTCUT"); + // 显示提示信息 + showToast(R.string.info_note_enter_desktop); + // 发送广播以创建快捷方式 + sendBroadcast(sender); + } else { + /** + * 存在用户未输入任何内容的情况（笔记不值得保存），此时没有笔记 ID， + * 提醒用户应该输入一些内容 + */ + Log.e(TAG, "Send to desktop error"); + showToast(R.string.error_note_empty_for_send_to_desktop); + } + } + + /** + * 生成快捷方式图标上显示的标题 + * + * @param content 笔记的内容 + * @return 处理后的标题 + */ + private String makeShortcutIconTitle(String content) { + // 移除内容中的已选中和未选中标记 + content = content.replace(TAG_CHECKED, ""); + content = content.replace(TAG_UNCHECKED, ""); + // 如果内容长度超过最大长度，截取前 SHORTCUT_ICON_TITLE_MAX_LEN 个字符 + return content.length() > SHORTCUT_ICON_TITLE_MAX_LEN ? content.substring(0, + SHORTCUT_ICON_TITLE_MAX_LEN) : content; + } + + /** + * 显示短时间的提示信息 + * + * @param resId 提示信息的资源 ID + */ + private void showToast(int resId) { + // 调用另一个 showToast 方法，显示短时间的提示信息 + showToast(resId, Toast.LENGTH_SHORT); + } + + /** + * 显示指定时长的提示信息 + * + * @param resId 提示信息的资源 ID + * @param duration 提示信息显示的时长 + */ + private void showToast(int resId, int duration) { + // 使用 Toast 显示提示信息 + Toast.makeText(this, resId, duration).show(); + } \ No newline at end of file diff --git a/src/代码注释/ui/NoteEditText.java b/src/代码注释/ui/NoteEditText.java new file mode 100644 index 0000000..b5b192b --- /dev/null +++ b/src/代码注释/ui/NoteEditText.java @@ -0,0 +1,309 @@ +/* + * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package net.micode.notes.ui; + +import android.content.Context; +import android.graphics.Rect; +import android.text.Layout; +import android.text.Selection; +import android.text.Spanned; +import android.text.TextUtils; +import android.text.style.URLSpan; +import android.util.AttributeSet; +import android.util.Log; +import android.view.ContextMenu; +import android.view.KeyEvent; +import android.view.MenuItem; +import android.view.MenuItem.OnMenuItemClickListener; +import android.view.MotionEvent; +import android.widget.EditText; + +import net.micode.notes.R; + +import java.util.HashMap; +import java.util.Map; + +// 自定义的 EditText 类，继承自 EditText，用于处理笔记编辑的特定逻辑 +public class NoteEditText extends EditText { + // 日志标签，用于调试信息输出 + private static final String TAG = "NoteEditText"; + // 该 EditText 在集合中的索引 + private int mIndex; + // 删除操作前的选择起始位置 + private int mSelectionStartBeforeDelete; + + // 定义支持的 URL 协议 + private static final String SCHEME_TEL = "tel:" ; + private static final String SCHEME_HTTP = "http:" ; + private static final String SCHEME_EMAIL = "mailto:" ; + + // 存储 URL 协议和对应的菜单资源 ID 的映射 + private static final Map sSchemaActionResMap = new HashMap(); + static { + // 初始化映射，将不同协议与对应的菜单文本资源 ID 关联 + sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel); + sSchemaActionResMap.put(SCHEME_HTTP, R.string.note_link_web); + sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email); + } + + /** + * 该接口由 NoteEditActivity 实现，用于处理 EditText 的删除、添加和文本变化事件 + */ + public interface OnTextViewChangeListener { + /** + * 当按下删除键且文本为空时，删除当前 EditText + * @param index 当前 EditText 的索引 + * @param text 当前 EditText 的文本 + */ + void onEditTextDelete(int index, String text); + + /** + * 当按下回车键时，在当前 EditText 之后添加一个新的 EditText + * @param index 新 EditText 的索引 + * @param text 从当前选择位置到文本末尾的文本 + */ + void onEditTextEnter(int index, String text); + + /** + * 当文本变化时，隐藏或显示菜单项 + * @param index 当前 EditText 的索引 + * @param hasText 当前 EditText 是否有文本 + */ + void onTextChange(int index, boolean hasText); + } + + // 文本变化监听器 + private OnTextViewChangeListener mOnTextViewChangeListener; + + /** + * 构造函数，使用默认属性 + * @param context 上下文对象 + */ + public NoteEditText(Context context) { + super(context, null); + // 初始化索引为 0 + mIndex = 0; + } + + /** + * 设置当前 EditText 的索引 + * @param index 索引值 + */ + public void setIndex(int index) { + mIndex = index; + } + + /** + * 设置文本变化监听器 + * @param listener 监听器对象 + */ + public void setOnTextViewChangeListener(OnTextViewChangeListener listener) { + mOnTextViewChangeListener = listener; + } + + /** + * 构造函数，使用指定属性 + * @param context 上下文对象 + * @param attrs 属性集 + */ + public NoteEditText(Context context, AttributeSet attrs) { + super(context, attrs, android.R.attr.editTextStyle); + } + + /** + * 构造函数，使用指定属性和样式 + * @param context 上下文对象 + * @param attrs 属性集 + * @param defStyle 默认样式 + */ + public NoteEditText(Context context, AttributeSet attrs, int defStyle) { + super(context, attrs, defStyle); + // TODO Auto-generated constructor stub + } + + /** + * 处理触摸事件，当按下时设置文本选择位置 + * @param event 触摸事件对象 + * @return 是否处理该事件 + */ + @Override + public boolean onTouchEvent(MotionEvent event) { + switch (event.getAction()) { + case MotionEvent.ACTION_DOWN: + // 获取触摸点的坐标 + int x = (int) event.getX(); + int y = (int) event.getY(); + // 调整坐标，去除内边距并考虑滚动 + x -= getTotalPaddingLeft(); + y -= getTotalPaddingTop(); + x += getScrollX(); + y += getScrollY(); + + // 获取文本布局 + Layout layout = getLayout(); + // 根据垂直坐标获取行号 + int line = layout.getLineForVertical(y); + // 根据行号和水平坐标获取字符偏移量 + int off = layout.getOffsetForHorizontal(line, x); + // 设置文本选择位置 + Selection.setSelection(getText(), off); + break; + } + + return super.onTouchEvent(event); + } + + /** + * 处理按键按下事件 + * @param keyCode 按键码 + * @param event 按键事件对象 + * @return 是否处理该事件 + */ + @Override + public boolean onKeyDown(int keyCode, KeyEvent event) { + switch (keyCode) { + case KeyEvent.KEYCODE_ENTER: + // 如果设置了监听器，不处理回车键事件 + if (mOnTextViewChangeListener != null) { + return false; + } + break; + case KeyEvent.KEYCODE_DEL: + // 记录删除操作前的选择起始位置 + mSelectionStartBeforeDelete = getSelectionStart(); + break; + default: + break; + } + return super.onKeyDown(keyCode, event); + } + + /** + * 处理按键抬起事件 + * @param keyCode 按键码 + * @param event 按键事件对象 + * @return 是否处理该事件 + */ + @Override + public boolean onKeyUp(int keyCode, KeyEvent event) { + switch(keyCode) { + case KeyEvent.KEYCODE_DEL: + // 如果设置了监听器 + if (mOnTextViewChangeListener != null) { + // 当选择起始位置为 0 且索引不为 0 时，触发删除操作 + if (0 == mSelectionStartBeforeDelete && mIndex != 0) { + mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString()); + return true; + } + } else { + // 未设置监听器，输出日志 + Log.d(TAG, "OnTextViewChangeListener was not seted"); + } + break; + case KeyEvent.KEYCODE_ENTER: + // 如果设置了监听器 + if (mOnTextViewChangeListener != null) { + // 获取选择起始位置 + int selectionStart = getSelectionStart(); + // 获取从选择起始位置到文本末尾的文本 + String text = getText().subSequence(selectionStart, length()).toString(); + // 设置文本为从开头到选择起始位置的内容 + setText(getText().subSequence(0, selectionStart)); + // 触发添加 EditText 操作 + mOnTextViewChangeListener.onEditTextEnter(mIndex + 1, text); + } else { + // 未设置监听器，输出日志 + Log.d(TAG, "OnTextViewChangeListener was not seted"); + } + break; + default: + break; + } + return super.onKeyUp(keyCode, event); + } + + /** + * 处理焦点变化事件 + * @param focused 是否获得焦点 + * @param direction 焦点移动方向 + * @param previouslyFocusedRect 之前聚焦的矩形区域 + */ + @Override + protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) { + // 如果设置了监听器 + if (mOnTextViewChangeListener != null) { + // 失去焦点且文本为空时，触发文本变化事件 + if (!focused && TextUtils.isEmpty(getText())) { + mOnTextViewChangeListener.onTextChange(mIndex, false); + } else { + // 其他情况，触发文本变化事件 + mOnTextViewChangeListener.onTextChange(mIndex, true); + } + } + super.onFocusChanged(focused, direction, previouslyFocusedRect); + } + + /** + * 创建上下文菜单 + * @param menu 上下文菜单对象 + */ + @Override + protected void onCreateContextMenu(ContextMenu menu) { + // 如果文本是 Spanned 类型 + if (getText() instanceof Spanned) { + // 获取选择的起始和结束位置 + int selStart = getSelectionStart(); + int selEnd = getSelectionEnd(); + + // 计算选择范围的最小值和最大值 + int min = Math.min(selStart, selEnd); + int max = Math.max(selStart, selEnd); + + // 获取选择范围内的 URLSpan 数组 + final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class); + // 如果只有一个 URLSpan + if (urls.length == 1) { + int defaultResId = 0; + // 遍历支持的协议 + for(String schema: sSchemaActionResMap.keySet()) { + // 如果 URL 包含该协议 + if(urls[0].getURL().indexOf(schema) >= 0) { + // 获取对应的菜单资源 ID + defaultResId = sSchemaActionResMap.get(schema); + break; + } + } + + // 如果未找到匹配的协议，使用默认的菜单资源 ID + if (defaultResId == 0) { + defaultResId = R.string.note_link_other; + } + + // 添加菜单项，并设置点击监听器 + menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener( + new OnMenuItemClickListener() { + public boolean onMenuItemClick(MenuItem item) { + // 点击菜单项时，触发 URLSpan 的点击事件 + urls[0].onClick(NoteEditText.this); + return true; + } + }); + } + } + super.onCreateContextMenu(menu); + } +} \ No newline at end of file diff --git a/src/代码注释/ui/NoteItemData.java b/src/代码注释/ui/NoteItemData.java new file mode 100644 index 0000000..7764e55 --- /dev/null +++ b/src/代码注释/ui/NoteItemData.java @@ -0,0 +1,346 @@ +/* + * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// 声明该类所在的包，属于笔记应用的用户界面相关包 +package net.micode.notes.ui; + +import android.content.Context; +import android.database.Cursor; +import android.text.TextUtils; + +import net.micode.notes.data.Contact; +import net.micode.notes.data.Notes; +import net.micode.notes.data.Notes.NoteColumns; +import net.micode.notes.tool.DataUtils; + +/** + * NoteItemData 类用于封装从数据库中查询得到的笔记项数据。 + * 它提供了一系列方法来获取笔记的各种属性，如 ID、提醒日期、背景颜色等， + * 同时还处理了笔记在列表中的位置信息，如是否为首个、最后一个、唯一一项等。 + */ +public class NoteItemData { + // 定义从数据库查询笔记数据时需要的列名数组 + static final String [] PROJECTION = new String [] { + NoteColumns.ID, // 笔记的唯一标识符 + NoteColumns.ALERTED_DATE, // 笔记的提醒日期 + NoteColumns.BG_COLOR_ID, // 笔记的背景颜色 ID + NoteColumns.CREATED_DATE, // 笔记的创建日期 + NoteColumns.HAS_ATTACHMENT, // 笔记是否有附件 + NoteColumns.MODIFIED_DATE, // 笔记的修改日期 + NoteColumns.NOTES_COUNT, // 笔记数量 + NoteColumns.PARENT_ID, // 笔记的父文件夹 ID + NoteColumns.SNIPPET, // 笔记的摘要 + NoteColumns.TYPE, // 笔记的类型 + NoteColumns.WIDGET_ID, // 笔记对应的小部件 ID + NoteColumns.WIDGET_TYPE, // 笔记对应的小部件类型 + }; + + // 定义各列在 PROJECTION 数组中的索引位置，方便后续从 Cursor 中获取数据 + private static final int ID_COLUMN = 0; + private static final int ALERTED_DATE_COLUMN = 1; + private static final int BG_COLOR_ID_COLUMN = 2; + private static final int CREATED_DATE_COLUMN = 3; + private static final int HAS_ATTACHMENT_COLUMN = 4; + private static final int MODIFIED_DATE_COLUMN = 5; + private static final int NOTES_COUNT_COLUMN = 6; + private static final int PARENT_ID_COLUMN = 7; + private static final int SNIPPET_COLUMN = 8; + private static final int TYPE_COLUMN = 9; + private static final int WIDGET_ID_COLUMN = 10; + private static final int WIDGET_TYPE_COLUMN = 11; + + // 定义类的成员变量，用于存储从数据库中获取的笔记数据 + private long mId; // 笔记的唯一标识符 + private long mAlertDate; // 笔记的提醒日期 + private int mBgColorId; // 笔记的背景颜色 ID + private long mCreatedDate; // 笔记的创建日期 + private boolean mHasAttachment; // 笔记是否有附件 + private long mModifiedDate; // 笔记的修改日期 + private int mNotesCount; // 笔记数量 + private long mParentId; // 笔记的父文件夹 ID + private String mSnippet; // 笔记的摘要 + private int mType; // 笔记的类型 + private int mWidgetId; // 笔记对应的小部件 ID + private int mWidgetType; // 笔记对应的小部件类型 + private String mName; // 联系人姓名 + private String mPhoneNumber; // 联系人电话号码 + + // 定义用于标记笔记在列表中位置的布尔变量 + private boolean mIsLastItem; // 是否为列表中的最后一项 + private boolean mIsFirstItem; // 是否为列表中的第一项 + private boolean mIsOnlyOneItem; // 是否为列表中唯一的一项 + private boolean mIsOneNoteFollowingFolder; // 是否为文件夹后的单条笔记 + private boolean mIsMultiNotesFollowingFolder; // 是否为文件夹后的多条笔记 + + /** + * 构造函数，用于从 Cursor 中获取笔记数据并初始化类的成员变量。 + * @param context 上下文对象，用于获取 ContentResolver 等系统服务 + * @param cursor 包含笔记数据的 Cursor 对象 + */ + public NoteItemData(Context context, Cursor cursor) { + // 从 Cursor 中获取各列的数据并赋值给对应的成员变量 + mId = cursor.getLong(ID_COLUMN); + mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN); + mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN); + mCreatedDate = cursor.getLong(CREATED_DATE_COLUMN); + mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0) ? true : false; + mModifiedDate = cursor.getLong(MODIFIED_DATE_COLUMN); + mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN); + mParentId = cursor.getLong(PARENT_ID_COLUMN); + mSnippet = cursor.getString(SNIPPET_COLUMN); + // 去除摘要中的特定标签 + mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace( + NoteEditActivity.TAG_UNCHECKED, ""); + mType = cursor.getInt(TYPE_COLUMN); + mWidgetId = cursor.getInt(WIDGET_ID_COLUMN); + mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN); + + mPhoneNumber = ""; + // 如果笔记的父文件夹 ID 为通话记录文件夹的 ID + if (mParentId == Notes.ID_CALL_RECORD_FOLDER) { + // 通过笔记 ID 获取通话号码 + mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId); + if (!TextUtils.isEmpty(mPhoneNumber)) { + // 根据电话号码获取联系人姓名 + mName = Contact.getContact(context, mPhoneNumber); + if (mName == null) { + // 如果未找到联系人姓名，则使用电话号码作为姓名 + mName = mPhoneNumber; + } + } + } + + if (mName == null) { + mName = ""; + } + // 检查笔记在列表中的位置信息 + checkPostion(cursor); + } + + /** + * 检查笔记在 Cursor 中的位置信息，设置相应的布尔标记。 + * @param cursor 包含笔记数据的 Cursor 对象 + */ + private void checkPostion(Cursor cursor) { + // 判断是否为列表中的最后一项 + mIsLastItem = cursor.isLast() ? true : false; + // 判断是否为列表中的第一项 + mIsFirstItem = cursor.isFirst() ? true : false; + // 判断是否为列表中唯一的一项 + mIsOnlyOneItem = (cursor.getCount() == 1); + mIsMultiNotesFollowingFolder = false; + mIsOneNoteFollowingFolder = false; + + // 如果笔记类型为普通笔记且不是第一项 + if (mType == Notes.TYPE_NOTE && !mIsFirstItem) { + int position = cursor.getPosition(); + if (cursor.moveToPrevious()) { + // 如果前一项是文件夹或系统类型 + if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER + || cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) { + if (cursor.getCount() > (position + 1)) { + // 如果后面还有其他笔记，则标记为文件夹后的多条笔记 + mIsMultiNotesFollowingFolder = true; + } else { + // 否则标记为文件夹后的单条笔记 + mIsOneNoteFollowingFolder = true; + } + } + // 将 Cursor 移动回原来的位置 + if (!cursor.moveToNext()) { + throw new IllegalStateException("cursor move to previous but can't move back"); + } + } + } + } + + /** + * 判断是否为文件夹后的单条笔记。 + * @return 如果是则返回 true，否则返回 false + */ + public boolean isOneFollowingFolder() { + return mIsOneNoteFollowingFolder; + } + + /** + * 判断是否为文件夹后的多条笔记。 + * @return 如果是则返回 true，否则返回 false + */ + public boolean isMultiFollowingFolder() { + return mIsMultiNotesFollowingFolder; + } + + /** + * 判断是否为列表中的最后一项。 + * @return 如果是则返回 true，否则返回 false + */ + public boolean isLast() { + return mIsLastItem; + } + + /** + * 获取通话记录对应的联系人姓名。 + * @return 联系人姓名 + */ + public String getCallName() { + return mName; + } + + /** + * 判断是否为列表中的第一项。 + * @return 如果是则返回 true，否则返回 false + */ + public boolean isFirst() { + return mIsFirstItem; + } + + /** + * 判断是否为列表中唯一的一项。 + * @return 如果是则返回 true，否则返回 false + */ + public boolean isSingle() { + return mIsOnlyOneItem; + } + + /** + * 获取笔记的唯一标识符。 + * @return 笔记的 ID + */ + public long getId() { + return mId; + } + + /** + * 获取笔记的提醒日期。 + * @return 提醒日期 + */ + public long getAlertDate() { + return mAlertDate; + } + + /** + * 获取笔记的创建日期。 + * @return 创建日期 + */ + public long getCreatedDate() { + return mCreatedDate; + } + + /** + * 判断笔记是否有附件。 + * @return 如果有则返回 true，否则返回 false + */ + public boolean hasAttachment() { + return mHasAttachment; + } + + /** + * 获取笔记的修改日期。 + * @return 修改日期 + */ + public long getModifiedDate() { + return mModifiedDate; + } + + /** + * 获取笔记的背景颜色 ID。 + * @return 背景颜色 ID + */ + public int getBgColorId() { + return mBgColorId; + } + + /** + * 获取笔记的父文件夹 ID。 + * @return 父文件夹 ID + */ + public long getParentId() { + return mParentId; + } + + /** + * 获取笔记数量。 + * @return 笔记数量 + */ + public int getNotesCount() { + return mNotesCount; + } + + /** + * 获取笔记所在的文件夹 ID，与 getParentId 功能相同。 + * @return 文件夹 ID + */ + public long getFolderId () { + return mParentId; + } + + /** + * 获取笔记的类型。 + * @return 笔记类型 + */ + public int getType() { + return mType; + } + + /** + * 获取笔记对应的小部件类型。 + * @return 小部件类型 + */ + public int getWidgetType() { + return mWidgetType; + } + + /** + * 获取笔记对应的小部件 ID。 + * @return 小部件 ID + */ + public int getWidgetId() { + return mWidgetId; + } + + /** + * 获取笔记的摘要。 + * @return 笔记摘要 + */ + public String getSnippet() { + return mSnippet; + } + + /** + * 判断笔记是否设置了提醒。 + * @return 如果设置了提醒则返回 true，否则返回 false + */ + public boolean hasAlert() { + return (mAlertDate > 0); + } + + /** + * 判断笔记是否为通话记录。 + * @return 如果是通话记录则返回 true，否则返回 false + */ + public boolean isCallRecord() { + return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber)); + } + + /** + * 从 Cursor 中获取笔记的类型。 + * @param cursor 包含笔记数据的 Cursor 对象 + * @return 笔记类型 + */ + public static int getNoteType(Cursor cursor) { + return cursor.getInt(TYPE_COLUMN); + } +} \ No newline at end of file