pi7yb2crf
/
xiaomi_note
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

小米便签2周旭升

Browse Source
zhouxusheng_branch
zhouxs 8 months ago
parent 3a3f5a9851
commit f1ea47c2bf
5 changed files with 436 additions and 139 deletions
Show Stats Download Patch File Download Diff File

4
src/Notesmaster/.idea/deploymentTargetSelector.xml
Unescape View File

@ -4,10 +4,10 @@
<selectionStates>
<SelectionState runConfigName="app">
<option name="selectionMode" value="DROPDOWN" />
<DropdownSelection timestamp="2024-11-29T12:03:47.753944Z">
<DropdownSelection timestamp="2024-12-20T09:19:31.518867100Z">
<Target type="DEFAULT_BOOT">
<handle>
<DeviceId pluginId="Default" identifier="serial=127.0.0.1:5555;connection=ca5d55c9" />
<DeviceId pluginId="Default" identifier="serial=emulator-5554;connection=13b9b5d6" />
</handle>
</Target>
</DropdownSelection>

1
src/Notesmaster/.idea/misc.xml
Unescape View File

@ -1,4 +1,3 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ExternalStorageConfigurationManager" enabled="true" />
<component name="ProjectRootManager" version="2" languageLevel="JDK_21" default="true" project-jdk-name="jbr-21" project-jdk-type="JavaSDK">

275
src/Notesmaster/app/src/main/java/net/micode/notes/ui/NoteEditActivity.java
Unescape View File

