ps249eph7
/
MiNotes
1
0
Fork 0
Code Issues Pull Requests 3 Packages Projects Releases Wiki Activity

final

Browse Source
main
LQS 10 months ago
parent caaeabbeff
commit dd3315cf72
16 changed files with 1497 additions and 211 deletions
Show Stats Download Patch File Download Diff File

BIN
doc/阅读维护开源软件的汇报.pptx
View File

Binary file not shown.

154
src/xiaomi/Notes-master/src/net/micode/notes/ui/AlarmAlertActivity.java
Unescape View File

@ -39,36 +39,80 @@ import net.micode.notes.tool.DataUtils;
import java.io.IOException;
/**
*
* @ProjectName:
* @Package: net.micode.notes.ui
* @ClassName: AlarmAlertActivity
* @Description: AlarmAlertActivity类的作用是作为一个提醒警报的活动界面。
* 当便签的提醒功能触发时，系统会启动AlarmAlertActivity，显示提醒的详细内容和相关操作选项，
* 让用户可以对提醒进行处理，比如查看提醒内容、延迟提醒或者标记为已完成等操作。
* 这个类主要负责提醒相关的界面展示和用户交互逻辑。
* @Author: xumingyang
* @CreateDate: 2023-12-24 10:33
* @UpdateUser: 更新者：
* @UpdateDate: 2023-12-24 10:33
* @UpdateRemark: 更新说明：
* @Version: 1.0
*/
public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener {
private long mNoteId;
private String mSnippet;
private long mNoteId;//文本在数据库存储中的ID号
private String mSnippet;//闹钟提示时出现的文本片段
private static final int SNIPPET_PREW_MAX_LEN = 60;
MediaPlayer mPlayer;
/**
* @method onCreate
* @description :
* 初始化提醒界面的布局和逻辑。
* 设置窗口特性，请求不显示标题栏，并在锁屏状态下显示提醒界面。
* 获取传入该活动的Intent对象，并尝试从中获取便签的ID。
* 使用获取到的便签ID获取便签的摘要信息，并进行相应的处理。
* 创建一个MediaPlayer对象，用于播放提醒的声音。
* 检查该便签是否在便签数据库中可见。
* 如果便签可见，则显示操作对话框，并播放提醒音效。
* 如果便签不可见，则关闭该界面。
* @date: 2023-12-24 10:41
* @author: xumingyang
* @param
* @return
*/
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//Bundle类型的数据与Map类型的数据相似，都是以key-value的形式存储数据的
//onsaveInstanceState方法是用来保存Activity的状态的
//能从onCreate的参数savedInsanceState中获得状态数
requestWindowFeature(Window.FEATURE_NO_TITLE);
//界面显示——无标题
final Window win = getWindow();
win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
if (!isScreenOn()) {
win.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
//保持窗体点亮
| WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
//将窗体点亮
| WindowManager.LayoutParams.FLAG_ALLOW_LOCK_WHILE_SCREEN_ON
//允许窗体点亮时锁屏
| WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR);
}
}//在手机锁屏后如果到了闹钟提示时间，点亮屏幕
Intent intent = getIntent();
try {
mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1));
mSnippet = DataUtils.getSnippetById(this.getContentResolver(), mNoteId);
//根据ID从数据库中获取标签的内容；
//getContentResolver（）是实现数据共享，实例存储
mSnippet = mSnippet.length() > SNIPPET_PREW_MAX_LEN ? mSnippet.substring(0,
SNIPPET_PREW_MAX_LEN) + getResources().getString(R.string.notelist_string_info)
: mSnippet;
//判断标签片段是否达到符合长度
} catch (IllegalArgumentException e) {
e.printStackTrace();
return;
@ -77,20 +121,44 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
mPlayer = new MediaPlayer();
if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) {
showActionDialog();
//弹出对话框
playAlarmSound();
//闹钟提示音激发
} else {
finish();
//完成闹钟动作
}
}
/**
* @method isScreenOn
* @description 判断屏幕是否锁屏，调用系统函数判断
* @date: 2023-12-24 10:45
* @author: xumingyang
* @param
* @return bool 类型
*/
private boolean isScreenOn() {
PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
return pm.isScreenOn();
}
/**
* @method playAlarmSound
* @description:
* 该段代码的作用是根据用户的设置，播放系统默认的闹钟铃声。
* 并且可以支持在静音模式下播放闹钟铃声
* @date: 2023-12-24 10:47
* @author: xumingyang
* @param
* @return
*/
private void playAlarmSound() {
Uri url = RingtoneManager.getActualDefaultRingtoneUri(this, RingtoneManager.TYPE_ALARM);
//调用系统的铃声管理URI，得到闹钟提示音
int silentModeStreams = Settings.System.getInt(getContentResolver(),
Settings.System.MODE_RINGER_STREAMS_AFFECTED, 0);
@ -101,12 +169,20 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
}
try {
mPlayer.setDataSource(this, url);
//方法：setDataSource(Context context, Uri uri)
//解释：无返回值，设置多媒体数据来源【根据 Uri】
mPlayer.prepare();
//准备同步
mPlayer.setLooping(true);
//设置是否循环播放
mPlayer.start();
//开始播放
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
//e.printStackTrace()函数功能是抛出异常， 还将显示出更深的调用信息
//System.out.println(e)，这个方法打印出异常，并且输出在哪里出现的异常
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
@ -119,39 +195,105 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
}
}
/**
* @method showActionDialog
* @description
* 创建一个AlertDialog.Builder对象，并设置对话框的标题为应用的名称（R.string.app_name）。
* 将对话框的消息内容设置为mSnippet变量所存储的文本信息。
* 设置对话框的积极按钮（Positive Button）的文本为“确定”（R.string.notealert_ok），并将当前类作为按钮的点击监听器。
* 如果屏幕处于开启状态（通过isScreenOn()方法判断），则设置对话框的消极按钮（Negative Button）的文本为“进入”（R.string.notealert_enter），并将当前类作为按钮的点击监听器。
* 调用dialog.show().setOnDismissListener(this)方法显示对话框，并设置当前类作为对话框消失时的监听器。
* @date: 2023-12-24 10:51
* @author: xumingyang
* @param
* @return
*/
private void showActionDialog() {
AlertDialog.Builder dialog = new AlertDialog.Builder(this);
/*
* AlertDialog的构造方法全部是Protected的
* 所以不能直接通过new一个AlertDialog来创建出一个AlertDialog。
* 要创建一个AlertDialog，就要用到AlertDialog.Builder中的create()方法
* 如这里的dialog就是新建了一个AlertDialog
*/
dialog.setTitle(R.string.app_name);
//为对话框设置标题
dialog.setMessage(mSnippet);
//为对话框设置内容
dialog.setPositiveButton(R.string.notealert_ok, this);
//给对话框添加"Yes"按钮
if (isScreenOn()) {
dialog.setNegativeButton(R.string.notealert_enter, this);
}
}//对话框添加"No"按钮
dialog.show().setOnDismissListener(this);
}
/**
* @method onClick
* @description :
* 根据点击的按钮类型执行相应的操作，
* 如果点击的是对话框中的消极按钮，则打开一个新的便签编辑界面，并将当前笔记的id传递给该Activity。
* @date: 2023-12-24 10:55
* @author: xumingyang
* @param
* @return
*/
public void onClick(DialogInterface dialog, int which) {
switch (which) {
//用which来选择click后下一步的操作
case DialogInterface.BUTTON_NEGATIVE:
//这是取消操作
Intent intent = new Intent(this, NoteEditActivity.class);
//实现两个类间的数据传输
intent.setAction(Intent.ACTION_VIEW);
//设置动作属性
intent.putExtra(Intent.EXTRA_UID, mNoteId);
//实现key-value对
//EXTRA_UID为key；mNoteId为键
startActivity(intent);
//开始动作
break;
default:
//这是确定操作'
break;
}
}
/**
* @method onDismiss
* @description 在闹钟提醒对话框消失时，停止闹钟铃声并结束当前Activity的生命周期。
* @date: 2023-12-24 10:57
* @author: xumingyang
* @param
* @return
*/
public void onDismiss(DialogInterface dialog) {
stopAlarmSound();
//停止闹钟声音
finish();
//完成该动作
}
/**
* @method stopAlarmSound
* @description 停止正在播放的闹钟声音，并释放相关的资源。
* @date: 2023-12-24 10:58
* @author: xumingyang
* @param
* @return
*/
private void stopAlarmSound() {
if (mPlayer != null) {
mPlayer.stop();
//停止播放
mPlayer.release();
//释放MediaPlayer对象
mPlayer = null;
}
}

43
src/xiaomi/Notes-master/src/net/micode/notes/ui/AlarmInitReceiver.java
Unescape View File

@ -28,25 +28,59 @@ import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns;
/**
*
* @ProjectName:
* @Package: net.micode.notes.ui
* @ClassName: AlarmInitReceiver
* @Description: AlarmInitReceiver类是小米便签应用中的一个广播接收器（BroadcastReceiver）
* 其作用是在设备启动时接收系统发送的广播，并执行一些初始化操作
* @Author: xumingyang
* @CreateDate: 2023-12-24 11:11
* @UpdateUser: 更新者：
* @UpdateDate: 2023-12-24 11:11
* @UpdateRemark: 更新说明：
* @Version: 1.0
*/
public class AlarmInitReceiver extends BroadcastReceiver {
private static final String [] PROJECTION = new String [] {
NoteColumns.ID,
NoteColumns.ALERTED_DATE
};
//对数据库的操作，调用标签ID和闹钟时间
private static final int COLUMN_ID = 0;
private static final int COLUMN_ALERTED_DATE = 1;
/**
* @method onReceive
* @description 是在设备启动后，通过查询数据库找到需要提醒的标签，并设置对应的闹钟。
* 这样，在设备启动完成后，小米便签应用可以重新加载标签的提醒功能，确保按时提醒用户。
* @date: 2023-12-24 11:26
* @author: xumingyang
* @param *Cursor在这里的作用是通过查找数据库中的标签内容，找到和当前系统时间相等的标签
* 从游标中获取提醒日期（alertDate）
* 创建一个新的Intent对象（sender），并指定目标广播接收器（AlarmReceiver）
* 创建PendingIntent：使用getBroadcast()方法创建一个用于启动广播的PendingIntent对象（pendingIntent）
* @return 查询结果将以Cursor对象（c）返回
*/
@Override
public void onReceive(Context context, Intent intent) {
long currentDate = System.currentTimeMillis();
//System.currentTimeMillis()产生一个当前的毫秒
//这个毫秒其实就是自1970年1月1日0时起的毫秒数
Cursor c = context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
PROJECTION,
NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE,
new String[] { String.valueOf(currentDate) },
//将long变量currentDate转化为字符串
null);
//Cursor在这里的作用是通过查找数据库中的标签内容，找到和当前系统时间相等的标签
if (c != null) {
if (c.moveToFirst()) {
do {
@ -62,4 +96,9 @@ public class AlarmInitReceiver extends BroadcastReceiver {
c.close();
}
}
/*
* 然而通过网上查找资料发现，对于闹钟机制的启动，通常需要上面的几个步骤
* 如新建Intent、PendingIntent以及AlarmManager等
* 这里就是根据数据库里的闹钟时间创建一个闹钟机制
*/
}

57
src/xiaomi/Notes-master/src/net/micode/notes/ui/AlarmReceiver .java
Unescape View File

@ -0,0 +1,57 @@
/*
* 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.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
/**
*
* @ProjectName:
* @Package: net.micode.notes.ui
* @ClassName: AlarmReceiver
* @Description: 通过AlarmReceiver类，可以实现小米便签的提醒功能，
* 让用户按时收到提醒并进行相应的操作。
* @Author: xumingyang
* @CreateDate: 2023-12-24 12:46
* @UpdateUser: 更新者：
* @UpdateDate: 2023-12-24 12:46
* @UpdateRemark: 更新说明：
* @Version: 1.0
*/
/**
* @method
* @description 段代码是用于在接收到广播时启动AlarmAlertActivity活动，并在新的任务栈中展示该活动
* @param *Context context和Intent intent，其中context表示上下文环境，intent表示接收到的广播意图。
* @return
*/
public class AlarmReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
//重写了onReceive()方法，该方法在接收到广播时会被调用
intent.setClass(context, AlarmAlertActivity.class);
//启动AlarmAlertActivity
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
//activity要存在于activity的栈中，而非activity的途径启动activity时必然不存在一个activity的栈
//所以要新起一个栈装入启动的activity
context.startActivity(intent);
}
}

27
src/xiaomi/Notes-master/src/net/micode/notes/ui/AlarmReceiver.java
Unescape View File

@ -20,11 +20,38 @@ import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
/**
*
* @ProjectName:
* @Package: net.micode.notes.ui
* @ClassName: AlarmReceiver
* @Description: 通过AlarmReceiver类，可以实现小米便签的提醒功能，
* 让用户按时收到提醒并进行相应的操作。
* @Author: xumingyang
* @CreateDate: 2023-12-24 12:46
* @UpdateUser: 更新者：
* @UpdateDate: 2023-12-24 12:46
* @UpdateRemark: 更新说明：
* @Version: 1.0
*/
/**
* @method
* @description 段代码是用于在接收到广播时启动AlarmAlertActivity活动，并在新的任务栈中展示该活动
* @param *Context context和Intent intent，其中context表示上下文环境，intent表示接收到的广播意图。
* @return
*/
public class AlarmReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
//重写了onReceive()方法，该方法在接收到广播时会被调用
intent.setClass(context, AlarmAlertActivity.class);
//启动AlarmAlertActivity
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
//activity要存在于activity的栈中，而非activity的途径启动activity时必然不存在一个activity的栈
//所以要新起一个栈装入启动的activity
context.startActivity(intent);
}
}

103
src/xiaomi/Notes-master/src/net/micode/notes/ui/DateTimePicker.java
Unescape View File