@ -71,19 +71,25 @@ import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* NoteEditActivity 是用于编辑笔记的活动类。它允许用户创建、修改、删除笔记，设置提醒，以及将笔记发送到桌面或分享给他人。
*/
public class NoteEditActivity extends Activity implements OnClickListener,
NoteSettingChangedListener, OnTextViewChangeListener {
private class HeadViewHolder {
public TextView tvModified;
public ImageView ivAlertIcon;
public TextView tvAlertDate;
public ImageView ibSetBgColor;
/**
* HeadViewHolder 是一个内部类，用于持有头部的视图组件，如修改日期、提醒图标和日期。
*/
private class HeadViewHolder {
public TextView tvModified; // 显示修改日期的 TextView
public ImageView ivAlertIcon; // 显示提醒图标的 ImageView
public TextView tvAlertDate; // 显示提醒日期的 TextView
public ImageView ibSetBgColor; // 设置背景颜色的 ImageView
}
/**
* sBgSelectorBtnsMap 是一个静态的 HashMap，用于将背景颜色选择按钮的 ID 映射到对应的颜色资源 ID。
*/
private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<Integer, Integer>();
static {
sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW);
@ -93,6 +99,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sBgSelectorBtnsMap.put(R.id.iv_bg_white, ResourceParser.WHITE);
}
/**
* sBgSelectorSelectionMap 是一个静态的 HashMap，用于将颜色资源 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 +111,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sBgSelectorSelectionMap.put(ResourceParser.WHITE, R.id.iv_bg_white_select);
}
/**
* sFontSizeBtnsMap 是一个静态的 HashMap，用于将字体大小选择按钮的 ID 映射到对应的字体大小资源 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 +122,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sFontSizeBtnsMap.put(R.id.ll_font_super, ResourceParser.TEXT_SUPER);
}
/**
* sFontSelectorSelectionMap 是一个静态的 HashMap，用于将字体大小资源 ID 映射到对应的选中状态按钮的 ID。
*/
private static final Map<Integer, Integer> sFontSelectorSelectionMap = new HashMap<Integer, Integer>();
static {
sFontSelectorSelectionMap.put(ResourceParser.TEXT_LARGE, R.id.iv_large_select);
@ -118,37 +133,90 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sFontSelectorSelectionMap.put(ResourceParser.TEXT_SUPER, R.id.iv_super_select);
}
/**
* TAG 是一个静态常量，用于日志记录。
*/
private static final String TAG = "NoteEditActivity";
/**
* mNoteHeaderHolder 是 HeadViewHolder 的实例，用于持有头部的视图组件。
*/
private HeadViewHolder mNoteHeaderHolder;
/**
* mHeadViewPanel 是头部的面板视图。
*/
private View mHeadViewPanel;
/**
* mNoteBgColorSelector 是用于选择背景颜色的面板视图。
*/
private View mNoteBgColorSelector;
/**
* mFontSizeSelector 是用于选择字体大小的面板视图。
*/
private View mFontSizeSelector;
/**
* mNoteEditor 是用于编辑笔记内容的 EditText。
*/
private EditText mNoteEditor;
/**
* mNoteEditorPanel 是编辑笔记内容的面板视图。
*/
private View mNoteEditorPanel;
/**
* mWorkingNote 是当前正在编辑的 WorkingNote 实例。
*/
private WorkingNote mWorkingNote;
/**
* mSharedPrefs 是 SharedPreferences 的实例，用于存储用户偏好设置。
*/
private SharedPreferences mSharedPrefs;
/**
* mFontSizeId 是当前选中的字体大小资源 ID。
*/
private int mFontSizeId;
/**
* PREFERENCE_FONT_SIZE 是存储字体大小偏好设置的键。
*/
private static final String PREFERENCE_FONT_SIZE = "pref_font_size";
/**
* SHORTCUT_ICON_TITLE_MAX_LEN 是快捷方式图标标题的最大长度。
*/
private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10;
/**
* TAG_CHECKED 和 TAG_UNCHECKED 是用于表示复选框状态的标签。
*/
public static final String TAG_CHECKED = String.valueOf('\u221A');
public static final String TAG_UNCHECKED = String.valueOf('\u25A1');
/**
* mEditTextList 是包含多个 NoteEditText 的 LinearLayout，用于编辑列表模式的笔记。
*/
private LinearLayout mEditTextList;
/**
* mUserQuery 是用户查询的字符串，用于高亮显示搜索结果。
*/
private String mUserQuery;
/**
* mPattern 是用于匹配用户查询的正则表达式模式。
*/
private Pattern mPattern;
/**
* onCreate 方法是活动的入口点，负责初始化活动状态和资源。
*/
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
@ -162,8 +230,7 @@ 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
* onRestoreInstanceState 方法用于恢复活动状态。如果活动被系统杀死并重新创建，则从保存的状态中恢复。
*/
@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
@ -179,19 +246,18 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
/**
* initActivityState 方法用于根据传入的 Intent 初始化活动状态。如果用户指定了 ACTION_VIEW 但未提供 ID，则跳转到 NotesListActivity。
*
* @param intent 传入的 Intent
* @return 如果初始化成功则返回 true，否则返回 false
*/
private boolean initActivityState(Intent intent) {
/**
* If the user specified the {@link Intent#ACTION_VIEW} but not provided with id,
* then jump to the NotesListActivity
*/
mWorkingNote = null;
if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) {
long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0);
mUserQuery = "";
/**
* Starting from the searched result
*/
if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) {
noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY));
mUserQuery = intent.getStringExtra(SearchManager.USER_QUERY);
@ -215,7 +281,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN
| WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
} else if(TextUtils.equals(Intent.ACTION_INSERT_OR_EDIT, intent.getAction())) {
// New note
// 新笔记
long folderId = intent.getLongExtra(Notes.INTENT_EXTRA_FOLDER_ID, 0);
int widgetId = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_ID,
AppWidgetManager.INVALID_APPWIDGET_ID);
@ -224,7 +290,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
int bgResId = intent.getIntExtra(Notes.INTENT_EXTRA_BACKGROUND_ID,
ResourceParser.getDefaultBgId(this));
// Parse call-record note
// 解析通话记录笔记
String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);
long callDate = intent.getLongExtra(Notes.INTENT_EXTRA_CALL_DATE, 0);
if (callDate != 0 && phoneNumber != null) {
@ -262,12 +328,18 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return true;
}
/**
* onResume 方法在活动恢复时调用，初始化笔记屏幕。
*/
@Override
protected void onResume() {
super.onResume();
initNoteScreen();
}
/**
* initNoteScreen 方法用于初始化笔记屏幕，包括设置文本外观、切换到列表模式或高亮显示查询结果。
*/
private void initNoteScreen() {
mNoteEditor.setTextAppearance(this, TextAppearanceResources
.getTexAppearanceResource(mFontSizeId));
@ -295,6 +367,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
showAlertHeader();
}
/**
* showAlertHeader 方法用于显示提醒头部的信息。如果设置了提醒，则显示提醒日期，否则隐藏。
*/
private void showAlertHeader() {
if (mWorkingNote.hasClockAlert()) {
long time = System.currentTimeMillis();
@ -312,20 +387,21 @@ public class NoteEditActivity extends Activity implements OnClickListener,
};
}
/**
* onNewIntent 方法在活动接收到新的 Intent 时调用，重新初始化活动状态。
*/
@Override
protected void onNewIntent(Intent intent) {
super.onNewIntent(intent);
initActivityState(intent);
}
/**
* onSaveInstanceState 方法用于保存活动状态，以便在活动被系统杀死后恢复。
*/
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
/**
* For new note without note id, we should firstly save it to
* generate a id. If the editing note is not worth saving, there
* is no id which is equivalent to create new note
*/
if (!mWorkingNote.existInDatabase()) {
saveNote();
}
@ -333,6 +409,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
Log.d(TAG, "Save working note id: " + mWorkingNote.getNoteId() + " onSaveInstanceState");
}
/**
* dispatchTouchEvent 方法用于处理触摸事件。当点击区域不在背景颜色选择器或字体大小选择器内时，隐藏选择器。
*/
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
if (mNoteBgColorSelector.getVisibility() == View.VISIBLE
@ -349,6 +428,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return super.dispatchTouchEvent(ev);
}
/**
* inRangeOfView 方法用于判断触摸点是否在指定视图的范围内。
*/
private boolean inRangeOfView(View view, MotionEvent ev) {
int []location = new int[2];
view.getLocationOnScreen(location);
@ -358,11 +440,14 @@ public class NoteEditActivity extends Activity implements OnClickListener,
|| ev.getX() > (x + view.getWidth())
|| ev.getY() < y
|| ev.getY() > (y + view.getHeight())) {
return false;
}
return false;
}
return true;
}
/**
* initResources 方法用于初始化资源，包括头部视图、背景颜色选择器、字体大小选择器等。
*/
private void initResources() {
mHeadViewPanel = findViewById(R.id.note_title);
mNoteHeaderHolder = new HeadViewHolder();
@ -397,6 +482,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list);
}
/**
* onPause 方法在活动暂停时调用，保存笔记数据并清除设置状态。
*/
@Override
protected void onPause() {
super.onPause();
@ -406,6 +494,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
clearSettingState();
}
/**
* updateWidget 方法用于更新小部件。
*/
private void updateWidget() {
Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_2X) {
@ -418,19 +509,22 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] {
mWorkingNote.getWidgetId()
mWorkingNote.getWidgetId()
});
sendBroadcast(intent);
setResult(RESULT_OK, intent);
}
/**
* onClick 方法用于处理点击事件，根据点击的视图 ID 执行不同的操作。
*/
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);
@ -452,6 +546,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
/**
* onBackPressed 方法用于处理返回键事件。如果有选择器可见，则隐藏它们，否则调用父类方法。
*/
@Override
public void onBackPressed() {
if(clearSettingState()) {
@ -462,6 +559,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
super.onBackPressed();
}
/**
* clearSettingState 方法用于清除选择器的状态。如果有选择器可见，则隐藏它们并返回 true，否则返回 false。
*/
private boolean clearSettingState() {
if (mNoteBgColorSelector.getVisibility() == View.VISIBLE) {
mNoteBgColorSelector.setVisibility(View.GONE);
@ -473,6 +573,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return false;
}
/**
* onBackgroundColorChanged 方法在背景颜色改变时被调用，更新背景颜色选择器的状态和背景视图。
*/
public void onBackgroundColorChanged() {
findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
View.VISIBLE);
@ -480,6 +583,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
}
/**
* onPrepareOptionsMenu 方法用于准备菜单选项。如果活动正在结束，则返回 true。
*/
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
if (isFinishing()) {
@ -505,6 +611,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return true;
}
/**
* onOptionsItemSelected 方法用于处理菜单选项点击事件，根据菜单项 ID 执行不同的操作。
*/
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
@ -553,6 +662,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return true;
}
/**
* setReminder 方法用于设置提醒。
*/
private void setReminder() {
DateTimePickerDialog d = new DateTimePickerDialog(this, System.currentTimeMillis());
d.setOnDateTimeSetListener(new OnDateTimeSetListener() {
@ -564,8 +676,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
/**
* Share note to apps that support {@link Intent#ACTION_SEND} action
* and {@text/plain} type
* sendTo 方法用于分享笔记内容到支持 ACTION_SEND 和 text/plain 类型的应用。
*/
private void sendTo(Context context, String info) {
Intent intent = new Intent(Intent.ACTION_SEND);
@ -574,11 +685,14 @@ public class NoteEditActivity extends Activity implements OnClickListener,
context.startActivity(intent);
}
/**
* createNewNote 方法用于创建新笔记。首先保存当前编辑的笔记，然后启动一个新的 NoteEditActivity。
*/
private void createNewNote() {
// Firstly, save current editing notes
// 首先保存当前编辑的笔记
saveNote();
// For safety, start a new NoteEditActivity
// 为了安全，创建一个新的 NoteEditActivity
finish();
Intent intent = new Intent(this, NoteEditActivity.class);
intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
@ -586,6 +700,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
startActivity(intent);
}
/**
* deleteCurrentNote 方法用于删除当前笔记。如果笔记存在于数据库中，则删除它。
*/
private void deleteCurrentNote() {
if (mWorkingNote.existInDatabase()) {
HashSet<Long> ids = new HashSet<Long>();
@ -608,15 +725,17 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mWorkingNote.markDeleted(true);
}
/**
* isSyncMode 方法用于判断当前是否为同步模式。
*/
private boolean isSyncMode() {
return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
}
/**
* onClockAlertChanged 方法在时钟提醒改变时被调用。如果笔记未保存，则先保存笔记，然后设置提醒。
*/
public void onClockAlertChanged(long date, boolean set) {
/**
* User could set clock to an unsaved note, so before setting the
* alert clock, we should save the note first
*/
if (!mWorkingNote.existInDatabase()) {
saveNote();
}
@ -632,20 +751,21 @@ public class NoteEditActivity extends Activity implements OnClickListener,
alarmManager.set(AlarmManager.RTC_WAKEUP, date, pendingIntent);
}
} else {
/**
* There is the condition that user has input nothing (the note is
* not worthy saving), we have no note id, remind the user that he
* should input something
*/
Log.e(TAG, "Clock alert setting error");
showToast(R.string.error_note_empty_for_clock);
}
}
/**
* onWidgetChanged 方法在笔记小部件改变时被调用，更新小部件。
*/
public void onWidgetChanged() {
updateWidget();
}
/**
* onEditTextDelete 方法在删除编辑文本时被调用，处理删除逻辑。
*/
public void onEditTextDelete(int index, String text) {
int childCount = mEditTextList.getChildCount();
if (childCount == 1) {
@ -672,10 +792,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
edit.setSelection(length);
}
/**
* onEditTextEnter 方法在编辑文本进入时被调用，处理进入逻辑。
*/
public void onEditTextEnter(int index, String text) {
/**
* Should not happen, check for debug
*/
if(index > mEditTextList.getChildCount()) {
Log.e(TAG, "Index out of mEditTextList boundrary, should not happen");
}
@ -691,6 +811,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
/**
* switchToListMode 方法用于切换到列表模式，将笔记内容转换为列表。
*/
private void switchToListMode(String text) {
mEditTextList.removeAllViews();
String[] items = text.split("\n");
@ -708,6 +831,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mEditTextList.setVisibility(View.VISIBLE);
}
/**
* getHighlightQueryResult 方法用于高亮显示查询结果。
*/
private Spannable getHighlightQueryResult(String fullText, String userQuery) {
SpannableString spannable = new SpannableString(fullText == null ? "" : fullText);
if (!TextUtils.isEmpty(userQuery)) {
@ -725,6 +851,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return spannable;
}
/**
* getListItem 方法用于获取列表项视图。
*/
private View getListItem(String item, int index) {
View view = LayoutInflater.from(this).inflate(R.layout.note_edit_list_item, null);
final NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
@ -756,6 +885,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return view;
}
/**
* onTextChange 方法在文本改变时被调用，处理文本变化逻辑。
*/
public void onTextChange(int index, boolean hasText) {
if (index >= mEditTextList.getChildCount()) {
Log.e(TAG, "Wrong index, should not happen");
@ -768,13 +900,15 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
/**
* onCheckListModeChanged 方法在列表模式改变时被调用，处理模式变化逻辑。
*/
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 + " ", "").trim());
}
mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));
mEditTextList.setVisibility(View.GONE);
@ -782,6 +916,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
/**
* getWorkingText 方法用于获取当前正在编辑的文本。
*/
private boolean getWorkingText() {
boolean hasChecked = false;
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
@ -805,28 +942,30 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return hasChecked;
}
/**
* saveNote 方法用于保存当前编辑的笔记。如果保存成功，则设置结果为 RESULT_OK。
*
* @return 如果保存成功则返回 true，否则返回 false
*/
private boolean saveNote() {
getWorkingText();
boolean saved = mWorkingNote.saveNote();
if (saved) {
/**
* There are two modes from List view to edit view, open one note,
* create/edit a node. Opening node requires to the original
* position in the list when back from edit view, while creating a
* new node requires to the top of the list. This code
* {@link #RESULT_OK} is used to identify the create/edit state
* 从列表视图切换到编辑视图有两种模式：打开一个笔记，创建/编辑一个笔记。
* 打开笔记时，从编辑视图返回时需要回到列表中的原始位置，而创建新笔记时需要回到列表顶部。
* 此处的 {@link #RESULT_OK} 用于标识创建/编辑状态
*/
setResult(RESULT_OK);
}
return saved;
}
/**
* sendToDesktop 方法用于将当前笔记发送到桌面作为快捷方式。
* 在发送之前，确保当前编辑的笔记存在于数据库中。如果笔记不存在，则先保存它。
*/
private void sendToDesktop() {
/**
* Before send message to home, we should make sure that current
* editing note is exists in databases. So, for new note, firstly
* save it
*/
if (!mWorkingNote.existInDatabase()) {
saveNote();
}
@ -847,15 +986,20 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sendBroadcast(sender);
} else {
/**
* There is the condition that user has input nothing (the note is
* not worthy saving), we have no note id, remind the user that he
* should input something
* 如果用户没有输入任何内容（笔记不值得保存），则没有笔记 ID，提醒用户应该输入一些内容。
*/
Log.e(TAG, "Send to desktop error");
showToast(R.string.error_note_empty_for_send_to_desktop);
}
}
/**
* makeShortcutIconTitle 方法用于生成快捷方式图标的标题。
* 它会移除复选框标签，并截取前 10 个字符作为标题。
*
* @param content 笔记内容
* @return 快捷方式图标标题
*/
private String makeShortcutIconTitle(String content) {
content = content.replace(TAG_CHECKED, "");
content = content.replace(TAG_UNCHECKED, "");
@ -863,11 +1007,22 @@ public class NoteEditActivity extends Activity implements OnClickListener,
SHORTCUT_ICON_TITLE_MAX_LEN) : content;
}
/**
* showToast 方法用于显示短时间的 Toast 消息。
*
* @param resId 字符串资源 ID
*/
private void showToast(int resId) {
showToast(resId, Toast.LENGTH_SHORT);
}
/**
* showToast 方法用于显示指定时间长度的 Toast 消息。
*
* @param resId 字符串资源 ID
* @param duration Toast 显示的时长
*/
private void showToast(int resId, int duration) {
Toast.makeText(this, resId, duration).show();
}
}
}