@ -28,8 +28,25 @@ import android.view.View;
import android.widget.FrameLayout;
import android.widget.NumberPicker;
public class DateTimePicker extends FrameLayout {
/**
*
* @ProjectName:
* @Package: net.micode.notes.ui
* @ClassName: DateTimePicker
* @Description: 用于选择日期和时间的自定义视图，包括年、月、日、时、分等选择器。
* 它使用了NumberPicker控件来实现日期和时间的选择功能，并提供了一些回调接口以便在日期和时间改变时进行通知。
* @Author: xumingyang
* @CreateDate: 2023-12-24 12:58
* @UpdateUser: 更新者：
* @UpdateDate: 2023-12-24 12:58
* @UpdateRemark: 更新说明：
* @Version: 1.0
*/
public class DateTimePicker extends FrameLayout {
//FrameLayout是布局模板之一
//所有的子元素全部在屏幕的右上方
private static final boolean DEFAULT_ENABLE_STATE = true;
private static final int HOURS_IN_HALF_DAY = 12;
@ -45,12 +62,17 @@ public class DateTimePicker extends FrameLayout {
private static final int MINUT_SPINNER_MAX_VAL = 59;
private static final int AMPM_SPINNER_MIN_VAL = 0;
private static final int AMPM_SPINNER_MAX_VAL = 1;
//初始化控件
private final NumberPicker mDateSpinner;
private final NumberPicker mHourSpinner;
private final NumberPicker mMinuteSpinner;
private final NumberPicker mAmPmSpinner;
//NumberPicker是数字选择器
//这里定义的四个变量全部是在设置闹钟时需要选择的变量（如日期、时、分、上午或者下午）
private Calendar mDate;
//定义了Calendar类型的变量mDate，用于操作时间
private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];
@ -72,8 +94,23 @@ public class DateTimePicker extends FrameLayout {
onDateTimeChanged();
}
};
//OnValueChangeListener，这是时间改变监听器，这里主要是对日期的监听
//将现在日期的值传递给mDate；updateDateControl是同步操作
private NumberPicker.OnValueChangeListener mOnHourChangedListener = new NumberPicker.OnValueChangeListener() {
//这里是对 小时（Hour） 的监听
/**
* @method onValueChange
* @description 这段代码是一个回调函数，用于监听NumberPicker的数值改变事件。
* 当用户改变了时间选择器中的小时数时，就会触发这个回调函数。
* 在函数中，首先判断当前选择器是否为24小时制，如果不是则需要处理上下午的切换和跨天的情况。
* @date: 2023-12-24 13:03
* @author: xumingyang
* @param *声明一个Calendar的变量cal，便于后续的操作
* @return isdateChanged bool类型 判断是否需要对时间进行调整
*/
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
boolean isDateChanged = false;
@ -83,29 +120,33 @@ public class DateTimePicker extends FrameLayout {
cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, 1);
isDateChanged = true;
//这里是对于12小时制时，晚上11点和12点交替时对日期的更改
} else if (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, -1);
isDateChanged = true;
}
}//这里是对于12小时制时，晚上11点和12点交替时对日期的更改
if (oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY ||
oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
mIsAm = !mIsAm;
updateAmPmControl();
}
}//这里是对于12小时制时，中午11点和12点交替时对AM和PM的更改
} else {
if (oldVal == HOURS_IN_ALL_DAY - 1 && newVal == 0) {
cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, 1);
isDateChanged = true;
//这里是对于24小时制时，晚上11点和12点交替时对日期的更改
} else if (oldVal == 0 && newVal == HOURS_IN_ALL_DAY - 1) {
cal.setTimeInMillis(mDate.getTimeInMillis());
cal.add(Calendar.DAY_OF_YEAR, -1);
isDateChanged = true;
}
}
}//这里是对于12小时制时，凌晨11点和12点交替时对日期的更改
int newHour = mHourSpinner.getValue() % HOURS_IN_HALF_DAY + (mIsAm ? 0 : HOURS_IN_HALF_DAY);
//通过数字选择器对newHour的赋值
mDate.set(Calendar.HOUR_OF_DAY, newHour);
//通过set函数将新的Hour值传给mDate
onDateTimeChanged();
if (isDateChanged) {
setCurrentYear(cal.get(Calendar.YEAR));
@ -116,16 +157,27 @@ public class DateTimePicker extends FrameLayout {
};
private NumberPicker.OnValueChangeListener mOnMinuteChangedListener = new NumberPicker.OnValueChangeListener() {
/**
* @method onValueChange
* @description 用于监控 NumberPicker（数字选择器）的数值变化事件。
* 具体来说，这个监听器是用于监听分钟选择器的数值变化。
* @param *三个参数：picker（当前的 NumberPicker 对象）、oldVal（旧值）和 newVal（新值）
*/
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
int minValue = mMinuteSpinner.getMinValue();
int maxValue = mMinuteSpinner.getMaxValue();
int offset = 0;
//设置offset，作为小时改变的一个记录数据
if (oldVal == maxValue && newVal == minValue) {
offset += 1;
} else if (oldVal == minValue && newVal == maxValue) {
offset -= 1;
}
//如果原值为59，新值为0，则offset加1
//如果原值为0，新值为59，则offset减1
if (offset != 0) {
mDate.add(Calendar.HOUR_OF_DAY, offset);
mHourSpinner.setValue(getCurrentHour());
@ -145,9 +197,16 @@ public class DateTimePicker extends FrameLayout {
};
private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() {
/**
* @method onValueChange
* @description 实现了一个监听器，用于监测用户对NumberPicker控件数值的改变，
* 并根据改变的数值来更新界面上的上午/下午控件
*/
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
mIsAm = !mIsAm;
//对AM和PM的监听
if (mIsAm) {
mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY);
} else {
@ -165,19 +224,24 @@ public class DateTimePicker extends FrameLayout {
public DateTimePicker(Context context) {
this(context, System.currentTimeMillis());
}
}//通过对数据库的访问，获取当前的系统时间
public DateTimePicker(Context context, long date) {
this(context, date, DateFormat.is24HourFormat(context));
}
}//上面函数的得到的是一个天文数字（1970至今的秒数），需要DateFormat将其变得有意义
public DateTimePicker(Context context, long date, boolean is24HourView) {
super(context);
//获取系统时间
mDate = Calendar.getInstance();
mInitialising = true;
mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY;
inflate(context, R.layout.datetime_picker, this);
/*
* 如果当前Activity里用到别的layout，比如对话框layout
* 还要设置这个layout上的其他组件的内容，就必须用inflate()方法先将对话框的layout找出来
* 然后再用findViewById()找到它上面的其它组件
*/
mDateSpinner = (NumberPicker) findViewById(R.id.date);
mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL);
mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL);
@ -214,17 +278,30 @@ public class DateTimePicker extends FrameLayout {
mInitialising = false;
}
/**
* @method setEnabled
* @description 这个函数用于统一设置控件及其相关子控件的可用状态，并且会根据传入的参数值进行相应的操作
* @param *布尔值 enabled，用于指定控件是否可用。
* @return 将 mIsEnabled 的值更新为传入的 enabled，以保持状态同步
*/
@Override
public void setEnabled(boolean enabled) {
if (mIsEnabled == enabled) {
return;
}
/*
* 如果传入的参数 enabled 与当前的控件可用状态 mIsEnabled 相同，则无需进行任何操作，直接返回。
* 这样可以避免重复设置控件的可用状态。
*/
super.setEnabled(enabled);
mDateSpinner.setEnabled(enabled);
mMinuteSpinner.setEnabled(enabled);
mHourSpinner.setEnabled(enabled);
mAmPmSpinner.setEnabled(enabled);
mIsEnabled = enabled;
//将 mIsEnabled 的值更新为传入的 enabled，以保持状态同步
}
@Override
@ -251,7 +328,7 @@ public class DateTimePicker extends FrameLayout {
cal.setTimeInMillis(date);
setCurrentDate(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH),
cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE));
}
}//实现函数功能——设置当前的时间，参数是date
/**
* Set the current date
@ -269,13 +346,15 @@ public class DateTimePicker extends FrameLayout {
setCurrentDay(dayOfMonth);
setCurrentHour(hourOfDay);
setCurrentMinute(minute);
}
}//实现函数功能——设置当前的时间，参数是各详细的变量
/**
* Get current year
*
* @return The current year
*/
//下面是得到year、month、day等值
public int getCurrentYear() {
return mDate.get(Calendar.YEAR);
}
@ -446,7 +525,7 @@ public class DateTimePicker extends FrameLayout {
mDateSpinner.setDisplayedValues(mDateDisplayValues);
mDateSpinner.setValue(DAYS_IN_ALL_WEEK / 2);
mDateSpinner.invalidate();
}
}// 对于星期几的算法
private void updateAmPmControl() {
if (mIs24HourView) {
@ -456,7 +535,7 @@ public class DateTimePicker extends FrameLayout {
mAmPmSpinner.setValue(index);
mAmPmSpinner.setVisibility(View.VISIBLE);
}
}
}// 对于上下午操作的算法
private void updateHourControl() {
if (mIs24HourView) {
@ -466,7 +545,7 @@ public class DateTimePicker extends FrameLayout {
mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW);
mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW);
}
}
}// 对与小时的算法
/**
* Set the callback that indicates the 'Set' button has been pressed.

36
src/xiaomi/Notes-master/src/net/micode/notes/ui/DateTimePickerDialog.java
Unescape View File

@ -29,21 +29,43 @@ import android.content.DialogInterface.OnClickListener;
import android.text.format.DateFormat;
import android.text.format.DateUtils;
/**
*
* @ProjectName: DateTimePickerDialog
* @Package: net.micode.notes.ui
* @ClassName: DateTimePickerDialog
* @Description: DateTimePickerDialog 的作用是提供一个日期和时间选择器的对话框，用于让用户选择日期和时间。
* 该对话框通常用于设置便签的提醒时间或截止时间等功能，用户可以通过滚动选择器来选择特定的日期和时间。
* DateTimePickerDialog 提供了直观且方便的界面，使用户能够方便地选择所需的日期和时间。
* @Author: xumingyang
* @CreateDate: 2023-12-24 13:52
* @UpdateUser: 更新者：
* @UpdateDate: 2023-12-24 13:52
* @UpdateRemark: 更新说明：
* @Version: 1.0
*/
public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
private Calendar mDate = Calendar.getInstance();
//创建一个Calendar类型的变量 mDate，方便时间的操作
private boolean mIs24HourView;
private OnDateTimeSetListener mOnDateTimeSetListener;
//声明一个时间日期滚动选择控件 mOnDateTimeSetListener
private DateTimePicker mDateTimePicker;
//DateTimePicker控件，控件一般用于让用户可以从日期列表中选择单个值。
//运行时，单击控件边上的下拉箭头，会显示为两个部分：一个下拉列表，一个用于选择日期的
public interface OnDateTimeSetListener {
void OnDateTimeSet(AlertDialog dialog, long date);
}
public DateTimePickerDialog(Context context, long date) {
//对该界面对话框的实例化
super(context);
//对数据库的操作
mDateTimePicker = new DateTimePicker(context);
setView(mDateTimePicker);
//添加一个子视图
mDateTimePicker.setOnDateTimeChangedListener(new OnDateTimeChangedListener() {
public void onDateTimeChanged(DateTimePicker view, int year, int month,
int dayOfMonth, int hourOfDay, int minute) {
@ -52,15 +74,21 @@ public class DateTimePickerDialog extends AlertDialog implements OnClickListener
mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
mDate.set(Calendar.MINUTE, minute);
//将视图中的各选项设置为系统当前时间
updateTitle(mDate.getTimeInMillis());
}
});
mDate.setTimeInMillis(date);
//得到系统时间
mDate.set(Calendar.SECOND, 0);
//将秒数设置为0 对日期时间进行标准化处理
mDateTimePicker.setCurrentDate(mDate.getTimeInMillis());
//将日期时间选择器设置为当前设置的日期时间
setButton(context.getString(R.string.datetime_dialog_ok), this);
setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener)null);
//设置按钮
set24HourView(DateFormat.is24HourFormat(this.getContext()));
//时间标准化打印
updateTitle(mDate.getTimeInMillis());
}
@ -70,7 +98,7 @@ public class DateTimePickerDialog extends AlertDialog implements OnClickListener
public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) {
mOnDateTimeSetListener = callBack;
}
}//将时间日期滚动选择控件实例化
private void updateTitle(long date) {
int flag =
@ -79,12 +107,12 @@ public class DateTimePickerDialog extends AlertDialog implements OnClickListener
DateUtils.FORMAT_SHOW_TIME;
flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_24HOUR;
setTitle(DateUtils.formatDateTime(this.getContext(), date, flag));
}
}//android开发中常见日期管理工具类（API）——DateUtils：按照上下午显示时间
public void onClick(DialogInterface arg0, int arg1) {
if (mOnDateTimeSetListener != null) {
mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis());
}
}
}//第一个参数arg0是接收到点击事件的对话框
//第二个参数arg1是该对话框上的按钮
}

32
src/xiaomi/Notes-master/src/net/micode/notes/ui/DropdownMenu.java
Unescape View File

@ -27,17 +27,43 @@ import android.widget.PopupMenu.OnMenuItemClickListener;
import net.micode.notes.R;
/**
*
* @ProjectName:
* @Package: net.micode.notes.ui
* @ClassName: DropdownMenu
* @Description: DropdownMenu是一个下拉菜单，它的作用是提供一种选择多个选项的方式。
* 当用户点击DropdownMenu时，会弹出一个下拉列表，列出了多个选项供用户选择。
* 1.笔记分类：用户可以使用DropdownMenu来选择笔记的分类，比如工作、生活、学习等，从而方便地将笔记进行分类管理。
* 2.笔记排序：用户可以使用DropdownMenu来选择笔记的排序方式，比如按时间、按标题等进行排序，以满足不同排序需求。
* 3.标签管理：用户可以使用DropdownMenu来选择或添加标签，以对笔记进行更细粒度的分类和标记。
* @Author: xumingyang
* @CreateDate: 2023-12-24 13:57
* @UpdateUser: 更新者：
* @UpdateDate: 2023-12-24 13:57
* @UpdateRemark: 更新说明：
* @Version: 1.0
*/
public class DropdownMenu {
private Button mButton;
private PopupMenu mPopupMenu;
//声明一个下拉菜单
private Menu mMenu;
public DropdownMenu(Context context, Button button, int menuId) {
mButton = button;
mButton.setBackgroundResource(R.drawable.dropdown_icon);
//设置这个view的背景
mPopupMenu = new PopupMenu(context, mButton);
mMenu = mPopupMenu.getMenu();
mPopupMenu.getMenuInflater().inflate(menuId, mMenu);
//MenuInflater是用来实例化Menu目录下的Menu布局文件
//根据ID来确认menu的内容选项
mButton.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
mPopupMenu.show();
@ -49,13 +75,13 @@ public class DropdownMenu {
if (mPopupMenu != null) {
mPopupMenu.setOnMenuItemClickListener(listener);
}
}
}//设置菜单的监听
public MenuItem findItem(int id) {
return mMenu.findItem(id);
}
}//对于菜单选项的初始化，根据索引搜索菜单需要的选项
public void setTitle(CharSequence title) {
mButton.setText(title);
}
}
}//布局文件，设置标题

37
src/xiaomi/Notes-master/src/net/micode/notes/ui/FoldersListAdapter.java
Unescape View File

@ -29,25 +29,53 @@ import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns;
/**
*
* @ProjectName:
* @Package: net.micode.notes.ui
* @ClassName: FoldersListAdapter
* @Description: FoldersListAdapter 的作用是作为文件夹列表的适配器，用于管理和显示文件夹列表的数据和视图。
* CursorAdapter是Cursor和ListView的接口
* FoldersListAdapter继承了CursorAdapter的类
* 主要作用是便签数据库和用户的交互
* 这里就是用folder（文件夹）的形式展现给用户
* @Author: xumingyang
* @CreateDate: 2023-12-24 14:05
* @UpdateDate: 2023-12-24 14:05
* @Version: 1.0
*/
public class FoldersListAdapter extends CursorAdapter {
public static final String [] PROJECTION = {
NoteColumns.ID,
NoteColumns.SNIPPET
};
};//调用数据库中便签的ID和片段
public static final int ID_COLUMN = 0;
public static final int NAME_COLUMN = 1;
/**
* @method FoldersListAdapter
* @description 用于初始化FoldersListAdapter类的实例。这个类可能是用于管理文件夹列表显示的适配器，其中包含了数据库操作相关的功能
* @param context 参数通常是指当前的上下文
* c 参数可能是一个用于查询数据库的Cursor对象。
*/
public FoldersListAdapter(Context context, Cursor c) {
super(context, c);
// TODO Auto-generated constructor stub
}
}//数据库操作
/**
* @method newView
* @description 用于创建新的视图用于显示文件夹列表项。
* @return 将该视图返回给适配器使用
*/
@Override
public View newView(Context context, Cursor cursor, ViewGroup parent) {
return new FolderListItem(context);
}
//将各个布局文件绑定起来
@Override
public void bindView(View view, Context context, Cursor cursor) {
if (view instanceof FolderListItem) {
@ -57,6 +85,7 @@ public class FoldersListAdapter extends CursorAdapter {
}
}
//根据数据库中标签的ID得到标签的各项内容
public String getFolderName(Context context, int position) {
Cursor cursor = (Cursor) getItem(position);
return (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
@ -67,8 +96,8 @@ public class FoldersListAdapter extends CursorAdapter {
private TextView mName;
public FolderListItem(Context context) {
super(context);
inflate(context, R.layout.folder_list_item, this);
super(context);//操作数据库
inflate(context, R.layout.folder_list_item, this);//根据布局文件的名字等信息将其找出来
mName = (TextView) findViewById(R.id.tv_folder_name);
}

401
src/xiaomi/Notes-master/src/net/micode/notes/ui/NoteEditActivity.java
Unescape View File

@ -16,6 +16,7 @@
package net.micode.notes.ui;
import android.app.Activity;
import android.app.AlarmManager;
import android.app.AlertDialog;
@ -102,9 +103,40 @@ import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;
/**
*
* @ProjectName:
* @Package: net.micode.notes.ui
* @ClassName: NoteEditActivity
* @Description: 编辑小米便签应用中的便签内容。它向用户提供了一个界面，允许用户输入、编辑和保存文本信息。
* 具体来说，用户可以在该界面中添加或编辑标题、标签、内容、图片等信息，并将这些信息保存到小米便签数据库中。
* 还提供了一些常用的编辑功能，如加粗、倾斜、下划线、字体调整、颜色设置、插入图片等，使得用户可以更加方便地对便签内容进行编辑和美化。
* @Author: xumingyang
* @CreateDate: 2024-01-03 8:44
* @UpdateUser: 更新者：
* @UpdateDate: 2024-01-03 8:44
* @UpdateRemark: 更新说明：
* @Version: 1.0
*/
import android.speech.tts.TextToSpeech.OnInitListener;
/**
*
* @ProjectName:
* @Package: net.micode.notes.ui
* @ClassName: NoteEditActivity
* @Description: 编辑小米便签应用中的便签内容。它向用户提供了一个界面，允许用户输入、编辑和保存文本信息。
* 具体来说，用户可以在该界面中添加或编辑标题、标签、内容、图片等信息，并将这些信息保存到小米便签数据库中。
* 还提供了一些常用的编辑功能，如加粗、倾斜、下划线、字体调整、颜色设置、插入图片等，使得用户可以更加方便地对便签内容进行编辑和美化。
* @Author: xumingyang
* @CreateDate: 2024-01-03 8:44
* @UpdateDate: 2024-01-03 8:44
* @Version: 1.0
*/
public class NoteEditActivity extends Activity implements OnClickListener,
NoteSettingChangedListener, OnTextViewChangeListener {
//该类主要是针对标签的编辑
//继承了系统内部许多和监听有关的类
public static void setmChanged(Stack mChanged) {
NoteEditActivity.mChanged = mChanged;
}
@ -112,6 +144,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
private class HeadViewHolder {
public TextView tvModified;
public EditText editText1;//新增
public TextView textView;//新增
public ImageView ivAlertIcon;
public TextView tvAlertDate;
@ -119,6 +153,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
public ImageView ibSetBgColor;
}
//使用Map实现数据存储
private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<Integer, Integer>();
static {
sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW);
@ -126,6 +161,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sBgSelectorBtnsMap.put(R.id.iv_bg_blue, ResourceParser.BLUE);
sBgSelectorBtnsMap.put(R.id.iv_bg_green, ResourceParser.GREEN);
sBgSelectorBtnsMap.put(R.id.iv_bg_white, ResourceParser.WHITE);
//put函数是将指定值和指定键相连
}
private static final Map<Integer, Integer> sBgSelectorSelectionMap = new HashMap<Integer, Integer>();
@ -135,6 +171,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sBgSelectorSelectionMap.put(ResourceParser.BLUE, R.id.iv_bg_blue_select);
sBgSelectorSelectionMap.put(ResourceParser.GREEN, R.id.iv_bg_green_select);
sBgSelectorSelectionMap.put(ResourceParser.WHITE, R.id.iv_bg_white_select);
//put函数是将指定值和指定键相连
}
private static final Map<Integer, Integer> sFontSizeBtnsMap = new HashMap<Integer, Integer>();
@ -157,22 +194,24 @@ public class NoteEditActivity extends Activity implements OnClickListener,
private HeadViewHolder mNoteHeaderHolder;
private View mHeadViewPanel;
private View mHeadViewPanel;//私有化一个界面操作mHeadViewPanel，对表头的操作
private View mNoteBgColorSelector;
private View mNoteBgColorSelector;//私有化一个界面操作mNoteBgColorSelector，对背景颜色的操作
private View mFontSizeSelector;
private View mFontSizeSelector;//私有化一个界面操作mFontSizeSelector，对标签字体的操作
private EditText mNoteEditor;
private EditText mNoteEditor;//声明编辑控件，对文本操作
private EditText editText;
private TextView textView;
private View mNoteEditorPanel;
private View mNoteEditorPanel;//私有化一个界面操作mNoteEditorPanel，文本编辑的控制板
private WorkingNote mWorkingNote;
private WorkingNote mWorkingNote;//对模板WorkingNote的初始化
private SharedPreferences mSharedPrefs;
private int mFontSizeId;
//私有化SharedPreferences的数据存储方式
//它的本质是基于XML文件存储key-value键值对数据
private int mFontSizeId;//用于操作字体的大小
private static final String PREFERENCE_FONT_SIZE = "pref_font_size";
@ -181,7 +220,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
public static final String TAG_CHECKED = String.valueOf('\u221A');
public static final String TAG_UNCHECKED = String.valueOf('\u25A1');
private LinearLayout mEditTextList;
private LinearLayout mEditTextList;//线性布局
private String mUserQuery;
private Pattern mPattern;
@ -359,9 +398,11 @@ public class NoteEditActivity extends Activity implements OnClickListener,
Editable editable = noteEditText.getText();
String noteText = editable.toString();
int length = editable.length();
//对于每个字符，从当前位置开始，向后遍历文本，直到找到与图片标记匹配的子字符串。
for (int i = 0; i < length; i++) {
for (int j = i; j < length; j++) {
String img_fragment = noteText.substring(i, j + 1);
//检查其长度是否大于15，且以"[local]"开头，以"[/local]"结尾
if (img_fragment.length() > 15 && img_fragment.endsWith("[/local]") && img_fragment.startsWith("[local]")) {
int limit = 7;
int len = img_fragment.length() - 15;
@ -369,17 +410,23 @@ public class NoteEditActivity extends Activity implements OnClickListener,
Bitmap bitmap = null;
Log.d(TAG, "图片的路径是：" + path);
try {
//BitmapFactory.decodeFile(path)是Android中用于从指定路径加载图片文件并返回一个Bitmap对象的方法
bitmap = BitmapFactory.decodeFile(path);
} catch (Exception e) {
e.printStackTrace();
}
//如果解码成功（即bitmap不为null），则创建一个新的ImageSpan对象，并将其插入到原始文本中，替换原来的图片标记
if (bitmap != null) {
Log.d(TAG, "图片不为null");
//创建一个SpannableString对象，将字符串ss作为参数传递给构造函数。
//SpannableString是一个可编辑的字符串，可以设置文本样式（如颜色、大小等）。
ImageSpan imageSpan = new ImageSpan(NoteEditActivity.this, bitmap);
String ss = "[local]" + path + "[/local]";
SpannableString spannableString = new SpannableString(ss);
//将ImageSpan对象应用于spannableString，从索引0开始，到字符串长度结束。这样可以将图片显示在指定的文本范围内
spannableString.setSpan(imageSpan, 0, ss.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
Log.d(TAG, "Create spannable string success!");
//获取noteEditText的可编辑文本内容，并将其赋值给变量edit_text
Editable edit_text = noteEditText.getEditableText();
edit_text.delete(i, i + len + 15);
edit_text.insert(i, spannableString);
@ -390,6 +437,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
//处理返回的数据，并将图片的路径也写入到数据库
//当用户在相机应用中选择了一张图片后，该图片的URI会被传递给NoteEditActivity，然后通过这个方法进行处理。
@RequiresApi(api = Build.VERSION_CODES.KITKAT)
protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
super.onActivityResult(requestCode, resultCode, intent);
@ -399,12 +447,11 @@ public class NoteEditActivity extends Activity implements OnClickListener,
Uri originalUri = intent.getData();
Bitmap bitmap = null;
try {
bitmap = BitmapFactory.decodeStream(resolver.openInputStream(originalUri));//2.解码图片
bitmap = BitmapFactory.decodeStream(resolver.openInputStream(originalUri));//解码图片
} catch (FileNotFoundException e) {
Log.d(TAG, "onActivityResult: get file_exception");
e.printStackTrace();
}
if (bitmap != null) {
Log.d(TAG, "onActivityResult: bitmap is not null");
ImageSpan imageSpan = new ImageSpan(NoteEditActivity.this, bitmap);
@ -467,12 +514,15 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
return null;
}
//用于从给定的URI中获取数据列
//Android的ContentResolver类来执行查询操作，通过url来定位和获取上下文数据
public String getDataColumn(Context context, Uri uri, String selection, String[] selectionArgs) {
Cursor cursor = null;
final String column = "_data";
final String[] projection = {column};
try {
//调用context.getContentResolver().query()方法，传入URI、投影、选择条件、选择参数和排序方式，执行查询操作并将结果存储在cursor中
cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs, null);
if (cursor != null && cursor.moveToFirst()) {
final int column_index = cursor.getColumnIndexOrThrow(column);
@ -491,17 +541,27 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return "com.android.providers.media.documents".equals(uri.getAuthority());
}
/**
* @method onCreate
* @description 描述一下方法的作用方法的主要作用是初始化Activity的状态、资源和界面，并对便签内容进行处理和计数。
*/
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
this.setContentView(R.layout.note_edit);
this.setContentView(R.layout.note_edit); //调用setContentView方法设置当前Activity显示的布局为note_edit.xml文件。
setmChanged(new Stack<>() );
/*
* 判断savedInstanceState是否为空，并调用initActivityState方法初始化Activity的状态。
* initActivityState方法会根据传入的Intent信息，判断当前是新建一个便签还是编辑一个已有的便签。
*/
if (savedInstanceState == null && !initActivityState(getIntent())) {
finish();
return;
}
initResources();
count();
initResources();//调用initResources方法初始化Activity中的资源，如绑定控件等。
count();//新增文档计数功能
final ImageButton add_img_btn = (ImageButton) findViewById(R.id.add_img_btn);
add_img_btn.setOnClickListener(new View.OnClickListener() {
@ -523,21 +583,37 @@ public class NoteEditActivity extends Activity implements OnClickListener,
*/
//用于在Activity被系统销毁后恢复其状态
@Override
/**
* @method onRestoreInstanceState
* @description 该方法的主要作用是在Activity恢复状态时，根据保存的数据重新初始化Activity的状态，
* 以保证在Activity被销毁后重新创建时能够正确恢复之前的状态。
*/
protected void onRestoreInstanceState(Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState);
//将保存在savedInstanceState中的Intent.EXTRA_UID的值作为Long类型的额外数据传递给新的Intent对象。
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));
/*
* 调用initActivityState方法，将新的Intent传递进去进行初始化Activity的状态。
* 如果initActivityState返回false，说明初始化失败，直接销毁Activity并返回。
*/
if (!initActivityState(intent)) {
finish();
return;
}
Log.d(TAG, "Restoring from killed activity");
}
}//为防止内存不足时程序的终止，在这里有一个保存现场的函数
}
//该方法主要用于初始化Activity的状态，根据传入的Intent的不同动作（action）执行不同的操作。
private boolean initActivityState(Intent intent) {
/**
* @method initActivityState
* @description 作用是初始化NoteEditActivity的状态。
* @param
* @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
@ -547,31 +623,34 @@ public class NoteEditActivity extends Activity implements OnClickListener,
if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) {
long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0);
mUserQuery = "";
//如果用户实例化标签时，系统并未给出标签ID
/**
* Starting from the searched result
*/
//根据键值查找ID
if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) {
noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY));
mUserQuery = intent.getStringExtra(SearchManager.USER_QUERY);
}
//DataUtils.visibleInNoteDatabase(getContentResolver(), noteId, Notes.TYPE_NOTE) 是一个方法调用
// 用于检查给定的 noteId 是否存在于笔记数据库中
//如果ID在数据库中未找到
if (!DataUtils.visibleInNoteDatabase(getContentResolver(), noteId, Notes.TYPE_NOTE)) {
Intent jump = new Intent(this, NotesListActivity.class);
startActivity(jump);
startActivity(jump);//程序将跳转到上面声明的intent——jump
showToast(R.string.error_note_not_exist);
finish();
return false;
} else {
} else {//ID在数据库中找到
//如果指定的笔记 ID 存在于笔记数据库中，则调用 WorkingNote.load() 方法，根据指定的笔记 ID 加载笔记对象，并将结果赋值给 mWorkingNote
mWorkingNote = WorkingNote.load(this, noteId);
if (mWorkingNote == null) {
Log.e(TAG, "load note failed with note id" + noteId);
Log.e(TAG, "load note failed with note id" + noteId); //打印出红色的错误信息
finish();
return false;
}
}
//setSoftInputMode——软键盘输入模式
getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN
| WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
@ -579,6 +658,11 @@ public class NoteEditActivity extends Activity implements OnClickListener,
//需要创建或编辑一个笔记
// New note
//从 Intent 中获取一些额外的信息，如文件夹 ID、小部件 ID、小部件类型和背景资源 ID。这些信息用于确定新笔记的位置和外观。
/*
* intent.getAction()
* 大多用于broadcast发送广播时给机制（intent）设置一个action，就是一个字符串
* 用户可以通过receive（接受）intent，通过 getAction得到的字符串，来决定做什么
*/
long folderId = intent.getLongExtra(Notes.INTENT_EXTRA_FOLDER_ID, 0);
int widgetId = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_ID,
AppWidgetManager.INVALID_APPWIDGET_ID);
@ -625,20 +709,37 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return true;
}
/**
* @method onResume
* @description 在Activity恢复时重新初始化便签的显示
*/
@Override
protected void onResume() {
super.onResume();
initNoteScreen();
initNoteScreen();//然后调用initNoteScreen方法，该方法会根据mWorkingNote的内容初始化便签的各个UI控件，例如标题栏、编辑区域、图片等。
}
//用于初始化笔记屏幕
/**
* @method initNoteScreen
* @description 根据mWorkingNote的内容重新初始化便签的UI，包括文本样式、编辑区域、背景、修改时间等
*/
private void initNoteScreen() {
mNoteEditor.setTextAppearance(this, TextAppearanceResources
.getTexAppearanceResource(mFontSizeId));
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
/*
* 如果当前便签是“清单”模式，则调用switchToListMode方法将编辑区域切换到“清单”模式，
* 并将mWorkingNote中的内容填充到编辑区域。
*/
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {//首先根据mFontSizeId设置mNoteEditor的文本样式。
switchToListMode(mWorkingNote.getContent());
} else {
mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));
}
/*
* 如果当前便签不是“清单”模式，则将mWorkingNote中的内容填充到编辑区域
* 并调用getHighlightQueryResult方法将搜索关键字高亮显示。
*/
else {
mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));//将所有背景选择器控件隐藏，然后根据mWorkingNote的标题背景和便签背景设置标题栏和编辑区域的背景。
mNoteEditor.setSelection(mNoteEditor.getText().length());
}
for (Integer id : sBgSelectorSelectionMap.keySet()) {
@ -660,12 +761,17 @@ public class NoteEditActivity extends Activity implements OnClickListener,
convertToImage();
}
/**
* @method showAlertHeader
* @description 根据mWorkingNote的提醒设置来显示提醒相关的UI，包括提醒日期文本和提醒图标。
* 如果有设置提醒，则根据当前时间判断是否已过期，并显示相应的文本。如果没有设置提醒，则隐藏相关UI。
*/
private void showAlertHeader() {
if (mWorkingNote.hasClockAlert()) {
if (mWorkingNote.hasClockAlert()) {//首先判断mWorkingNote是否有设置提醒（hasClockAlert）。如果有设置提醒，则执行以下步骤
long time = System.currentTimeMillis();
if (time > mWorkingNote.getAlertDate()) {
mNoteHeaderHolder.tvAlertDate.setText(R.string.note_alert_expired);
} else {
mNoteHeaderHolder.tvAlertDate.setText(R.string.note_alert_expired);//判断当前时间是否超过了提醒时间（mWorkingNote.getAlertDate）。如果超过了提醒时间，则将提醒日期文本（tvAlertDate）
} else {//如果没有超过提醒时间，则将提醒日期文本设置为相对时间，即距离提醒时间还有多久（使用DateUtils.getRelativeTimeSpanString方法）。
mNoteHeaderHolder.tvAlertDate.setText(DateUtils.getRelativeTimeSpanString(
mWorkingNote.getAlertDate(), time, DateUtils.MINUTE_IN_MILLIS));
}
@ -678,11 +784,18 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
@Override
//在Activity已经存在于任务栈中时，再次启动该Activity时的回调方法，可以在其中处理相关的逻辑操作
protected void onNewIntent(Intent intent) {
super.onNewIntent(intent);
initActivityState(intent);
}
/**
* @method onSaveInstanceState
* @description 在Activity即将被销毁时的回调方法，用于保存当前Activity的状态，
* 以便在Activity被恢复时能够正确地加载之前的状态。
* @return void
*/
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
@ -692,28 +805,33 @@ public class NoteEditActivity extends Activity implements OnClickListener,
* is no id which is equivalent to create new note
*/
if (!mWorkingNote.existInDatabase()) {
saveNote();
saveNote();//在创建一个新的标签时，先在数据库中匹配
//如果不存在，那么先在数据库中存储
}
outState.putLong(Intent.EXTRA_UID, mWorkingNote.getNoteId());
Log.d(TAG, "Save working note id: " + mWorkingNote.getNoteId() + " onSaveInstanceState");
}
@Override
//MotionEvent是对屏幕触控的传递机制
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;
}
}//字体大小选择器在屏幕上可见
return super.dispatchTouchEvent(ev);
}
//对屏幕触控的坐标进行操作
private boolean inRangeOfView(View view, MotionEvent ev) {
int []location = new int[2];
view.getLocationOnScreen(location);
@ -723,7 +841,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
|| ev.getX() > (x + view.getWidth())
|| ev.getY() < y
|| ev.getY() > (y + view.getHeight())) {
return false;
return false;//如果触控的位置超出了给定的范围，返回false
}
return true;
}
@ -751,12 +869,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
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);
mFontSizeId = mSharedPrefs.getInt(PREFERENCE_FONT_SIZE, ResourceParser.BG_DEFAULT_FONT_SIZE);
/**
@ -910,15 +1028,17 @@ public class NoteEditActivity extends Activity implements OnClickListener,
alertDialog2.show();
}
//在Activity即将失去焦点并进入后台时的回调方法，用于执行一些与保存数据、清除状态等相关的操作。
@Override
protected void onPause() {
super.onPause();
if(saveNote()) {
Log.d(TAG, "Note data was saved with length:" + mWorkingNote.getContent().length());
}
clearSettingState();
clearSettingState();//调用clearSettingState()方法来清除一些设置状态。具体的逻辑需要根据实际需求来实现，可能包括清除临时数据、重置一些标志位等。
}
//和桌面小工具的同步
private void updateWidget() {
Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_2X) {
@ -934,6 +1054,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mWorkingNote.getWidgetId()
});
//将当前Note笔记的Widget ID放入Intent的Extra参数中。注意，这里只更新当前Note笔记所绑定的Widget，因此只需要传入一个Widget ID。
sendBroadcast(intent);
setResult(RESULT_OK, intent);
}
@ -965,10 +1086,19 @@ public class NoteEditActivity extends Activity implements OnClickListener,
} else {
mNoteEditor.setTextAppearance(this, TextAppearanceResources.getTexAppearanceResource(mFontSizeId));
}
/*
* 如果点击的ID在sFontSizeBtnsMap中存在（即点击的是字体大小选择项的按钮），则将当前字体大小的选择项设置为不可见，
* 将字体大小ID更新为对应的值，并将新的字体大小选择项设置为可见。
* 同时，根据Note笔记的模式（是否为检查列表模式）进行相应的处理：
* 如果是检查列表模式，则切换到列表模式并获取最新的Note内容；
* 否则，仅更新文本编辑器的字体样式。
*/
mFontSizeSelector.setVisibility(View.GONE);
}
}
//这段代码重写了Activity的返回按钮操作，
// 在返回操作中处理了设置状态的清除和Note笔记的保存。
@Override
public void onBackPressed() {
if(clearSettingState()) {
@ -979,7 +1109,14 @@ public class NoteEditActivity extends Activity implements OnClickListener,
super.onBackPressed();
}
/**
* @method clearSettingState
* @description 这个方法的作用是在用户按下返回按钮时，检查当前是否处于设置状态（例如正在选择背景颜色或字体大小），
* 如果是，则清除设置状态并返回true，否则返回false。
* @return true表示成功清除了设置状态 返回false表示当前没有处于设置状态。
*/
private boolean clearSettingState() {
//首先检查背景颜色选择器（mNoteBgColorSelector）和字体大小选择器（mFontSizeSelector）的可见性
if (mNoteBgColorSelector.getVisibility() == View.VISIBLE) {
mNoteBgColorSelector.setVisibility(View.GONE);
return true;
@ -990,24 +1127,34 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return false;
}
/**
* @method onBackgroundColorChanged
* @description 在背景颜色发生变化时，根据新的背景颜色ID更新选中状态的选择项的可见性，
* 并将新的背景颜色资源应用到相关的视图上，以实现界面的背景颜色变更
*/
public void onBackgroundColorChanged() {
findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
View.VISIBLE);
mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());
mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
//获取当前Note笔记的背景颜色资源ID，并将该资源作为背景设置给mNoteEditorPanel和mHeadViewPanel，实现对编辑区域和标题区域的背景颜色的更新。
}
/**
* @method onPrepareOptionsMenu
* @description 根据当前Note笔记的状态和属性，动态加载选项菜单的内容，并更新其中的部分选项的名称和可见性。
*/
//该方法的主要作用是根据当前的工作笔记（mWorkingNote）的属性来准备和更新菜单项。
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
if (isFinishing()) {
return true;
}
}//判断当前Activity是否正在关闭，如果是，则直接返回true，不做任何处理。
clearSettingState();
menu.clear();
menu.clear(); //调用clearSettingState()方法清除当前的设置状态，并使用menu.clear()方法清空选项菜单中的所有选项。
//工作笔记的文件夹ID
if (mWorkingNote.getFolderId() == Notes.ID_CALL_RECORD_FOLDER) {
getMenuInflater().inflate(R.menu.call_note_edit, menu);
getMenuInflater().inflate(R.menu.call_note_edit, menu);// MenuInflater是用来实例化Menu目录下的Menu布局文件的
} else {
getMenuInflater().inflate(R.menu.note_edit, menu);
}
@ -1016,6 +1163,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
} else {
menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_list_mode);
}
//如果当前Note笔记已经有闹钟提醒，则隐藏“添加提醒”选项，否则隐藏“删除提醒”选项。
if (mWorkingNote.hasClockAlert()) {
menu.findItem(R.id.menu_alert).setVisible(false);
} else {
@ -1024,12 +1172,22 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return true;
}
/**
* @method onOptionsItemSelected
* @description 用于处理选项菜单中的各个选项被点击时的事件响应。
* @return boolean 返回true表示已经处理了该选项的点击事件。
*/
@Override
public boolean onOptionsItemSelected(MenuItem item) {
int itemId = item.getItemId();
if (itemId == R.id.menu_new_note) {
int itemId = item.getItemId();//在这个方法中，首先获取被点击的选项的ID，然后根据ID的不同执行相应的操作。
if (itemId == R.id.menu_new_note) {//如果被点击的选项是“新建笔记”，则调用createNewNote()方法创建一个新的笔记。
createNewNote();
} else if (itemId == R.id.menu_delete) {
}
/*
* 如果被点击的选项是“删除”，则弹出一个警告对话框，询问用户是否确认删除当前笔记。
* 如果用户确认删除，则调用deleteCurrentNote()方法删除当前笔记，并关闭当前Activity。
*/
else if (itemId == R.id.menu_delete) {
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle(getString(R.string.alert_title_delete));
builder.setIcon(android.R.drawable.ic_dialog_alert);
@ -1043,20 +1201,33 @@ public class NoteEditActivity extends Activity implements OnClickListener,
});
builder.setNegativeButton(android.R.string.cancel, null);
builder.show();
} else if (itemId == R.id.menu_font_size) {
}
//如果被点击的选项是“修改字体大小”，则显示字体大小选择器，以供用户选择字体大小。
else if (itemId == R.id.menu_font_size) {
mFontSizeSelector.setVisibility (View.VISIBLE);
findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
} else if (itemId == R.id.menu_list_mode) {
}
//如果被点击的选项是“切换列表模式”，则切换当前笔记的检查列表模式状态。
else if (itemId == R.id.menu_list_mode) {
mWorkingNote.setCheckListMode(mWorkingNote.getCheckListMode() == 0 ?
TextNote.MODE_CHECK_LIST : 0);
} else if (itemId == R.id.menu_share) {
}
//如果被点击的选项是“分享”，则获取当前笔记的内容并将其发送到其他应用程序。
else if (itemId == R.id.menu_share) {
getWorkingText();
sendTo(this, mWorkingNote.getContent());
} else if (itemId == R.id.menu_send_to_desktop) {
}
//如果被点击的选项是“发送到桌面”，则将当前笔记发送到桌面。
else if (itemId == R.id.menu_send_to_desktop) {
sendToDesktop();
} else if (itemId == R.id.menu_alert) {
}
//如果被点击的选项是“添加提醒”，则设置当前笔记的提醒时间
else if (itemId == R.id.menu_alert) {
setReminder();
} else if (itemId == R.id.menu_delete_remind) {
}
//如果被点击的选项是“删除提醒”，则清除当前笔记的提醒时间
else if (itemId == R.id.menu_delete_remind) {
mWorkingNote.setAlertDate(0, false);
}else if(itemId == R.id.menu_revoke) {
doRevoke();
@ -1075,42 +1246,51 @@ public class NoteEditActivity extends Activity implements OnClickListener,
private void setReminder() {
DateTimePickerDialog d = new DateTimePickerDialog(this, System.currentTimeMillis());
d.setOnDateTimeSetListener(new OnDateTimeSetListener() {
//首先创建一个DateTimePickerDialog对象，并将当前系统时间作为初始时间传入。
// 然后，为该对话框设置一个日期时间选择器监听器。
public void OnDateTimeSet(AlertDialog dialog, long date) {
mWorkingNote.setAlertDate(date , true);
}
});
d.show();
d.show();//最后，显示日期时间选择器对话框。
}
/**
* Share note to apps that support {@link Intent#ACTION_SEND} action
* and {@text/plain} type
*/
/**
* @method sendTo
* @description 用于在给定的Context上下文环境中，利用系统默认的分享功能将特定的文本信息发送给其他应用程序。
*/
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);
Intent intent = new Intent(Intent.ACTION_SEND);//在方法内部，首先创建一个新的Intent对象，并将其动作设置为Intent.ACTION_SEND，表示发送内容。
intent.putExtra(Intent.EXTRA_TEXT, info);//接着，通过putExtra方法将要分享的文本信息info放入Intent中，使用Intent.EXTRA_TEXT作为键。
intent.setType("text/plain"); //然后，使用setType方法将要分享的内容的MIME类型设置为"text/plain"，表示纯文本类型。
context.startActivity(intent);//最后，通过context.startActivity(intent)启动该Intent，将文本信息发送给其他应用程序进行处理。
}
private void count(){
private void count(){//用于实时更新字符数的文本视图
mNoteEditor.addTextChangedListener(new TextWatcher() {
int currentlength = 0;
@Override
public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {
textView.setText("字符数："+currentlength);
}
}//在beforeTextChanged()方法中，通过获取当前文本的长度并更新textView的文本来显示当前字符数。
@Override
public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {
currentlength = editText.getText().length();
}
}//在onTextChanged()方法中，通过获取编辑框的文本长度并将其赋值给currentLength变量，以便在afterTextChanged()方法中使用。
@Override
public void afterTextChanged(Editable editable) {
textView.setText("字符数：" + currentlength);
}
}//在afterTextChanged()方法中，再次更新textView的文本以显示最新的字符数
});
}
private void createNewNote() {
@ -1130,6 +1310,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
startActivity(intent);
}
//删除便签
private void deleteCurrentNote() {
//假如当前运行的便签内存有数据
if (mWorkingNote.existInDatabase()) {
@ -1159,6 +1340,11 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mWorkingNote.markDeleted(true);
}
/**
* @method isSyncMode
* @description 用于判断是否处于同步模式。
* @return 如果此名称的长度大于0，则说明处于同步模式，返回true；否则返回false。
*/
private boolean isSyncMode() {
return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
}
@ -1168,10 +1354,11 @@ public class NoteEditActivity extends Activity implements OnClickListener,
* User could set clock to an unsaved note, so before setting the
* alert clock, we should save the note first
*/
if (!mWorkingNote.existInDatabase()) {
if (!mWorkingNote.existInDatabase()) {//首先检查当前工作的便签是否存在于数据库中，如果不存在，则调用saveNote()方法保存便签。
saveNote();
}
if (mWorkingNote.getNoteId() > 0) {
if (mWorkingNote.getNoteId() > 0) {//若当前便签的ID大于0，则创建一个用于触发闹钟的Intent，并设置相应的PendingIntent。
// 然后根据参数set来决定是取消闹钟还是设置新的闹钟时间。
Intent intent = new Intent(this, AlarmReceiver.class);
intent.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mWorkingNote.getNoteId()));
PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, intent, 0);
@ -1193,10 +1380,15 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
//更新小部件的显示内容。具体的更新逻辑可能包括重新加载数据、刷新UI等操作，以确保小部件展示的内容和状态是最新的。
public void onWidgetChanged() {
updateWidget();
}
/**
* @method onEditTextDelete
* @description 用于处理删除文本编辑框的操作。
*/
public void onEditTextDelete(int index, String text) {
int childCount = mEditTextList.getChildCount();
if (childCount == 1) {
@ -1223,17 +1415,21 @@ public class NoteEditActivity extends Activity implements OnClickListener,
edit.setSelection(length);
}
/**
* @method onEditTextEnter
* @description 用于处理插入文本编辑框的操作。
*/
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");
Log.e(TAG, "Index out of mEditTextList boundrary, should not happen");//在方法中，首先检查传入的索引位置是否超出了mEditTextList的子视图数量。如果超出了范围，会记录错误日志。
}
View view = getListItem(text, index);
mEditTextList.addView(view, index);
NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
View view = getListItem(text, index);//根据传入的文本和索引位置创建一个新的视图view。
mEditTextList.addView(view, index);//将创建的视图插入到mEditTextList中的指定索引位置。
NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);//获取新插入的文本编辑框，并将其请求获取焦点。同时，将光标定位在文本编辑框的开头位置。
edit.requestFocus();
edit.setSelection(0);
for (int i = index + 1; i < mEditTextList.getChildCount(); i++) {
@ -1242,6 +1438,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
//用于切换到列表模式
private void switchToListMode(String text) {
mEditTextList.removeAllViews();
String[] items = text.split("\n");
@ -1259,6 +1456,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mEditTextList.setVisibility(View.VISIBLE);
}
//用于将匹配到的查询结果进行高亮处理。
private Spannable getHighlightQueryResult(String fullText, String userQuery) {
SpannableString spannable = new SpannableString(fullText == null ? "" : fullText);
if (!TextUtils.isEmpty(userQuery)) {
@ -1276,11 +1474,15 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return spannable;
}
/**
* @method getListItem
* @description 用于根据给定的文本项item和索引index创建一个列表项的视图。
*/
private View getListItem(String item, int index) {
View view = LayoutInflater.from(this).inflate(R.layout.note_edit_list_item, null);
View view = LayoutInflater.from(this).inflate(R.layout.note_edit_list_item, null);//首先使用LayoutInflater.from(this).inflate(R.layout.note_edit_list_item, null)从布局文件note_edit_list_item中获取一个视图view。
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));
edit.setTextAppearance(this, TextAppearanceResources.getTexAppearanceResource(mFontSizeId));//从view中获取一个NoteEditText编辑框对象edit，并设置其文本外观为当前字体大小mFontSizeId对应的样式。
CheckBox cb = ((CheckBox) view.findViewById(R.id.cb_edit_item)); //从view中获取一个CheckBox对象cb，并设置其选中状态改变的监听器，以便在状态改变时修改编辑框的文本外观。
cb.setOnCheckedChangeListener(new OnCheckedChangeListener() {
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
if (isChecked) {
@ -1291,6 +1493,11 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
});
/*
根据文本项的前缀标记判断当前列表项是否被选中。如果是，则将复选框设置为选中状态，并将编辑框的文本外观设置为带有删除线的样式；
否则，将复选框设置为未选中状态，并将编辑框的文本外观设置为普通样式。
同时，去除前缀标记并去除两端的空格。
*/
if (item.startsWith(TAG_CHECKED)) {
cb.setChecked(true);
edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
@ -1303,38 +1510,61 @@ public class NoteEditActivity extends Activity implements OnClickListener,
edit.setOnTextViewChangeListener(this);
edit.setIndex(index);
edit.setText(getHighlightQueryResult(item, mUserQuery));
return view;
edit.setText(getHighlightQueryResult(item, mUserQuery));//设置编辑框的值为经过高亮处理的文本项item，并设置编辑框的索引值为传入的索引index，
return view;// 最后将edit对象添加到视图view中并返回该视图。
}
/**
* @method onCheckListModeChanged
* @description 用于监听编辑框中文本的改变，并根据是否有文本来控制复选框的可见性。
*/
public void onTextChange(int index, boolean hasText) {
if (index >= mEditTextList.getChildCount()) {
Log.e(TAG, "Wrong index, should not happen");
return;
//判断传入的索引值index是否超出了编辑框列表中子视图的数量范围。
//如果超出，则打印错误日志并退出方法。
}
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);
}
//根据传入的hasText参数判断当前编辑框是否有文本。如果有文本，则将该编辑框所在的列表项的复选框设置为可见状态；
// 否则，将复选框设置为不可见状态。
}
/**
* @method onCheckListModeChanged
* @description 用于监听检查列表模式的改变，并根据新的模式来更新界面显示。
*/
public void onCheckListModeChanged(int oldMode, int newMode) {
//判断新的模式是否为检查列表模式。如果是，则调用switchToListMode()方法，
// 并传入当前编辑器中的文本内容，以切换到列表模式。
if (newMode == TextNote.MODE_CHECK_LIST) {
switchToListMode(mNoteEditor.getText().toString());
} else {
//调用getWorkingText()方法来获取当前的工作文本。如果获取失败（即没有工作文本），则将工作文本设置为去除了未选中标记的内容。
if (!getWorkingText()) {
mWorkingNote.setWorkingText(mWorkingNote.getContent().replace(TAG_UNCHECKED + " ",
""));
}
mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));
mEditTextList.setVisibility(View.GONE);
mNoteEditor.setVisibility(View.VISIBLE);
mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));//将编辑器的文本设置为经过高亮处理的工作文本内容
mEditTextList.setVisibility(View.GONE);//将编辑框列表设置为不可见状态。
mNoteEditor.setVisibility(View.VISIBLE);//将编辑器设置为可见状态。
}
}
/**
* @method getWorkingText
* @description 用于获取工作笔记的文本内容，并根据是否为待办事项模式进行相应处理。
* @return 该方法返回一个布尔值，表示在待办事项模式下是否有选中的项目。
*/
private boolean getWorkingText() {
boolean hasChecked = false;
//检查当前工作笔记mWorkingNote是否为待办事项模式。如果是，就遍历所有子视图view，其中包含每个待办事项的复选框和文本编辑框。
// 对于每个非空的文本编辑框，如果其相应的复选框被选中，则将文本内容作为已选中的待办事项添加到字符串缓冲区sb中，并将标记hasChecked设置为true；
// 否则，将文本内容作为未选中的待办事项添加到字符串缓冲区sb中。
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < mEditTextList.getChildCount(); i++) {
@ -1345,6 +1575,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sb.append(TAG_CHECKED).append(" ").append(edit.getText()).append("\n");
hasChecked = true;
} else {
//如果不是待办事项模式，则将文本编辑器mNoteEditor中的文本内容设置为工作笔记的文本内容。
sb.append(TAG_UNCHECKED).append(" ").append(edit.getText()).append("\n");
}
}
@ -1353,12 +1584,16 @@ public class NoteEditActivity extends Activity implements OnClickListener,
} else {
mWorkingNote.setWorkingText(mNoteEditor.getText().toString());
}
return hasChecked;
return hasChecked;//该方法返回一个布尔值hasChecked，表示在待办事项模式下是否有选中的项目。
}
//用于保存当前正在编辑的笔记。
private boolean saveNote() {
//在方法内部，首先调用getWorkingText方法获取当前正在编辑的笔记的文本内容，并将其保存到mWorkingNote对象中。
getWorkingText();
boolean saved = mWorkingNote.saveNote();
//如果保存成功，则调用setResult(RESULT_OK)方法，设置当前Activity的返回状态为RESULT_OK。
//这个状态用于标识从编辑状态返回到列表视图时，是创建新笔记还是编辑已有笔记。
if (saved) {
/**
* There are two modes from List view to edit view, open one note,
@ -1372,30 +1607,34 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return saved;
}
//用于将笔记发送到桌面。
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
*/
//检查当前正在编辑的笔记是否存在于数据库中。如果笔记不存在于数据库中，则调用saveNote()方法保存笔记。
if (!mWorkingNote.existInDatabase()) {
saveNote();
}
if (mWorkingNote.getNoteId() > 0) {
Intent sender = new Intent();
Intent sender = new Intent();//创建一个Intent对象sender用于发送广播。
Intent shortcutIntent = new Intent(this, NoteEditActivity.class);
shortcutIntent.setAction(Intent.ACTION_VIEW);
shortcutIntent.putExtra(Intent.EXTRA_UID, mWorkingNote.getNoteId());
shortcutIntent.setAction(Intent.ACTION_VIEW);//创建一个Intent对象shortcutIntent，指定其目标为NoteEditActivity类，并设置动作为Intent.ACTION_VIEW
shortcutIntent.putExtra(Intent.EXTRA_UID, mWorkingNote.getNoteId());//将正在编辑的笔记ID作为附加数据放入shortcutIntent中。
//将笔记内容生成适合作为快捷方式图标标题的字符串，并放入sender中作为附加数据。
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中。
sender.putExtra("duplicate", true);
sender.setAction("com.android.launcher.action.INSTALL_SHORTCUT");
showToast(R.string.info_note_enter_desktop);
sendBroadcast(sender);
sender.setAction("com.android.launcher.action.INSTALL_SHORTCUT");//设置sender的动作为com.android.launcher.action.INSTALL_SHORTCUT，表示要安装快捷方式。
showToast(R.string.info_note_enter_desktop);//弹出一个简短的提示消息，提示用户笔记已经进入桌面。
sendBroadcast(sender);//发送广播，安装快捷方式。
} else {
/**
* There is the condition that user has input nothing (the note is
@ -1404,20 +1643,26 @@ public class NoteEditActivity extends Activity implements OnClickListener,
*/
Log.e(TAG, "Send to desktop error");
showToast(R.string.error_note_empty_for_send_to_desktop);
//如果当前正在编辑的笔记没有有效的笔记ID，则执行以下操作：
//输出一个错误日志，表示发送到桌面出错
//弹出一个提示消息，提醒用户必须输入一些内容才能发送到桌面。
}
}
//用于生成快捷图标的标题
private String makeShortcutIconTitle(String content) {
content = content.replace(TAG_CHECKED, "");
content = content.replace(TAG_CHECKED, "");//使用replace()方法将文本中的所有TAG_CHECKED和TAG_UNCHECKED替换为空字符串，即去除已选中和未选中标记。
content = content.replace(TAG_UNCHECKED, "");
return content.length() > SHORTCUT_ICON_TITLE_MAX_LEN ? content.substring(0,
SHORTCUT_ICON_TITLE_MAX_LEN) : content;
}
//用于显示一个短时间的 Toast 提示消息
private void showToast(int resId) {
showToast(resId, Toast.LENGTH_SHORT);
}
//用于显示一个指定时长的 Toast 提示消息
private void showToast(int resId, int duration) {
Toast.makeText(this, resId, duration).show();
}

107
src/xiaomi/Notes-master/src/net/micode/notes/ui/NoteEditText.java
Unescape View File

@ -37,7 +37,25 @@ import net.micode.notes.R;
import java.util.HashMap;
import java.util.Map;
public class NoteEditText extends EditText {
/**
*
* @ProjectName: 小米便签代码标注
* @Package: net.micode.notes.ui
* @ClassName: NoteEditText
* @Description:
* 处理屏幕被按下的事件，并根据坐标更新光标位置。
* 处理用户按下一个键盘按键时会触发的删除事件，并记录光标位置。
* 处理用户松开一个键盘按键时会触发的删除和添加新文本事件，并利用OnTextViewChangeListener对文本修改进行监听。
* 处理焦点变化的事件，并利用OnTextViewChangeListener对文本修改进行监听。
* 生成上下文菜单，根据文本中的URLSpan创建菜单项并跳转到相应链接。
* @Author: 作者名 xumingyang
* @CreateDate: 2024-01-06 8:13
* @UpdateUser: 更新者：
* @UpdateDate: 2024-01-06 8:13
* @UpdateRemark: 更新说明：
* @Version: 1.0
*/
public class NoteEditText extends EditText {//继承edittext，设置便签设置文本框
private static final String TAG = "NoteEditText";
private int mIndex;
private int mSelectionStartBeforeDelete;
@ -46,6 +64,7 @@ public class NoteEditText extends EditText {
private static final String SCHEME_HTTP = "http:" ;
private static final String SCHEME_EMAIL = "mailto:" ;
//建立一个字符和整数的hash表，用于链接电话，网站，还有邮箱
private static final Map<String, Integer> sSchemaActionResMap = new HashMap<String, Integer>();
static {
sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel);
@ -56,18 +75,19 @@ public class NoteEditText extends EditText {
/**
* Call by the {@link NoteEditActivity} to delete or add edit text
*/
//在NoteEditActivity中删除或添加文本的操作，可以看做是一个文本是否被变的标记，英文注释已说明的很清楚
public interface OnTextViewChangeListener {
/**
* Delete current edit text when {@link KeyEvent#KEYCODE_DEL} happens
* and the text is null
*/
void onEditTextDelete(int index, String text);
void onEditTextDelete(int index, String text);//处理删除按键时的操作
/**
* Add edit text after current edit text when {@link KeyEvent#KEYCODE_ENTER}
* happen
*/
void onEditTextEnter(int index, String text);
void onEditTextEnter(int index, String text);//处理进入按键时的操作
/**
* Hide or show item option when text change
@ -77,72 +97,96 @@ public class NoteEditText extends EditText {
private OnTextViewChangeListener mOnTextViewChangeListener;
//根据context设置文本
public NoteEditText(Context context) {
super(context, null);
super(context, null);//用super引用父类变量
mIndex = 0;
}
//设置当前光标
public void setIndex(int index) {
mIndex = index;
}
//初始化文本修改标记
public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
mOnTextViewChangeListener = listener;
}
//AttributeSet 百度了一下是自定义空控件属性，用于维护便签动态变化的属性
//初始化便签
public NoteEditText(Context context, AttributeSet attrs) {
super(context, attrs, android.R.attr.editTextStyle);
}
// 根据defstyle自动初始化
public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
// TODO Auto-generated constructor stub
}
/**
* @method onTouchEvent
* @description 在用户触摸屏幕时被调用，实现了根据用户点击的位置更新光标的位置，让用户更加方便地编辑文本。
* @param *参数event为手机屏幕触摸事件封装类的对象，其中封装了该事件的所有信息，
* 例如触摸的位置、触摸的类型以及触摸的时间等。该对象会在用户触摸手机屏幕时被创建。
* @return 返回super.onTouchEvent(event)来处理其他的触摸事件
*/
@Override
public boolean onTouchEvent(MotionEvent event) {
switch (event.getAction()) {
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根据x,y的新值设置新的位置
Layout layout = getLayout();
int line = layout.getLineForVertical(y);
int off = layout.getOffsetForHorizontal(line, x);
Selection.setSelection(getText(), off);
break;
}
//更新光标新的位置
return super.onTouchEvent(event);
}
/**
* @method onKeyDown
* @description 处理用户按下一个键盘按键时会触发 的事件
* @param
* @return 返回super.onKeyDown(keyCode, event)来处理其他的按键事件
*/
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
switch (keyCode) {
case KeyEvent.KEYCODE_ENTER:
if (mOnTextViewChangeListener != null) {
switch (keyCode) {//根据按键的 Unicode 编码值来处理
case KeyEvent.KEYCODE_ENTER://“进入”按键
if (mOnTextViewChangeListener != null) {//如果设置了则返回false，否则交给父类处理。
return false;
}
break;
case KeyEvent.KEYCODE_DEL:
mSelectionStartBeforeDelete = getSelectionStart();
case KeyEvent.KEYCODE_DEL://“删除”按键
mSelectionStartBeforeDelete = getSelectionStart();//通过getSelectionStart()方法获取当前光标的位置，并记录下来
break;
default:
break;
}
return super.onKeyDown(keyCode, event);
return super.onKeyDown(keyCode, event);//继续执行父类的其他点击事件
}
/**
* @method onKeyUp
* @description 在用户释放一个键盘按键时被调用。它实现了处理删除和回车事件的功能，并触发相应的回调。
* @param keyCode 按键码 keyevent 按键对象
* @return 需要返回super.onKeyUp(keyCode, event)来处理其他的按键事件。
*/
@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
switch(keyCode) {
switch(keyCode) {//根据按键的 Unicode 编码值来处理，有删除和进入2种操作
case KeyEvent.KEYCODE_DEL:
if (mOnTextViewChangeListener != null) {
if (mOnTextViewChangeListener != null) {//若是被修改过
if (0 == mSelectionStartBeforeDelete && mIndex != 0) {
mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString());
return true;
@ -151,7 +195,7 @@ public class NoteEditText extends EditText {
Log.d(TAG, "OnTextViewChangeListener was not seted");
}
break;
case KeyEvent.KEYCODE_ENTER:
case KeyEvent.KEYCODE_ENTER://同上也是分为监听器是否建立2种情况
if (mOnTextViewChangeListener != null) {
int selectionStart = getSelectionStart();
String text = getText().subSequence(selectionStart, length()).toString();
@ -168,18 +212,29 @@ public class NoteEditText extends EditText {
}
@Override
/**
* @method onFocusChanged
* @description 在TextView获取或失去焦点时被调用。它实现了当TextView失去焦点且内容为空时，触发onTextChange()回调。
* @param * focused表示触发该事件的View是否获得了焦点，当该控件获得焦点时，Focused等于true，否则等于false。
* direction表示焦点移动的方向，用数值表示
* @return 表示在触发事件的View的坐标系中，前一个获得焦点的矩形区域，即表示焦点是从哪里来的。如果不可用则为null
*/
protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
if (mOnTextViewChangeListener != null) {
if (!focused && TextUtils.isEmpty(getText())) {
mOnTextViewChangeListener.onTextChange(mIndex, false);
if (mOnTextViewChangeListener != null) {//若监听器已经建立
if (!focused && TextUtils.isEmpty(getText())) {//获取到焦点并且文本不为空
mOnTextViewChangeListener.onTextChange(mIndex, false);//mOnTextViewChangeListener子函数，置false隐藏事件选项
} else {
mOnTextViewChangeListener.onTextChange(mIndex, true);
mOnTextViewChangeListener.onTextChange(mIndex, true);//mOnTextViewChangeListener子函数，置true显示事件选项
}
}
super.onFocusChanged(focused, direction, previouslyFocusedRect);
super.onFocusChanged(focused, direction, previouslyFocusedRect); //继续执行父类的其他焦点变化的事件
}
@Override
/**
* @method onCreateContextMenu
* @description 创建上下文菜单（Context Menu）。它实现了在文本中存在URL链接时，在上下文菜单中添加相应的选项，并在点击选项时执行相应的操作。
*/
protected void onCreateContextMenu(ContextMenu menu) {
if (getText() instanceof Spanned) {
int selStart = getSelectionStart();
@ -192,13 +247,13 @@ public class NoteEditText extends EditText {
if (urls.length == 1) {
int defaultResId = 0;
for(String schema: sSchemaActionResMap.keySet()) {
if(urls[0].getURL().indexOf(schema) >= 0) {
if(urls[0].getURL().indexOf(schema) >= 0) {//若url可以添加则在添加后将defaultResId置为key所映射的值
defaultResId = sSchemaActionResMap.get(schema);
break;
}
}
if (defaultResId == 0) {
if (defaultResId == 0) {//defaultResId == 0则说明url并没有添加任何东西，所以置为连接其他SchemaActionResMap的值
defaultResId = R.string.note_link_other;
}
@ -212,6 +267,6 @@ public class NoteEditText extends EditText {
});
}
}
super.onCreateContextMenu(menu);
super.onCreateContextMenu(menu);//继续执行父类的其他菜单创建的事件
}
}

32
src/xiaomi/Notes-master/src/net/micode/notes/ui/NoteItemData.java
Unescape View File

@ -26,6 +26,20 @@ import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.tool.DataUtils;
/**
*
* @ProjectName:
* @Package: net.micode.notes.ui
* @ClassName: NoteItemData
* @Description: 这是一个便签应用中的一个数据类，用于存储和管理便签的相关信息。它包含了便签的各种属性和方法，
* 例如便签的ID、提醒日期、背景颜色、创建日期、是否有附件等等。
* @Author: xumingyang
* @CreateDate: 2024-01-06 8:46
* @UpdateUser: 更新者：
* @UpdateDate: 2024-01-06 8:46
* @UpdateRemark: 更新说明：
* @Version: 1.0
*/
public class NoteItemData {
static final String [] PROJECTION = new String [] {
NoteColumns.ID,
@ -42,6 +56,7 @@ public class NoteItemData {
NoteColumns.WIDGET_TYPE,
};
//常量标记和数据就不一一标记了，意义翻译基本就知道
private static final int ID_COLUMN = 0;
private static final int ALERTED_DATE_COLUMN = 1;
private static final int BG_COLOR_ID_COLUMN = 2;
@ -76,7 +91,9 @@ public class NoteItemData {
private boolean mIsOneNoteFollowingFolder;
private boolean mIsMultiNotesFollowingFolder;
//初始化NoteItemData，主要利用光标cursor获取的东西
public NoteItemData(Context context, Cursor cursor) {
//getxxx为转换格式
mId = cursor.getLong(ID_COLUMN);
mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN);
mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN);
@ -109,31 +126,35 @@ public class NoteItemData {
checkPostion(cursor);
}
//根据鼠标的位置设置标记，和位置
private void checkPostion(Cursor cursor) {
//初始化几个标记
mIsLastItem = cursor.isLast() ? true : false;
mIsFirstItem = cursor.isFirst() ? true : false;
mIsOnlyOneItem = (cursor.getCount() == 1);
//初始化“多重子文件”“单一子文件”2个标记
mIsMultiNotesFollowingFolder = false;
mIsOneNoteFollowingFolder = false;
if (mType == Notes.TYPE_NOTE && !mIsFirstItem) {
if (mType == Notes.TYPE_NOTE && !mIsFirstItem) {//若是note格式并且不是第一个元素
int position = cursor.getPosition();
if (cursor.moveToPrevious()) {
if (cursor.moveToPrevious()) {//获取光标位置后看上一行
if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER
|| cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) {
|| cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) {//若光标满足系统或note格式
if (cursor.getCount() > (position + 1)) {
mIsMultiNotesFollowingFolder = true;
mIsMultiNotesFollowingFolder = true;//若是数据行数大于但前位置+1则设置成正确
} else {
mIsOneNoteFollowingFolder = true;
}
}
if (!cursor.moveToNext()) {
if (!cursor.moveToNext()) {//若不能再往下走则报错
throw new IllegalStateException("cursor move to previous but can't move back");
}
}
}
}
//以下都是获取标记
public boolean isOneFollowingFolder() {
return mIsOneNoteFollowingFolder;
}
@ -214,6 +235,7 @@ public class NoteItemData {
return (mAlertDate > 0);
}
//若数据父id为保存至文件夹模式的id且满足电话号码单元不为空，则isCallRecord为true
public boolean isCallRecord() {
return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber));
}

333
src/xiaomi/Notes-master/src/net/micode/notes/ui/NotesListActivity.java
Unescape View File

@ -78,6 +78,19 @@ import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashSet;
/**
*
* @ProjectName:
* @Package: net.micode.notes.ui
* @ClassName: NotesListActivity
* @Description: 显示和管理便签列表的主要界面。
* @Author: xumingyang
* @CreateDate: 2024-01-09 11:02
* @UpdateUser: 更新者：
* @UpdateDate: 2024-01-09 11:02
* @UpdateRemark: 更新说明：
* @Version: 1.0
*/
public class NotesListActivity extends Activity implements OnClickListener, OnItemLongClickListener {
/*
用于首页背景切换的控制变量
@ -141,11 +154,26 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
private final static int REQUEST_CODE_OPEN_NODE = 102;
private final static int REQUEST_CODE_NEW_NODE = 103;
/**
* @method onCreate
* @description 用于初始化资源
*/
@Override
protected void onCreate(Bundle savedInstanceState) {
/*
需要是final类型 根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。
final类不能被继承，没有子类，final类中的方法默认是final的。
final方法不能被子类的方法覆盖，但可以被继承。
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
final不能用于修饰构造方法。
*/
super.onCreate(savedInstanceState);
// 调用父类的onCreate函数
setContentView(R.layout.note_list);
//绑定视图
initResources();
//调用初始化函数进行初始化 包括数据和视图的关联
getWindow().setBackgroundDrawableResource(R.drawable.picture1);
/**
* Insert an introduction when user firstly use this application
@ -153,27 +181,41 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
setAppInfoFromRawRes();
}
/**
* @method onActivityResult
* @description 返回一些子模块完成的数据交给主Activity处理
*/
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
// 结果值 和 要求值 符合要求
if (resultCode == RESULT_OK
&& (requestCode == REQUEST_CODE_OPEN_NODE || requestCode == REQUEST_CODE_NEW_NODE)) {
mNotesListAdapter.changeCursor(null);
} else {
super.onActivityResult(requestCode, resultCode, data);
// 调用 Activity 的onActivityResult（）
}
}
/**
* @method setAppInfoFromRawRes
* @description 用于从应用的原始资源文件中读取介绍内容，并将其保存为一个便签。
*/
private void setAppInfoFromRawRes() {
// Android平台给我们提供了一个SharedPreferences类，它是一个轻量级的存储类，特别适合用于保存软件配置参数。
SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
if (!sp.getBoolean(PREFERENCE_ADD_INTRODUCTION, false)) {
StringBuilder sb = new StringBuilder();
InputStream in = null;
try {
// 把资源文件放到应用程序的/raw/raw下，那么就可以在应用中使用getResources获取资源后,
// 以openRawResource方法（不带后缀的资源文件名）打开这个文件。
in = getResources().openRawResource(R.raw.introduction);
if (in != null) {
InputStreamReader isr = new InputStreamReader(in);
BufferedReader br = new BufferedReader(isr);
char [] buf = new char[1024];
char [] buf = new char[1024];// 自行定义的数值，使用者不知道有什么意义
int len = 0;
while ((len = br.read(buf)) > 0) {
sb.append(buf, 0, len);
@ -195,12 +237,13 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
}
// 创建空的WorkingNote
WorkingNote note = WorkingNote.createEmptyNote(this, Notes.ID_ROOT_FOLDER,
AppWidgetManager.INVALID_APPWIDGET_ID, Notes.TYPE_WIDGET_INVALIDE,
ResourceParser.RED);
note.setWorkingText(sb.toString());
if (note.saveNote()) {
// 更新保存note的信息
sp.edit().putBoolean(PREFERENCE_ADD_INTRODUCTION, true).commit();
} else {
Log.e(TAG, "Save introduction note error");
@ -209,17 +252,30 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
/**
* @method onStart
* @description 启动时执行异步查询操作，以获取数据并在 UI 中显示结果。
*/
@Override
protected void onStart() {
super.onStart();
//调用父类的 onStart() 方法
startAsyncNotesListQuery();
}
/**
* @method initResources
* @description 进行资源的初始化
*/
private void initResources() {
mContentResolver = this.getContentResolver();
// 获取应用程序的数据，得到类似数据表的东西
mBackgroundQueryHandler = new BackgroundQueryHandler(this.getContentResolver());
mCurrentFolderId = Notes.ID_ROOT_FOLDER;
// findViewById 是安卓编程的定位函数，主要是引用.R文件里的引用名
mNotesListView = (ListView) findViewById(R.id.notes_list);
// 绑定XML中的ListView，作为Item的容器
mNotesListView.addFooterView(LayoutInflater.from(this).inflate(R.layout.note_list_footer, null),
null, false);
mNotesListView.setOnItemClickListener(new OnListItemClickListener());
@ -227,6 +283,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
mNotesListAdapter = new NotesListAdapter(this);
mNotesListView.setAdapter(mNotesListAdapter);
mAddNewNote = (Button) findViewById(R.id.btn_new_note);
// 在activity中要获取该按钮
mAddNewNote.setOnClickListener(this);
mAddNewNote.setOnTouchListener(new NewNoteOnTouchListener());
mDispatch = false;
@ -237,6 +294,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
mModeCallBack = new ModeCallback();
}
// 继承自ListView.MultiChoiceModeListener 和 OnMenuItemClickListener
private class ModeCallback implements ListView.MultiChoiceModeListener, OnMenuItemClickListener {
private DropdownMenu mDropDownMenu;
private ActionMode mActionMode;
@ -275,14 +333,23 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
return true;
}
/**
* @method updateMenu
* @description 新下拉菜单的内容。
* 根据已选择的项目数量和选择状态更新下拉菜单的标题和菜单项。它用于在用户选择项目时动态更新菜单的显示内容。
*/
private void updateMenu() {
int selectedCount = mNotesListAdapter.getSelectedCount();
//取已选择的项目数量。
// Update dropdown menu
String format = getResources().getString(R.string.menu_select_title, selectedCount);
mDropDownMenu.setTitle(format);
//获取一个格式化的字符串，其中包含已选择的项目数量。然后，将该字符串设置为下拉菜单的标题
mDropDownMenu.setTitle(format);// 更改标题
MenuItem item = mDropDownMenu.findItem(R.id.action_select_all);
if (item != null) {
if (mNotesListAdapter.isAllSelected()) {
//检查是否所有项目都被选择。
item.setChecked(true);
item.setTitle(R.string.menu_deselect_all);
} else {
@ -292,39 +359,76 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
/**
* @method onPrepareActionMode
* @description 进入操作模式时对菜单进行特定的修改或更新
* @return 方法直接返回 false，表示不需要进行任何额外的操作或更新。
*/
public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
// TODO Auto-generated method stub
return false;
}
/**
* @method onActionItemClicked
* @description 并用于处理操作模式菜单项的点击事件。
* @param mode 和 item 其中，mode 表示当前的操作模式对象，而 item 表示被点击的菜单项对象。
* @return 直接返回 false 表示菜单项的点击事件未被处理。 返回 true 表示已经处理了相应的菜单项点击事件。
*/
public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
// TODO Auto-generated method stub
return false;
}
/**
* @method onDestroyActionMode
* @description 它实现了 ActionMode.Callback 接口中的方法，并用于销毁操作模式。
*/
public void onDestroyActionMode(ActionMode mode) {
mNotesListAdapter.setChoiceMode(false);
//取消列表的选择模式。
mNotesListView.setLongClickable(true);
//重新启用列表项的长按事件。
mAddNewNote.setVisibility(View.VISIBLE);
//将新建笔记按钮设置为可见状态。
}
//用于结束当前的操作模式。
public void finishActionMode() {
mActionMode.finish();
//在调用 finish() 方法之前，需要确保当前存在一个有效的操作模式对象 mActionMode。
// 如果当前不存在任何操作模式对象，则调用 finish() 方法将抛出异常。
}
/**
* @method onItemCheckedStateChanged
* @description 它实现了 ActionMode.Callback 接口中的方法，并用于处理列表项的选中状态变化事件。
* @param mode 表示当前的操作模式对象，position 表示列表项的位置，id 表示列表项的唯一标识符，checked 表示列表项的选中状态。
*/
public void onItemCheckedStateChanged(ActionMode mode, int position, long id,
boolean checked) {
mNotesListAdapter.setCheckedItem(position, checked);
//将列表项的选中状态传递给列表适配器，在适配器中更新相应的数据。
updateMenu();
//根据当前选中的列表项的数量，更新操作模式的菜单项。
}
/**
* @method onMenuItemClick
* @description 它实现了 MenuItem.OnMenuItemClickListener 接口中的方法，并用于处理操作模式菜单项的单击事件。
* @param *方法接收一个参数 item，表示被单击的菜单项。
*/
public boolean onMenuItemClick(MenuItem item) {
if (mNotesListAdapter.getSelectedCount() == 0) {
Toast.makeText(NotesListActivity.this, getString(R.string.menu_select_none),
Toast.LENGTH_SHORT).show();
return true;
}
//根据被单击的菜单项 ID，执行不同的操作。
int itemId = item.getItemId();
if (itemId == R.id.delete) {
AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
@ -345,11 +449,18 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
startQueryDestinationFolders();
} else {
return false;
//如果被单击的菜单项不是删除或移动菜单项，则返回 false
}
return true;
//如果成功处理了菜单项，则返回 true。
}
}
/**
* @method
* @description 实现了OnTouchListener接口。主要功能是处理触摸。
*/
private class NewNoteOnTouchListener implements OnTouchListener {
public boolean onTouch(View v, MotionEvent event) {
@ -360,6 +471,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
int newNoteViewHeight = mAddNewNote.getHeight();
int start = screenHeight - newNoteViewHeight;
int eventY = start + (int) event.getY();
//首先获取屏幕高度和新笔记视图的高度，并计算出起始位置。如果当前状态是子文件夹状态，则还需减去标题栏的高度。
/**
* Minus TitleBar's height
*/
@ -377,6 +489,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
* also change. This is very bad, just for the UI designer's strong requirement.
*/
if (event.getY() < (event.getX() * (-0.12) + 94)) {
//通过判断触摸点的坐标是否在"New Note"按钮的透明部分上方，来决定是否将事件转发给位于按钮后面的列表视图。
View view = mNotesListView.getChildAt(mNotesListView.getChildCount() - 1
- mNotesListView.getFooterViewsCount());
if (view != null && view.getBottom() > start
@ -395,6 +508,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
mDispatchY += (int) event.getY() - mOriginY;
event.setLocation(event.getX(), mDispatchY);
return mNotesListView.dispatchTouchEvent(event);
//当动作为ACTION_MOVE（移动）时，如果之前已经开始转发事件，则更新转发的Y坐标，并将事件重新定位后转发给列表视图。
}
break;
}
@ -403,6 +517,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
event.setLocation(event.getX(), mDispatchY);
mDispatch = false;
return mNotesListView.dispatchTouchEvent(event);
//如果没有进行事件转发，则返回false，表示本类未处理该事件。
}
break;
}
@ -412,6 +527,17 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
};
/**
* @method startAsyncNotesListQuery
* @description 它通过异步查询数据库，获取指定文件夹下的笔记列表，并将结果显示在UI上。
* @param
* *FOLDER_NOTE_LIST_QUERY_TOKEN是一个常量值，用于标识该次查询（可以理解为查询ID）。
* 第二个参数为null，表示不需要传递额外的数据。
* 第三个参数是查询的URI，即Notes.CONTENT_NOTE_URI，表示查询笔记内容的URI。
* 第四个参数是查询需要返回的列名数组（NoteItemData.PROJECTION），用于指定查询结果中需要包含哪些列。
* 第五个参数是selection，表示查询时要使用的筛选条件。
* 最后一个参数是一个字符串数组，表示用于替换查询语句中占位符的值。
*/
private void startAsyncNotesListQuery() {
String selection = (mCurrentFolderId == Notes.ID_ROOT_FOLDER) ? ROOT_FOLDER_SELECTION
: NORMAL_SELECTION;
@ -450,17 +576,28 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
super(contentResolver);
}
/**
* @method onQueryComplete
* @description 用于处理异步查询完成后的回调。
* @param token 参数来判断当前是哪个查询完成了。根据不同的查询标识（token），执行相应的操作。
*/
@Override
protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
switch (token) {
case FOLDER_NOTE_LIST_QUERY_TOKEN:
//表示文件夹笔记列表查询完成。
mNotesListAdapter.changeCursor(cursor);
//更新笔记列表的显示内容。
break;
case FOLDER_LIST_QUERY_TOKEN:
//表示文件夹列表查询完成。
if (cursor != null && cursor.getCount() > 0) {
showFolderListMenu(cursor);
//调用showFolderListMenu(cursor)方法，显示文件夹列表菜单。
} else {
Log.e(TAG, "Query folder failed");
//在日志中记录查询文件夹失败的错误信息。
}
break;
default:
@ -469,32 +606,51 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
/**
* @method showFolderListMenu
* @description 用于显示文件夹列表菜单。
*/
private void showFolderListMenu(Cursor cursor) {
AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
builder.setTitle(R.string.menu_title_select_folder);
final FoldersListAdapter adapter = new FoldersListAdapter(this, cursor);
builder.setAdapter(adapter, new DialogInterface.OnClickListener() {
//设置对话框的列表项和点击事件监听器。
//将适配器设置为对话框的列表项，并在点击列表项时执行相应的操作。
public void onClick(DialogInterface dialog, int which) {
DataUtils.batchMoveToFolder(mContentResolver,
mNotesListAdapter.getSelectedItemIds(), adapter.getItemId(which));
Toast.makeText(
//显示一条消息，内容为移动的笔记数量和所选文件夹的名称。
NotesListActivity.this,
getString(R.string.format_move_notes_to_folder,
mNotesListAdapter.getSelectedCount(),
adapter.getFolderName(NotesListActivity.this, which)),
Toast.LENGTH_SHORT).show();
mModeCallBack.finishActionMode();
//结束动作模式（Action Mode），即退出多选模式。
}
});
builder.show();
//显示文件夹列表菜单对话框
}
/**
* @method createNewNote
* @description 用于创建新的笔记
* @param * intent 来启动一个名为NoteEditActivity的活动，
* ACTION_INSERT_OR_EDIT表示要执行插入或编辑操作
* Notes.INTENT_EXTRA_FOLDER_ID则是传递当前文件夹的ID
*/
private void createNewNote() {
Intent intent = new Intent(this, NoteEditActivity.class);
intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mCurrentFolderId);
this.startActivityForResult(intent, REQUEST_CODE_NEW_NODE);
//通过startActivityForResult方法启动活动，并传递了一个请求码（REQUEST_CODE_NEW_NOTE），以便在活动返回结果时进行区分。
}
private void batchDelete() {
@ -534,16 +690,30 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}.execute();
}
/**
* @method deleteFolder
* @description 避免意外情况下删除根文件夹
* @date: 2024-01-09 14:54
* @author: 作者名
* @param folderId，表示要删除的文件夹的ID
* @return
*/
private void deleteFolder(long folderId) {
if (folderId == Notes.ID_ROOT_FOLDER) {
Log.e(TAG, "Wrong folder id, should not happen " + folderId);
return;
//在方法内部，首先通过条件判断检查folderId是否等于Notes.ID_ROOT_FOLDER（根文件夹的ID）。
// 如果是根文件夹的ID，则记录错误日志并返回，不执行删除操作。
}
HashSet<Long> ids = new HashSet<Long>();
ids.add(folderId);
//创建一个HashSet<Long>对象，并将folderId添加到该集合中
HashSet<AppWidgetAttribute> widgets = DataUtils.getFolderNoteWidget(mContentResolver,
folderId);
//调用DataUtils.getFolderNoteWidget()方法获取与该文件夹相关联的小部件。将结果保存在widgets变量中。
if (!isSyncMode()) {
// if not synced, delete folder directly
DataUtils.batchDeleteNotes(mContentResolver, ids);
@ -556,11 +726,17 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID
&& widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) {
updateWidget(widget.widgetId, widget.widgetType);
//遍历widgets集合中的每个小部件，并根据小部件的ID和类型调用updateWidget()方法进行小部件的更新操作。
}
}
}
}
/**
* @method openNode
* @description 用于打开笔记。
*/
private void openNode(NoteItemData data) {
Intent intent = new Intent(this, NoteEditActivity.class);
intent.setAction(Intent.ACTION_VIEW);
@ -568,48 +744,75 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
this.startActivityForResult(intent, REQUEST_CODE_OPEN_NODE);
}
/**
* @method openFolder
* @description 打开指定的文件夹
* @param data，表示要打开的文件夹
* @return
*/
private void openFolder(NoteItemData data) {
mCurrentFolderId = data.getId();
//将当前文件夹的ID设置为参数data的ID，并调用startAsyncNotesListQuery()方法开始异步查询当前文件夹下的笔记列表。
startAsyncNotesListQuery();
//根据文件夹的ID判断当前状态：
if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
mState = ListEditState.CALL_RECORD_FOLDER;
mAddNewNote.setVisibility(View.GONE);
//如果文件夹的ID为Notes.ID_CALL_RECORD_FOLDER，则将状态设置为ListEditState.CALL_RECORD_FOLDER，并隐藏添加新笔记按钮；
} else {
mState = ListEditState.SUB_FOLDER;
//将状态设置为ListEditState.SUB_FOLDER。
}
//根据文件夹的ID设置标题栏的文本：
if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
mTitleBar.setText(R.string.call_record_folder_name);
//如果文件夹的ID为Notes.ID_CALL_RECORD_FOLDER，则设置标题栏的文本为字符串资源R.string.call_record_folder_name；
} else {
mTitleBar.setText(data.getSnippet());
//否则，设置标题栏的文本为文件夹的名称（通过调用data.getSnippet()方法获取）
}
mTitleBar.setVisibility(View.VISIBLE);
//将标题栏设置为可见状态。
}
//当按钮控件的 id 为 btn_new_note 的按钮被点击时，该方法会调用 createNewNote() 方法。
public void onClick(View v) {
if (v.getId() == R.id.btn_new_note) {
createNewNote();
}
}
//显示软键盘
private void showSoftInput() {
InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
if (inputMethodManager != null) {
inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
}
}
//隐藏软键盘
private void hideSoftInput(View view) {
InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
/**
* @method showCreateOrModifyFolderDialog
* @description 用于创建或者是修改文件夹
* @param *接收一个参数create，用于指示是创建文件夹还是修改文件夹。
*/
private void showCreateOrModifyFolderDialog(final boolean create) {
final AlertDialog.Builder builder = new AlertDialog.Builder(this);
View view = LayoutInflater.from(this).inflate(R.layout.dialog_edit_text, null);
//在方法内部，首先创建一个AlertDialog.Builder对象，并通过LayoutInflater从XML布局文件中实例化一个视图。
final EditText etName = (EditText) view.findViewById(R.id.et_foler_name);
showSoftInput();
//获取EditText对象用于输入文件夹名称，并调用showSoftInput()方法显示软键盘。
//根据create参数的值，判断是创建文件夹还是修改文件夹。如果是修改文件夹，
if (!create) {
if (mFocusNoteDataItem != null) {
etName.setText(mFocusNoteDataItem.getSnippet());
// 从mFocusNoteDataItem中获取文件夹名称，并设置对话框的标题为对应的修改文件夹名称；
builder.setTitle(getString(R.string.menu_folder_change_name));
} else {
Log.e(TAG, "The long click data item is null");
@ -618,6 +821,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
} else {
etName.setText("");
builder.setTitle(this.getString(R.string.menu_create_folder));
// 如果是创建文件夹，则将EditText的文本设置为空，并设置对话框的标题为创建文件夹。
}
builder.setPositiveButton(android.R.string.ok, null);
@ -688,15 +892,28 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
});
}
/**
* @method onBackPressed
* @description 用于处理用户按下返回按钮的操作
*/
@Override
public void onBackPressed() {
switch (mState) {
//通过switch语句检查当前的状态（mState）
case SUB_FOLDER:
mCurrentFolderId = Notes.ID_ROOT_FOLDER;
mState = ListEditState.NOTE_LIST;
startAsyncNotesListQuery();
mTitleBar.setVisibility(View.GONE);
break;
/*
如果当前状态为SUB_FOLDER（子文件夹），
则将mCurrentFolderId设置为根文件夹的ID（Notes.ID_ROOT_FOLDER），
将状态设置为笔记列表状态（ListEditState.NOTE_LIST），
并调用startAsyncNotesListQuery()方法开始异步查询笔记列表。
同时，隐藏标题栏（mTitleBar.setVisibility(View.GONE)）
*/
case CALL_RECORD_FOLDER:
mCurrentFolderId = Notes.ID_ROOT_FOLDER;
mState = ListEditState.NOTE_LIST;
@ -704,27 +921,43 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
mTitleBar.setVisibility(View.GONE);
startAsyncNotesListQuery();
break;
/*
如果当前状态为CALL_RECORD_FOLDER（通话记录文件夹），
则同样将mCurrentFolderId设置为根文件夹的ID，
将状态设置为笔记列表状态，显示添加新笔记按钮（mAddNewNote.setVisibility(View.VISIBLE)），
隐藏标题栏，并调用startAsyncNotesListQuery()方法开始异步查询笔记列表。
*/
case NOTE_LIST:
super.onBackPressed();
//调用父类的onBackPressed()方法，执行默认的返回操作。
break;
default:
break;
}
}
/**
* @method updateWidget
* @description 用于更新小部件（widget）
*/
private void updateWidget(int appWidgetId, int appWidgetType) {
Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
//根据appWidgetType的不同值，设置不同的NoteWidgetProvider类作为接收广播的目标。
if (appWidgetType == Notes.TYPE_WIDGET_2X) {
intent.setClass(this, NoteWidgetProvider_2x.class);
//设置NoteWidgetProvider_2x类作为目标；
} else if (appWidgetType == Notes.TYPE_WIDGET_4X) {
intent.setClass(this, NoteWidgetProvider_4x.class);
//则设置NoteWidgetProvider_4x类作为目标
} else {
Log.e(TAG, "Unspported widget type");
//不匹配任何已知的类型，则记录一个错误日志并返回
return;
}
intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] {
appWidgetId
appWidgetId//将appWidgetId作为额外参数放入意图中，并通过sendBroadcast方法发送广播。
});
sendBroadcast(intent);
@ -742,17 +975,31 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
};
/**
* @method onContextMenuClosed
* @description 在上下文菜单关闭时调用的方法
*/
@Override
public void onContextMenuClosed(Menu menu) {
if (mNotesListView != null) {
mNotesListView.setOnCreateContextMenuListener(null);
//然后通过调用 setOnCreateContextMenuListener(null) 方法将上下文菜单的创建监听器设置为 null，即移除了上下文菜单的创建监听器。
}
super.onContextMenuClosed(menu);
//调用 super.onContextMenuClosed(menu) 方法来执行父类的相应操作。
}
/**
* @method onContextItemSelected
* @description 用于处理上下文菜单项的选择操作
* @return 返回true表示操作已经成功处理 如果为空，则记录错误日志并返回false
*/
@Override
public boolean onContextItemSelected(MenuItem item) {
if (mFocusNoteDataItem == null) {
//通过检查mFocusNoteDataItem是否为空来确保当前长按操作的数据项不为空
Log.e(TAG, "The long click data item is null");
return false;
}
@ -760,6 +1007,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
case MENU_FOLDER_VIEW:
openFolder(mFocusNoteDataItem);
break;
//如果用户选择了“查看文件夹”菜单项，则调用openFolder()方法打开该文件夹。
case MENU_FOLDER_DELETE:
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle(getString(R.string.alert_title_delete));
@ -774,9 +1022,12 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
builder.setNegativeButton(android.R.string.cancel, null);
builder.show();
break;
//如果用户选择了“删除文件夹”菜单项，则弹出一个提示对话框，
// 并在用户确认删除操作后调用deleteFolder()方法执行相应的数据库操作。
case MENU_FOLDER_CHANGE_NAME:
showCreateOrModifyFolderDialog(false);
break;
//如果用户选择了“重命名文件夹”菜单项，则调用showCreateOrModifyFolderDialog()方法显示创建或修改文件夹的对话框。
default:
break;
}
@ -784,9 +1035,19 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
return true;
}
/**
* @method onPrepareOptionsMenu
* @description 用于在菜单准备显示时进行处理的。
* 它会根据当前的状态（mState）来加载不同的菜单布局，并设置相应的标题。
* @return 方法返回true，表示菜单已经被处理完毕。
*/
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
menu.clear();
//通过调用menu.clear()方法清除菜单中的所有项。
//根据mState的不同值，使用getMenuInflater().inflate()方法加载对应的菜单布局文件。
if (mState == ListEditState.NOTE_LIST) {
getMenuInflater().inflate(R.menu.note_list, menu);
// set sync or sync_cancel
@ -834,6 +1095,11 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
startActivity(intent);
finish();
}
/**
* @method onOptionsItemSelected
* @description 每当用户选择菜单项时，Android 系统会调用该方法，并传入被选中的菜单项（MenuItem）。
*/
@Override
public boolean onOptionsItemSelected(MenuItem item) {
int login_mode=-1;
@ -845,6 +1111,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
else{
login_mode=0;
}
//该方法首先获取被选中菜单项的ID，然后根据不同的ID执行相应的操作。
int itemId = item.getItemId();
if (itemId == R.id.menu_new_folder) {
showCreateOrModifyFolderDialog(true);
@ -926,8 +1193,24 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
dialog.show();
}
return true;
/*
* 如果选中的菜单项是R.id.menu_new_folder，则调用showCreateOrModifyFolderDialog(true)方法，显示创建或修改文件夹的对话框。
* 如果选中的菜单项是R.id.menu_export_text，则调用exportNoteToText()方法，将笔记导出为文本。
* 如果选中的菜单项是R.id.menu_sync，则根据当前是否处于同步模式（isSyncMode()）分别启动或取消同步服务（GTaskSyncService）或打开设置活动（startPreferenceActivity）。
* 如果选中的菜单项是R.id.menu_setting，则打开设置活动（startPreferenceActivity）。
* 如果选中的菜单项是R.id.menu_new_note，则创建新的笔记（createNewNote）。
* 如果选中的菜单项是R.id.menu_search，则执行搜索请求（onSearchRequested）。
*/
}
/**
* @method onSearchRequested
* @description nSearchRequested方法是一个覆盖方法，用于在用户点击搜索按钮或者执行搜索手势时被调用。
* @param *搜索关键字（null表示没有指定关键字），
* 是否全局搜索（false表示只搜索当前应用程序），
* 应用程序数据（null表示没有额外的应用程序数据），
* 以及是否由用户触发的搜索（false表示不是由用户触发）。
*/
@Override
public boolean onSearchRequested() {
startSearch(null, false, null /* appData */, false);
@ -975,14 +1258,23 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}.execute();
}
//用于检查是否处于同步模式
private boolean isSyncMode() {
return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
}
/**
* @method startPreferenceActivity
* @description 用于启动应用程序的“偏好设置”屏幕
* @param
* @return
*/
private void startPreferenceActivity() {
Activity from = getParent() != null ? getParent() : this;
//通过检查父活动是否存在来确定从哪个活动中启动偏好设置屏幕。
Intent intent = new Intent(from, NotesPreferenceActivity.class);
//创建一个新的意图（Intent）对象，并将其目标设置为NotesPreferenceActivity类。
from.startActivityIfNeeded(intent, -1);
}
@ -1027,6 +1319,18 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
/**
* @method startQueryDestinationFolders
* @description 用于开始查询目标文件夹列表。
* @param
* *FOLDER_LIST_QUERY_TOKEN：查询令牌，用于标识此次查询。
* null：附加到查询令牌的对象，这里为null。
* Notes.CONTENT_NOTE_URI：要查询的URI，表示笔记内容。
* FoldersListAdapter.PROJECTION：要返回的数据列数组。
* selection：查询的条件字符串。
* new String[] { String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER), String.valueOf(mCurrentFolderId) }：查询条件中的参数值。
* NoteColumns.MODIFIED_DATE + " DESC"：查询结果按照修改日期降序排列。
*/
private void startQueryDestinationFolders() {
String selection = NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>? AND " + NoteColumns.ID + "<>?";
selection = (mState == ListEditState.NOTE_LIST) ? selection:
@ -1044,21 +1348,30 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
},
NoteColumns.MODIFIED_DATE + " DESC");
}
/**
* @method onItemLongClick
* @description 用于处理列表项的长按事件
* @return 返回false表示事件未被消耗，以便继续处理其他可能的事件。
*/
public boolean onItemLongClick(AdapterView<?> parent, View view, int position, long id) {
if (view instanceof NotesListItem) {
//通过检查view是否是NotesListItem的实例来确定长按的列表项类型。
mFocusNoteDataItem = ((NotesListItem) view).getItemData();
if (mFocusNoteDataItem.getType() == Notes.TYPE_NOTE && !mNotesListAdapter.isInChoiceMode()) {
if (mNotesListView.startActionMode(mModeCallBack) != null) {
mModeCallBack.onItemCheckedStateChanged(null, position, id, true);
mNotesListView.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
//调用mModeCallBack.onItemCheckedStateChanged()方法更新选择状态。
mNotesListView.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
//调用mNotesListView.performHapticFeedback()方法进行触觉反馈，表示长按操作已触发。
} else {
Log.e(TAG, "startActionMode fails");
}
} else if (mFocusNoteDataItem.getType() == Notes.TYPE_FOLDER) {
mNotesListView.setOnCreateContextMenuListener(mFolderOnCreateContextMenuListener);
}
//如果数据项的类型为文件夹类型(Notes.TYPE_FOLDER)，则设置列表视图的上下文菜单创建监听器(mFolderOnCreateContextMenuListener)。
}
}
return false;
//返回false表示事件未被消耗，以便继续处理其他可能的事件。
}
}

112
src/xiaomi/Notes-master/src/net/micode/notes/ui/NotesListAdapter.java
Unescape View File

@ -31,56 +31,104 @@ import java.util.HashSet;
import java.util.Iterator;
/**
*
* @ProjectName:
* @Package: net.micode.notes.ui
* @ClassName: NotesListAdapter
* @Description: 扩展了CursorAdapter类，用于显示笔记列表。
* 该适配器具有选择模式，允许用户选择多个项目，并处理所选项目的响应。
* 它还提供了一些实用方法，例如获取所选项目的ID和小部件属性等。
* @Author: xumingyang
* @CreateDate: 2024-01-07 23:46
* @UpdateUser: 更新者：
* @UpdateDate: 2024-01-07 23:46
* @UpdateRemark: 更新说明：
* @Version: 1.0
*/
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 int mNotesCount;//便签数
private boolean mChoiceMode;//选择模式标记
//桌面widget的属性，包括编号和类型
public static class AppWidgetAttribute {
public int widgetId;
public int widgetType;
};
/**
* @method NotesListAdapter
* @description 初始化便签链接器
*/
public NotesListAdapter(Context context) {
super(context, null);
mSelectedIndex = new HashMap<Integer, Boolean>();
super(context, null);//父类对象置空
mSelectedIndex = new HashMap<Integer, Boolean>();//新建选项下标的hash表
mContext = context;
mNotesCount = 0;
}
/**
* @method newView
* @description 新建一个视图来存储光标所指向的数据
* return 返回一个新的项目选项
*/
@Override
public View newView(Context context, Cursor cursor, ViewGroup parent) {
return new NotesListItem(context);
}
/**
* @method bindView
* @description 将已经存在的视图和鼠标指向的数据进行捆绑
*/
@Override
public void bindView(View view, Context context, Cursor cursor) {
if (view instanceof NotesListItem) {
if (view instanceof NotesListItem) {//若view是NotesListItem的一个实例
//则新建一个项目选项并且用bind跟将view和鼠标，内容，便签数据捆绑在一起
NoteItemData itemData = new NoteItemData(context, cursor);
((NotesListItem) view).bind(context, itemData, mChoiceMode,
isSelectedItem(cursor.getPosition()));
}
}
/**
* @method setCheckedItem
* @description 设置勾选框
*/
public void setCheckedItem(final int position, final boolean checked) {
mSelectedIndex.put(position, checked);
notifyDataSetChanged();
mSelectedIndex.put(position, checked);//根据定位和是否勾选设置下标
notifyDataSetChanged();//在修改后刷新activity
}
//判断单选按钮是否勾选
public boolean isInChoiceMode() {
return mChoiceMode;
}
/**
* @method setChoiceMode
* @description 设置单项选项框
*/
public void setChoiceMode(boolean mode) {
mSelectedIndex.clear();
mSelectedIndex.clear();//重置下标并且根据参数mode设置选项
mChoiceMode = mode;
}
/*
* 函数功能：选择全部选项
* 函数实现：如下注释
*/
/**
* @method selectAll
* @description 选择全部选项
* @param *cursor游标对象
*/
public void selectAll(boolean checked) {
Cursor cursor = getCursor();
for (int i = 0; i < getCount(); i++) {
Cursor cursor = getCursor();//获取光标位置
for (int i = 0; i < getCount(); i++) {//遍历所有光标可用的位置在判断为便签类型之后勾选单项框
if (cursor.moveToPosition(i)) {
if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) {
setCheckedItem(i, checked);
@ -89,14 +137,20 @@ public class NotesListAdapter extends CursorAdapter {
}
}
/**
* @method getSelectedItemIds
* @description 建立选择项的下标列表
* @param *hashset hash表
* @return 返回一个itemSet 下标列表
*/
public HashSet<Long> getSelectedItemIds() {
HashSet<Long> itemSet = new HashSet<Long>();
for (Integer position : mSelectedIndex.keySet()) {
if (mSelectedIndex.get(position) == true) {
HashSet<Long> itemSet = new HashSet<Long>();//建立hash表
for (Integer position : mSelectedIndex.keySet()) {//遍历所有的关键
if (mSelectedIndex.get(position) == true) {//若光标位置可用
Long id = getItemId(position);
if (id == Notes.ID_ROOT_FOLDER) {
if (id == Notes.ID_ROOT_FOLDER) {//原文件不需要添加
Log.d(TAG, "Wrong item id, should not happen");
} else {
} else { //则将id该下标假如选项集合中
itemSet.add(id);
}
}
@ -105,12 +159,18 @@ public class NotesListAdapter extends CursorAdapter {
return itemSet;
}
/**
* @method getSelectedWidget
* @description 建立桌面Widget的选项表
* @param *hashset hash表
* @return 返回一个itemSet 桌面Widget选项表
*/
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);
if (c != null) {
if (c != null) {//光标位置可用的话就建立新的Widget属性并编辑下标和类型，最后添加到选项集中
AppWidgetAttribute widget = new AppWidgetAttribute();
NoteItemData item = new NoteItemData(mContext, c);
widget.widgetId = item.getWidgetId();
@ -128,12 +188,17 @@ public class NotesListAdapter extends CursorAdapter {
return itemSet;
}
/**
* @method getSelectedCount
* @description 统计选项的个数
* @return 返回count 表示选项的个数
*/
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()) {
@ -143,37 +208,44 @@ public class NotesListAdapter extends CursorAdapter {
return count;
}
//函数功能：判断是否全部选中
public boolean isAllSelected() {
int checkedCount = getSelectedCount();
return (checkedCount != 0 && checkedCount == mNotesCount);
//获取选项数看是否等于便签的个数
}
//函数功能：判断是否为选项表
public boolean isSelectedItem(final int position) {
if (null == mSelectedIndex.get(position)) {
return false;
}
return mSelectedIndex.get(position);
//通过传递的下标来确定
}
//函数功能：在activity内容发生局部变动的时候回调该函数计算便签的数量
@Override
protected void onContentChanged() {
super.onContentChanged();
super.onContentChanged();//执行基类函数
calcNotesCount();
}
//函数功能：在activity光标发生局部变动的时候回调该函数计算便签的数量
@Override
public void changeCursor(Cursor cursor) {
super.changeCursor(cursor);
calcNotesCount();
}
//函数功能：计算便签数量
private void calcNotesCount() {
mNotesCount = 0;
for (int i = 0; i < getCount(); i++) {
Cursor c = (Cursor) getItem(i);
if (c != null) {
if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) {
mNotesCount++;
mNotesCount++;//若该位置不为空并且文本类型为便签就+1
}
} else {
Log.e(TAG, "Invalid cursor");

27
src/xiaomi/Notes-master/src/net/micode/notes/ui/NotesListItem.java
Unescape View File

@ -29,18 +29,21 @@ import net.micode.notes.data.Notes;
import net.micode.notes.tool.DataUtils;
import net.micode.notes.tool.ResourceParser.NoteItemBgResources;
//创建便签列表项目选项
public class NotesListItem extends LinearLayout {
private ImageView mAlert;
private TextView mTitle;
private TextView mTime;
private ImageView mAlert;//闹钟图片
private TextView mTitle;//标题
private TextView mTime;//时间
private TextView mCallName;
private NoteItemData mItemData;
private CheckBox mCheckBox;
private NoteItemData mItemData;//标签数据
private CheckBox mCheckBox;//打钩框
/*初始化基本信息*/
public NotesListItem(Context context) {
super(context);
super(context);//super()它的主要作用是调整调用父类构造函数的顺序
inflate(context, R.layout.note_item, this);
//Inflate可用于将一个xml中定义的布局控件找出来,这里的xml是r。layout
//findViewById用于从contentView中查找指定ID的View，转换出来的形式根据需要而定;
mAlert = (ImageView) findViewById(R.id.iv_alert_icon);
mTitle = (TextView) findViewById(R.id.tv_title);
mTime = (TextView) findViewById(R.id.tv_time);
@ -48,6 +51,7 @@ public class NotesListItem extends LinearLayout {
mCheckBox = (CheckBox) findViewById(android.R.id.checkbox);
}
//根据data的属性对各个控件的属性的控制，主要是可见性Visibility，内容setText，格式setTextAppearance
public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
if (choiceMode && data.getType() == Notes.TYPE_NOTE) {
mCheckBox.setVisibility(View.VISIBLE);
@ -57,6 +61,7 @@ public class NotesListItem extends LinearLayout {
}
mItemData = data;
//设置控件属性，一共三种情况，由data的id和父id是否与保存到文件夹的id一致来决定
if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
mCallName.setVisibility(View.GONE);
mAlert.setVisibility(View.VISIBLE);
@ -94,13 +99,15 @@ public class NotesListItem extends LinearLayout {
}
}
}
mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));
mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));//设置内容，获取相关时间，从data里编辑的日期中获取
setBackground(data);
}
//根据data的文件属性来设置背景
private void setBackground(NoteItemData data) {
int id = data.getBgColorId();
//若是note型文件，则4种情况，对于4种不同情况的背景来源
if (data.getType() == Notes.TYPE_NOTE) {
if (data.isSingle() || data.isOneFollowingFolder()) {
setBackgroundResource(NoteItemBgResources.getNoteBgSingleRes(id));
@ -111,7 +118,9 @@ public class NotesListItem extends LinearLayout {
} else {
setBackgroundResource(NoteItemBgResources.getNoteBgNormalRes(id));
}
} else {
}
//若不是note直接调用文件夹的背景来源
else {
setBackgroundResource(NoteItemBgResources.getFolderBgRes());
}
}

203
src/xiaomi/Notes-master/src/net/micode/notes/ui/NotesPreferenceActivity.java
Unescape View File

@ -48,53 +48,78 @@ import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.gtask.remote.GTaskSyncService;
/**
*
* @ProjectName:
* @Package: net.micode.notes.ui
* @ClassName: NotesPreferenceActivity
* @Description: 它提供了一些选项供用户选择，例如设置字体大小、颜色、排序方式、备份/恢复等。
* 用户可以通过这个界面来调整应用程序的行为和外观，以更好地适应其需求和喜好。
* NotesPreferenceActivity，在小米便签中主要实现的是对背景颜色和字体大小的数据储存。
* 继承了PreferenceActivity主要功能为对系统信息和配置进行自动保存的Activity
* @Author: xumingyang
* @CreateDate: 2024-01-08 18:03
* @UpdateUser: 更新者：
* @UpdateDate: 2024-01-08 18:03
* @UpdateRemark: 更新说明：
* @Version: 1.0
*/
public class NotesPreferenceActivity extends PreferenceActivity {
public static final String PREFERENCE_NAME = "notes_preferences";
public static final String PREFERENCE_NAME = "notes_preferences";//优先名
public static final String PREFERENCE_SYNC_ACCOUNT_NAME = "pref_key_account_name";
public static final String PREFERENCE_SYNC_ACCOUNT_NAME = "pref_key_account_name";//同步账号
public static final String PREFERENCE_LAST_SYNC_TIME = "pref_last_sync_time";
public static final String PREFERENCE_LAST_SYNC_TIME = "pref_last_sync_time";//同步时间
public static final String PREFERENCE_SET_BG_COLOR_KEY = "pref_key_bg_random_appear";
private static final String PREFERENCE_SYNC_ACCOUNT_KEY = "pref_sync_account_key";
private static final String PREFERENCE_SYNC_ACCOUNT_KEY = "pref_sync_account_key"; //同步密码
private static final String AUTHORITIES_FILTER_KEY = "authorities";
private static final String AUTHORITIES_FILTER_KEY = "authorities";//本地密码
private PreferenceCategory mAccountCategory;
private PreferenceCategory mAccountCategory; //账户分组
private GTaskReceiver mReceiver;
private GTaskReceiver mReceiver;//同步任务接收器
private Account[] mOriAccounts;
private Account[] mOriAccounts;//账户
private boolean mHasAddedAccount;
private boolean mHasAddedAccount;//账户的HASH标记
/**
* @method onCreate
* @description 创建一个activity，在函数里要完成所有的正常静态设置
* @param *Bundle icicle：存放了 activity 当前的状态
*/
@Override
protected void onCreate(Bundle icicle) {
super.onCreate(icicle);
super.onCreate(icicle);//先执行父类的创建函数
/* using the app icon for navigation */
getActionBar().setDisplayHomeAsUpEnabled(true);
getActionBar().setDisplayHomeAsUpEnabled(true);//给左上角图标的左边加上一个返回的图标
addPreferencesFromResource(R.xml.preferences);
mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);
addPreferencesFromResource(R.xml.preferences);//添加xml来源并显示 xml
mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);//根据同步账户关键码来初始化分组
mReceiver = new GTaskReceiver();
IntentFilter filter = new IntentFilter();
filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME);
registerReceiver(mReceiver, filter);
registerReceiver(mReceiver, filter);//初始化同步组件
mOriAccounts = null;
View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null);
getListView().addHeaderView(header, null, true);
View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null);//获取listvivew，ListView的作用:用于列出所有选择
getListView().addHeaderView(header, null, true); //在listview组件上方添加其他组件
}
@Override
/**
* @method onResume
* @description activity交互功能的实现，用于接受用户的输入
*/
protected void onResume() {
super.onResume();
super.onResume();//先执行父类 的交互实现
// need to set sync account automatically if user has added a new
// account
if (mHasAddedAccount) {
if (mHasAddedAccount) {//若用户新加了账户则自动设置同步账户
Account[] accounts = getGoogleAccounts();
if (mOriAccounts != null && accounts.length > mOriAccounts.length) {
for (Account accountNew : accounts) {
@ -116,6 +141,10 @@ public class NotesPreferenceActivity extends PreferenceActivity {
refreshUI();
}
/**
* @method onDestroy
* @description 销毁一个activity
*/
@Override
protected void onDestroy() {
if (mReceiver != null) {
@ -124,48 +153,66 @@ public class NotesPreferenceActivity extends PreferenceActivity {
super.onDestroy();
}
/**
* @method loadAccountPreference
* @description 重新设置账户信息
*/
private void loadAccountPreference() {
mAccountCategory.removeAll();
//销毁所有的分组
Preference accountPref = new Preference(this);
//建立首选项
final String defaultAccount = getSyncAccountName(this);
accountPref.setTitle(getString(R.string.preferences_account_title));
accountPref.setSummary(getString(R.string.preferences_account_summary));
//设置首选项的大标题和小标题
accountPref.setOnPreferenceClickListener(new OnPreferenceClickListener() {
public boolean onPreferenceClick(Preference preference) {
//建立监听器
if (!GTaskSyncService.isSyncing()) {
if (TextUtils.isEmpty(defaultAccount)) {
// the first time to set account
//若是第一次建立账户显示选择账户提示对话框
showSelectAccountAlertDialog();
} else {
// if the account has already been set, we need to promp
// user about the risk
//若是已经建立则显示修改对话框并进行修改操作
showChangeAccountConfirmAlertDialog();
}
} else {
//若在没有同步的情况下，则在toast中显示不能修改
Toast.makeText(NotesPreferenceActivity.this,
R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
.show();
}
return true;
}
});
//根据新建首选项编辑新的账户分组
mAccountCategory.addPreference(accountPref);
}
/**
* @method loadSyncButton
* @description 设置按键的状态和最后同步的时间
*/
private void loadSyncButton() {
Button syncButton = (Button) findViewById(R.id.preference_sync_button);
TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
//获取同步按钮控件和最终同步时间的的窗口
// set button state
//设置按钮的状态
if (GTaskSyncService.isSyncing()) {
//若是在同步状态下
syncButton.setText(getString(R.string.preferences_button_sync_cancel));
syncButton.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
GTaskSyncService.cancelSync(NotesPreferenceActivity.this);
}
});
//设置按钮显示的文本为“取消同步”以及监听器
} else {
syncButton.setText(getString(R.string.preferences_button_sync_immediately));
syncButton.setOnClickListener(new View.OnClickListener() {
@ -173,50 +220,68 @@ public class NotesPreferenceActivity extends PreferenceActivity {
GTaskSyncService.startSync(NotesPreferenceActivity.this);
}
});
//若是不同步则设置按钮显示的文本为“立即同步”以及对应监听器
}
syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this)));
//设置按键可用还是不可用
// set last sync time
// 设置最终同步时间
if (GTaskSyncService.isSyncing()) {
//若是在同步的情况下
lastSyncTimeView.setText(GTaskSyncService.getProgressString());
lastSyncTimeView.setVisibility(View.VISIBLE);
// 根据当前同步服务器设置时间显示框的文本以及可见性
} else {
//若是非同步情况
long lastSyncTime = getLastSyncTime(this);
if (lastSyncTime != 0) {
lastSyncTimeView.setText(getString(R.string.preferences_last_sync_time,
DateFormat.format(getString(R.string.preferences_last_sync_time_format),
lastSyncTime)));
lastSyncTimeView.setVisibility(View.VISIBLE);
//则根据最后同步时间的信息来编辑时间显示框的文本内容和可见性
} else {
//若时间为空直接设置为不可见状态
lastSyncTimeView.setVisibility(View.GONE);
}
}
}
/**
* @method refreshUI
* @description 刷新标签界面
*/
private void refreshUI() {
loadAccountPreference();
loadSyncButton();
//调用上文设置账号和设置按键两个函数来实现
}
/**
* @method showSelectAccountAlertDialog
* @description 函数功能：显示账户选择的对话框并进行账户的设置
*/
private void showSelectAccountAlertDialog() {
AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
//创建一个新的对话框
View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
titleTextView.setText(getString(R.string.preferences_dialog_select_account_title));
TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
subtitleTextView.setText(getString(R.string.preferences_dialog_select_account_tips));
//设置标题以及子标题的内容
dialogBuilder.setCustomTitle(titleView);
dialogBuilder.setPositiveButton(null, null);
//设置对话框的自定义标题，建立一个YES的按钮
Account[] accounts = getGoogleAccounts();
String defAccount = getSyncAccountName(this);
//获取同步账户信息
mOriAccounts = accounts;
mHasAddedAccount = false;
if (accounts.length > 0) {
//若账户不为空
CharSequence[] items = new CharSequence[accounts.length];
final CharSequence[] itemMapping = items;
int checkedItem = -1;
@ -224,83 +289,119 @@ public class NotesPreferenceActivity extends PreferenceActivity {
for (Account account : accounts) {
if (TextUtils.equals(account.name, defAccount)) {
checkedItem = index;
//在账户列表中查询到所需账户
}
items[index++] = account.name;
}
dialogBuilder.setSingleChoiceItems(items, checkedItem,
//在对话框建立一个单选的复选框
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
setSyncAccount(itemMapping[which].toString());
dialog.dismiss();
//取消对话框
refreshUI();
}
//设置点击后执行的事件，包括检录新同步账户和刷新标签界面
});
//建立对话框网络版的监听器
}
View addAccountView = LayoutInflater.from(this).inflate(R.layout.add_account_text, null);
dialogBuilder.setView(addAccountView);
//给新加账户对话框设置自定义样式
final AlertDialog dialog = dialogBuilder.show();
//显示对话框
addAccountView.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
mHasAddedAccount = true;
//将新加账户的hash置true
Intent intent = new Intent("android.settings.ADD_ACCOUNT_SETTINGS");
//建立网络建立组件
intent.putExtra(AUTHORITIES_FILTER_KEY, new String[] {
"gmail-ls"
"gmail-ls"
});
startActivityForResult(intent, -1);
//跳回上一个选项
dialog.dismiss();
}
});
//建立新加账户对话框的监听器
}
/**
* @method showChangeAccountConfirmAlertDialog
* @description 显示账户选择对话框和相关账户操作
*/
private void showChangeAccountConfirmAlertDialog() {
AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
//创建一个新的对话框
View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
titleTextView.setText(getString(R.string.preferences_dialog_change_account_title,
getSyncAccountName(this)));
TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
subtitleTextView.setText(getString(R.string.preferences_dialog_change_account_warn_msg));
//根据同步修改的账户信息设置标题以及子标题的内容
dialogBuilder.setCustomTitle(titleView);
//设置对话框的自定义标题
CharSequence[] menuItemArray = new CharSequence[] {
getString(R.string.preferences_menu_change_account),
getString(R.string.preferences_menu_remove_account),
getString(R.string.preferences_menu_cancel)
};
//定义一些标记字符串
dialogBuilder.setItems(menuItemArray, new DialogInterface.OnClickListener() {
//设置对话框要显示的一个list，用于显示几个命令时,即change，remove，cancel
public void onClick(DialogInterface dialog, int which) {
//按键功能，由which来决定
if (which == 0) {
//进入账户选择对话框
showSelectAccountAlertDialog();
} else if (which == 1) {
//删除账户并且跟新便签界面
removeSyncAccount();
refreshUI();
}
}
});
dialogBuilder.show();
//显示对话框
}
/**
* @method getGoogleAccounts
* @description 获取谷歌账户
*/
private Account[] getGoogleAccounts() {
AccountManager accountManager = AccountManager.get(this);
return accountManager.getAccountsByType("com.google");
//通过账户管理器直接获取
}
/**
* @method setSyncAccount
* @description 设置同步账户
*/
private void setSyncAccount(String account) {
if (!getSyncAccountName(this).equals(account)) {
//假如该账号不在同步账号列表中
SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
//编辑共享的首选项
if (account != null) {
editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, account);
} else {
editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
}
//将该账号加入到首选项中
editor.commit();
//提交修改的数据
// clean up last sync time
setLastSyncTime(this, 0);
//将最后同步时间清零
// clean up local gtask related info
new Thread(new Runnable() {
@ -311,23 +412,34 @@ public class NotesPreferenceActivity extends PreferenceActivity {
getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
}
}).start();
//重置当地同步任务的信息
Toast.makeText(NotesPreferenceActivity.this,
getString(R.string.preferences_toast_success_set_accout, account),
Toast.LENGTH_SHORT).show();
//将toast的文本信息置为“设置账户成功”并显示出来
}
}
/**
* @method removeSyncAccount
* @description 删除同步账户
*/
private void removeSyncAccount() {
SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
//设置共享首选项
if (settings.contains(PREFERENCE_SYNC_ACCOUNT_NAME)) {
editor.remove(PREFERENCE_SYNC_ACCOUNT_NAME);
//假如当前首选项中有账户就删除
}
if (settings.contains(PREFERENCE_LAST_SYNC_TIME)) {
editor.remove(PREFERENCE_LAST_SYNC_TIME);
//删除当前首选项中有账户时间
}
editor.commit();
//提交更新后的数据
// clean up local gtask related info
new Thread(new Runnable() {
@ -338,49 +450,80 @@ public class NotesPreferenceActivity extends PreferenceActivity {
getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
}
}).start();
//重置当地同步任务的信息
}
/**
* @method getSyncAccountName
* @description 获取同步账户名称
*/
public static String getSyncAccountName(Context context) {
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE);
//通过共享的首选项里的信息直接获取
return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
}
/**
* @method setLastSyncTime
* @description 设置最终同步的时间
*/
public static void setLastSyncTime(Context context, long time) {
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
// 从共享首选项中找到相关账户并获取其编辑器
editor.putLong(PREFERENCE_LAST_SYNC_TIME, time);
editor.commit();
//编辑最终同步时间并提交更新
}
/**
* @method getLastSyncTime
* @description 获取最终同步时间
*/
public static long getLastSyncTime(Context context) {
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE);
//通过共享的首选项里的信息直接获取
return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);
}
/**
* @method
* @description 接受同步信息
*/
private class GTaskReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
refreshUI();
if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {
//获取随广播而来的Intent中的同步服务的数据
TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
syncStatus.setText(intent
.getStringExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_PROGRESS_MSG));
//通过获取的数据在设置系统的状态
}
}
}
/**
* @method onOptionsItemSelected
* @description 处理菜单的选项
* @param *MenuItem菜单选项
*/
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
//根据选项的id选择，这里只有一个主页
case android.R.id.home:
Intent intent = new Intent(this, NotesListActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);
return true;
//在主页情况下在创建连接组件intent，发出清空的信号并开始一个相应的activity
default:
return false;
}

Write Preview
Loading…
Cancel
Save