210
src/Notesmaster/app/src/main/java/net/micode/notes/ui/NotesListAdapter.java
Unescape View File

@ -5,7 +5,7 @@
* 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
* 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,
@ -16,6 +16,7 @@
package net.micode.notes.ui;
// 导入必要的Android类
import android.content.Context;
import android.database.Cursor;
import android.util.Log;
@ -23,6 +24,7 @@ import android.view.View;
import android.view.ViewGroup;
import android.widget.CursorAdapter;
// 导入自定义的类和资源
import net.micode.notes.data.Notes;
import java.util.Collection;
@ -30,155 +32,239 @@ import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
/**
* NotesListAdapter类继承自CursorAdapter，用于在ListView中显示笔记列表。
* 该适配器支持多选模式，并管理选中的笔记项。
*/
public class NotesListAdapter extends CursorAdapter {
private static final String TAG = "NotesListAdapter";
private Context mContext;
private HashMap<Integer, Boolean> mSelectedIndex;
private int mNotesCount;
private boolean mChoiceMode;
private static final String TAG = "NotesListAdapter"; // 日志标签
private Context mContext; // 上下文对象
private HashMap<Integer, Boolean> mSelectedIndex; // 存储选中项的位置和状态
private int mNotesCount; // 笔记总数
private boolean mChoiceMode; // 是否处于多选模式
/**
* 内部静态类，用于存储AppWidget的属性。
*/
public static class AppWidgetAttribute {
public int widgetId;
public int widgetType;
};
public int widgetId; // Widget的ID
public int widgetType; // Widget的类型
}
/**
* 构造函数，初始化NotesListAdapter。
*
* @param context 上下文对象
*/
public NotesListAdapter(Context context) {
super(context, null);
mSelectedIndex = new HashMap<Integer, Boolean>();
mSelectedIndex = new HashMap<Integer, Boolean>(); // 初始化选中项的HashMap
mContext = context;
mNotesCount = 0;
}
/**
* 创建新的视图。
*
* @param context 上下文对象
* @param cursor 游标对象，指向当前数据项
* @param parent 父视图组
* @return 新的视图对象
*/
@Override
public View newView(Context context, Cursor cursor, ViewGroup parent) {
return new NotesListItem(context);
return new NotesListItem(context); // 返回一个新的NotesListItem对象
}
/**
* 绑定数据到现有视图。
*
* @param view 视图对象
* @param context 上下文对象
* @param cursor 游标对象，指向当前数据项
*/
@Override
public void bindView(View view, Context context, Cursor cursor) {
if (view instanceof NotesListItem) {
NoteItemData itemData = new NoteItemData(context, cursor);
((NotesListItem) view).bind(context, itemData, mChoiceMode,
if (view instanceof NotesListItem) { // 检查视图是否为NotesListItem
NoteItemData itemData = new NoteItemData(context, cursor); // 创建NoteItemData对象
((NotesListItem) view).bind(context, itemData, mChoiceMode, // 绑定数据到NotesListItem
isSelectedItem(cursor.getPosition()));
}
}
/**
* 设置指定位置的项为选中或未选中。
*
* @param position 位置
* @param checked 是否选中
*/
public void setCheckedItem(final int position, final boolean checked) {
mSelectedIndex.put(position, checked);
notifyDataSetChanged();
mSelectedIndex.put(position, checked); // 更新选中状态
notifyDataSetChanged(); // 通知数据变化
}
/**
* 判断当前是否处于多选模式。
*
* @return 如果处于多选模式，返回true；否则返回false
*/
public boolean isInChoiceMode() {
return mChoiceMode;
}
/**
* 设置多选模式。
*
* @param mode 如果为true，则进入多选模式；否则退出多选模式
*/
public void setChoiceMode(boolean mode) {
mSelectedIndex.clear();
mSelectedIndex.clear(); // 清除所有选中状态
mChoiceMode = mode;
}
/**
* 全选或全不选。
*
* @param checked 如果为true，则全选；否则全不选
*/
public void selectAll(boolean checked) {
Cursor cursor = getCursor();
for (int i = 0; i < getCount(); i++) {
if (cursor.moveToPosition(i)) {
if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) {
setCheckedItem(i, checked);
Cursor cursor = getCursor(); // 获取当前游标
for (int i = 0; i < getCount(); i++) { // 遍历所有项
if (cursor.moveToPosition(i)) { // 移动到指定位置
if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) { // 如果是普通笔记
setCheckedItem(i, checked); // 设置选中状态
}
}
}
}
/**
* 获取所有选中的项的ID。
*
* @return 包含选中项ID的HashSet
*/
public HashSet<Long> getSelectedItemIds() {
HashSet<Long> itemSet = new HashSet<Long>();
for (Integer position : mSelectedIndex.keySet()) {
if (mSelectedIndex.get(position) == true) {
Long id = getItemId(position);
if (id == Notes.ID_ROOT_FOLDER) {
Log.d(TAG, "Wrong item id, should not happen");
HashSet<Long> itemSet = new HashSet<Long>(); // 初始化HashSet
for (Integer position : mSelectedIndex.keySet()) { // 遍历所有选中项
if (mSelectedIndex.get(position) == true) { // 如果选中
Long id = getItemId(position); // 获取项的ID
if (id == Notes.ID_ROOT_FOLDER) { // 如果ID为根文件夹的ID
Log.d(TAG, "Wrong item id, should not happen"); // 记录日志
} else {
itemSet.add(id);
itemSet.add(id); // 添加到HashSet中
}
}
}
return itemSet;
return itemSet; // 返回HashSet
}
/**
* 获取所有选中的Widget属性。
*
* @return 包含选中Widget属性的HashSet
*/
public HashSet<AppWidgetAttribute> getSelectedWidget() {
HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>();
for (Integer position : mSelectedIndex.keySet()) {
if (mSelectedIndex.get(position) == true) {
Cursor c = (Cursor) getItem(position);
HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>(); // 初始化HashSet
for (Integer position : mSelectedIndex.keySet()) { // 遍历所有选中项
if (mSelectedIndex.get(position) == true) { // 如果选中
Cursor c = (Cursor) getItem(position); // 获取Cursor对象
if (c != null) {
AppWidgetAttribute widget = new AppWidgetAttribute();
NoteItemData item = new NoteItemData(mContext, c);
widget.widgetId = item.getWidgetId();
widget.widgetType = item.getWidgetType();
itemSet.add(widget);
AppWidgetAttribute widget = new AppWidgetAttribute(); // 创建AppWidgetAttribute对象
NoteItemData item = new NoteItemData(mContext, c); // 创建NoteItemData对象
widget.widgetId = item.getWidgetId(); // 设置Widget ID
widget.widgetType = item.getWidgetType(); // 设置Widget类型
itemSet.add(widget); // 添加到HashSet中
/**
* Don't close cursor here, only the adapter could close it
*/
} else {
Log.e(TAG, "Invalid cursor");
Log.e(TAG, "Invalid cursor"); // 记录错误日志
return null;
}
}
}
return itemSet;
return itemSet; // 返回HashSet
}
/**
* 获取选中的项的数量。
*
* @return 选中的项的数量
*/
public int getSelectedCount() {
Collection<Boolean> values = mSelectedIndex.values();
Collection<Boolean> values = mSelectedIndex.values(); // 获取所有选中状态
if (null == values) {
return 0;
}
Iterator<Boolean> iter = values.iterator();
Iterator<Boolean> iter = values.iterator(); // 创建迭代器
int count = 0;
while (iter.hasNext()) {
if (true == iter.next()) {
count++;
while (iter.hasNext()) { // 遍历所有选中状态
if (true == iter.next()) { // 如果选中
count++; // 增加计数
}
}
return count;
}
/**
* 判断是否所有项都被选中。
*
* @return 如果所有项都被选中，返回true；否则返回false
*/
public boolean isAllSelected() {
int checkedCount = getSelectedCount();
return (checkedCount != 0 && checkedCount == mNotesCount);
int checkedCount = getSelectedCount(); // 获取选中项的数量
return (checkedCount != 0 && checkedCount == mNotesCount); // 判断是否所有项都被选中
}
/**
* 判断指定位置的项是否被选中。
*
* @param position 位置
* @return 如果被选中，返回true；否则返回false
*/
public boolean isSelectedItem(final int position) {
if (null == mSelectedIndex.get(position)) {
if (null == mSelectedIndex.get(position)) { // 如果没有选中状态
return false;
}
return mSelectedIndex.get(position);
return mSelectedIndex.get(position); // 返回选中状态
}
/**
* 当内容变化时调用。
*/
@Override
protected void onContentChanged() {
super.onContentChanged();
calcNotesCount();
super.onContentChanged(); // 调用父类方法
calcNotesCount(); // 计算笔记数量
}
/**
* 更改游标。
*
* @param cursor 新的游标对象
*/
@Override
public void changeCursor(Cursor cursor) {
super.changeCursor(cursor);
calcNotesCount();
super.changeCursor(cursor); // 调用父类方法
calcNotesCount(); // 计算笔记数量
}
/**
* 计算笔记数量。
*/
private void calcNotesCount() {
mNotesCount = 0;
for (int i = 0; i < getCount(); i++) {
Cursor c = (Cursor) getItem(i);
mNotesCount = 0; // 重置笔记数量
for (int i = 0; i < getCount(); i++) { // 遍历所有项
Cursor c = (Cursor) getItem(i); // 获取Cursor对象
if (c != null) {
if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) {
mNotesCount++;
if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) { // 如果是普通笔记
mNotesCount++; // 增加计数
}
} else {
Log.e(TAG, "Invalid cursor");
Log.e(TAG, "Invalid cursor"); // 记录错误日志
return;
}
}
}
}
}

85
src/Notesmaster/app/src/main/java/net/micode/notes/ui/NotesListItem.java
Unescape View File

@ -5,7 +5,7 @@
* 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
* 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,
@ -16,6 +16,7 @@
package net.micode.notes.ui;
// 导入必要的Android类
import android.content.Context;
import android.text.format.DateUtils;
import android.view.View;
@ -24,23 +25,35 @@ import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
// 导入自定义的类和资源
import net.micode.notes.R;
import net.micode.notes.data.Notes;
import net.micode.notes.tool.DataUtils;
import net.micode.notes.tool.ResourceParser.NoteItemBgResources;
/**
* NotesListItem类继承自LinearLayout，用于在笔记列表中显示单个笔记项。
* 每个笔记项包括标题、时间、图标等，并根据不同的状态展示不同的背景和图标。
*/
public class NotesListItem extends LinearLayout {
private ImageView mAlert;
private TextView mTitle;
private TextView mTime;
private TextView mCallName;
private NoteItemData mItemData;
private CheckBox mCheckBox;
// UI组件
private ImageView mAlert; // 提示图标（如时钟图标）
private TextView mTitle; // 笔记标题
private TextView mTime; // 笔记修改时间
private TextView mCallName; // 通话记录名称
private NoteItemData mItemData; // 笔记项数据
private CheckBox mCheckBox; // 多选模式下的复选框
/**
* 构造函数，初始化NotesListItem。
*
* @param context 上下文对象
*/
public NotesListItem(Context context) {
super(context);
// 加载布局文件note_item.xml并将其作为子视图添加到当前LinearLayout中
inflate(context, R.layout.note_item, this);
// 初始化UI组件
mAlert = (ImageView) findViewById(R.id.iv_alert_icon);
mTitle = (TextView) findViewById(R.id.tv_title);
mTime = (TextView) findViewById(R.id.tv_time);
@ -48,44 +61,71 @@ public class NotesListItem extends LinearLayout {
mCheckBox = (CheckBox) findViewById(android.R.id.checkbox);
}
/**
* 绑定数据到当前笔记项视图。
*
* @param context 上下文对象
* @param data 笔记项数据
* @param choiceMode 是否处于多选模式
* @param checked 是否被选中
*/
public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
// 如果处于多选模式且笔记类型为普通笔记，则显示复选框并设置选中状态
if (choiceMode && data.getType() == Notes.TYPE_NOTE) {
mCheckBox.setVisibility(View.VISIBLE);
mCheckBox.setChecked(checked);
} else {
// 否则隐藏复选框
mCheckBox.setVisibility(View.GONE);
}
// 绑定数据到成员变量
mItemData = data;
// 如果笔记ID为通话记录文件夹的ID，则显示通话记录文件夹视图
if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
mCallName.setVisibility(View.GONE);
mAlert.setVisibility(View.VISIBLE);
// 设置标题样式和文本为通话记录文件夹名称及文件数量
mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
mTitle.setText(context.getString(R.string.call_record_folder_name)
+ context.getString(R.string.format_folder_files_count, data.getNotesCount()));
// 设置提示图标为通话记录图标
mAlert.setImageResource(R.drawable.call_record);
} else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
}
// 如果笔记的父ID为通话记录文件夹的ID，则显示通话记录子项视图
else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
mCallName.setVisibility(View.VISIBLE);
// 设置通话记录名称
mCallName.setText(data.getCallName());
// 设置标题样式和文本为笔记片段
mTitle.setTextAppearance(context,R.style.TextAppearanceSecondaryItem);
mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
// 如果笔记有提醒，则显示时钟图标
if (data.hasAlert()) {
mAlert.setImageResource(R.drawable.clock);
mAlert.setVisibility(View.VISIBLE);
} else {
mAlert.setVisibility(View.GONE);
}
} else {
}
// 其他类型的笔记
else {
mCallName.setVisibility(View.GONE);
// 设置标题样式
mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
// 如果笔记类型为文件夹，则显示文件夹名称及文件数量
if (data.getType() == Notes.TYPE_FOLDER) {
mTitle.setText(data.getSnippet()
+ context.getString(R.string.format_folder_files_count,
data.getNotesCount()));
data.getNotesCount()));
mAlert.setVisibility(View.GONE);
} else {
}
// 如果是普通笔记，则显示笔记片段
else {
mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
// 如果笔记有提醒，则显示时钟图标
if (data.hasAlert()) {
mAlert.setImageResource(R.drawable.clock);
mAlert.setVisibility(View.VISIBLE);
@ -94,14 +134,24 @@ public class NotesListItem extends LinearLayout {
}
}
}
// 设置笔记的修改时间
mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));
// 设置背景
setBackground(data);
}
/**
* 设置笔记项的背景。
*
* @param data 笔记项数据
*/
private void setBackground(NoteItemData data) {
// 获取背景颜色ID
int id = data.getBgColorId();
// 如果笔记类型为普通笔记
if (data.getType() == Notes.TYPE_NOTE) {
// 根据笔记的位置设置不同的背景资源
if (data.isSingle() || data.isOneFollowingFolder()) {
setBackgroundResource(NoteItemBgResources.getNoteBgSingleRes(id));
} else if (data.isLast()) {
@ -111,12 +161,19 @@ public class NotesListItem extends LinearLayout {
} else {
setBackgroundResource(NoteItemBgResources.getNoteBgNormalRes(id));
}
} else {
}
// 如果笔记类型为文件夹，则设置文件夹背景
else {
setBackgroundResource(NoteItemBgResources.getFolderBgRes());
}
}
/**
* 获取当前笔记项的数据。
*
* @return 笔记项数据
*/
public NoteItemData getItemData() {
return mItemData;
}
}
}
Write Preview
Loading…
Cancel
Save