当前位置：首页 > news >正文

小米便签——ui包详细解读

news 2025/11/26 23:26:11

目录

ui:用户界面类

1 AlarmAlertActivity

2 AlarmInitReceiver

3 AlarmReceiver

4 DateTimePicker

5 DateTimePickerDialog

6 DropdownMenu

7 FoldersListAdapter

8 NoteEditActivity

9 NoteltemData

10 NotesListActivity

11 NoteEditText

12 NotesListAdapter

13 NotesListltem

14 NotesPreferenceActivity

ui:用户界面类

AlarmAlertActivity:闹钟提醒界面
AlarmmlnitReceiver:闹钟提醒启动消息接收器
AlarmReceiver:闹钟提醒接收器
DataTimePicker:设置提醒时间的部件
DataTimePickerDialog:设置提醒时间的对话框界面
DropdownMenu:下拉菜单界面
FoldersListAdapter:文件夹列表链接器(链接数据库)
NoteEditAcfvity:便签编辑活动
NoteEditText:便签的文本编辑界面
NoteltemData:便签项数据
NoteUstActivity:主界面，实现处理文件列表的活动

NoteUstAdapter:便签列表链接器(链接数据库)
NoteUstltem:便签列表项
NotePreferenceActivity:便签同步的设置界面

1 AlarmAlertActivity

package net.micode.notes.ui; // 定义了该类的包路径import android.app.Activity; // 导入Activity类，用于创建Android活动
import android.app.AlertDialog; // 导入AlertDialog类，用于创建对话框
import android.content.Context; // 导入Context类，用于获取应用程序环境
import android.content.DialogInterface; // 导入DialogInterface类，用于处理对话框事件
import android.content.DialogInterface.OnClickListener; // 导入OnClickListener接口，用于处理对话框按钮点击事件
import android.content.DialogInterface.OnDismissListener; // 导入OnDismissListener接口，用于处理对话框关闭事件
import android.content.Intent; // 导入Intent类，用于启动活动和传递数据
import android.media.AudioManager; // 导入AudioManager类，用于管理音频设置
import android.media.MediaPlayer; // 导入MediaPlayer类，用于播放音频
import android.media.RingtoneManager; // 导入RingtoneManager类，用于获取铃声
import android.net.Uri; // 导入Uri类，用于表示资源路径
import android.os.Bundle; // 导入Bundle类，用于保存活动状态
import android.os.PowerManager; // 导入PowerManager类，用于管理电源设置
import android.provider.Settings; // 导入Settings类，用于获取系统设置
import android.view.Window; // 导入Window类，用于管理窗口
import android.view.WindowManager; // 导入WindowManager类，用于管理窗口标志import net.micode.notes.R; // 导入应用内部定义的资源类
import net.micode.notes.data.Notes; // 导入应用内部定义的笔记数据类
import net.micode.notes.tool.DataUtils; // 导入应用内部定义的数据工具类import java.io.IOException; // 导入IOException类，用于处理输入输出异常public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener { // 定义AlarmAlertActivity类，继承自Activity，并实现OnClickListener和OnDismissListener接口private long mNoteId; // 定义笔记的IDprivate String mSnippet; // 定义笔记内容的简短预览private static final int SNIPPET_PREW_MAX_LEN = 60; // 定义预览文本的最大长度private MediaPlayer mPlayer; // 定义用于播放提醒声音的MediaPlayer对象@Overrideprotected void onCreate(Bundle savedInstanceState) { // 重写onCreate方法，在活动创建时调用super.onCreate(savedInstanceState); // 调用父类的onCreate方法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)); // 从意图中获取笔记IDmSnippet = DataUtils.getSnippetById(this.getContentResolver(), mNoteId); // 获取笔记内容的简短预览mSnippet = mSnippet.length() > SNIPPET_PREW_MAX_LEN ? mSnippet.substring(0, // 如果预览文本长度超过最大长度，则截取SNIPPET_PREW_MAX_LEN) + getResources().getString(R.string.notelist_string_info): mSnippet; // 否则使用原始预览文本} catch (IllegalArgumentException e) { // 捕获非法参数异常e.printStackTrace(); // 打印异常信息return; // 返回}mPlayer = new MediaPlayer(); // 创建MediaPlayer对象if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) { // 检查笔记在数据库中是否可见showActionDialog(); // 显示动作对话框playAlarmSound(); // 播放提醒声音} else {finish(); // 结束活动}}private boolean isScreenOn() { // 定义检查屏幕是否处于打开状态的方法PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE); // 获取电源管理服务return pm.isScreenOn(); // 返回屏幕是否处于打开状态}private void playAlarmSound() { // 定义播放提醒声音的方法Uri url = RingtoneManager.getActualDefaultRingtoneUri(this, RingtoneManager.TYPE_ALARM); // 获取默认的闹钟铃声URIint silentModeStreams = Settings.System.getInt(getContentResolver(), // 获取静音模式下影响的音频流Settings.System.MODE_RINGER_STREAMS_AFFECTED, 0);if ((silentModeStreams & (1 << AudioManager.STREAM_ALARM)) != 0) { // 检查闹钟音频流是否受静音模式影响mPlayer.setAudioStreamType(silentModeStreams); // 设置音频流类型} else {mPlayer.setAudioStreamType(AudioManager.STREAM_ALARM); // 设置音频流类型为闹钟}try {mPlayer.setDataSource(this, url); // 设置数据源mPlayer.prepare(); // 准备播放mPlayer.setLooping(true); // 设置循环播放mPlayer.start(); // 开始播放} catch (IllegalArgumentException e) { // 捕获非法参数异常e.printStackTrace(); // 打印异常信息} catch (SecurityException e) { // 捕获安全异常e.printStackTrace(); // 打印异常信息} catch (IllegalStateException e) { // 捕获非法状态异常e.printStackTrace(); // 打印异常信息} catch (IOException e) { // 捕获输入输出异常e.printStackTrace(); // 打印异常信息}}private void showActionDialog() { // 定义显示动作对话框的方法AlertDialog.Builder dialog = new AlertDialog.Builder(this); // 创建对话框构建器dialog.setTitle(R.string.app_name); // 设置对话框标题dialog.setMessage(mSnippet); // 设置对话框消息dialog.setPositiveButton(R.string.notealert_ok, this); // 设置正面按钮if (isScreenOn()) { // 检查屏幕是否处于打开状态dialog.setNegativeButton(R.string.notealert_enter, this); // 设置负面按钮}dialog.show().setOnDismissListener(this); // 显示对话框并设置关闭监听器}public void onClick(DialogInterface dialog, int which) { // 实现OnClickListener接口的onClick方法，处理对话框按钮点击事件switch (which) { // 根据按钮类型进行处理case DialogInterface.BUTTON_NEGATIVE: // 如果是负面按钮Intent intent = new Intent(this, NoteEditActivity.class); // 创建启动笔记编辑活动的意图intent.setAction(Intent.ACTION_VIEW); // 设置动作intent.putExtra(Intent.EXTRA_UID, mNoteId); // 传递笔记IDstartActivity(intent); // 启动活动break; // 结束处理default: // 默认情况break; // 结束处理}}public void onDismiss(DialogInterface dialog) { // 实现OnDismissListener接口的onDismiss方法，处理对话框关闭事件stopAlarmSound(); // 停止播放提醒声音finish(); // 结束活动}private void stopAlarmSound() { // 定义停止播放提醒声音的方法if (mPlayer != null) { // 检查MediaPlayer对象是否为空mPlayer.stop(); // 停止播放mPlayer.release(); // 释放资源mPlayer = null; // 将MediaPlayer对象设置为空}}
}

2 AlarmInitReceiver

/** 该类是广播接收器，用于在应用启动时初始化提醒设置。* 当系统启动时，它会检查数据库中所有设置了提醒的笔记，并为每个笔记设置相应的提醒。*/
package net.micode.notes.ui; // 定义该类的包路径import android.app.AlarmManager; // 导入AlarmManager类，用于设置提醒
import android.app.PendingIntent; // 导入PendingIntent类，用于延迟执行意图
import android.content.BroadcastReceiver; // 导入BroadcastReceiver类，用于接收广播
import android.content.ContentUris; // 导入ContentUris类，用于处理URI
import android.content.Context; // 导入Context类，用于获取应用环境
import android.content.Intent; // 导入Intent类，用于启动活动和传递数据
import android.database.Cursor; // 导入Cursor类，用于查询数据库import net.micode.notes.data.Notes; // 导入应用内部定义的笔记数据类
import net.micode.notes.data.Notes.NoteColumns; // 导入笔记数据类的列定义public class AlarmInitReceiver extends BroadcastReceiver { // 定义AlarmInitReceiver类，继承自BroadcastReceiver// 查询笔记时需要的列private static final String[] PROJECTION = new String[]{NoteColumns.ID, // 笔记IDNoteColumns.ALERTED_DATE // 提醒日期};// 列的索引private static final int COLUMN_ID = 0; // ID列的索引private static final int COLUMN_ALERTED_DATE = 1; // 提醒日期列的索引/*** 当接收到广播时执行的操作。主要用于设置所有已记录的提醒时间。** @param context 上下文，提供访问应用全局功能的入口。* @param intent  携带了触发该接收器的广播信息。*/@Overridepublic void onReceive(Context context, Intent intent) { // 重写onReceive方法，当接收到广播时执行// 获取当前日期和时间long currentDate = System.currentTimeMillis(); // 获取当前时间戳// 查询数据库中所有需要提醒的笔记Cursor c = context.getContentResolver().query(Notes.CONTENT_NOTE_URI, // 查询笔记内容的URIPROJECTION, // 查询的列NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE, // 查询条件new String[]{String.valueOf(currentDate)}, // 查询参数null); // 排序方式if (c != null) { // 检查Cursor是否为空// 遍历查询结果，为每个需要提醒的笔记设置提醒if (c.moveToFirst()) { // 移动到第一行do {// 获取提醒日期long alertDate = c.getLong(COLUMN_ALERTED_DATE); // 获取提醒日期// 创建Intent，用于在提醒时间触发AlarmReceiverIntent sender = new Intent(context, AlarmReceiver.class); // 创建启动AlarmReceiver的意图sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(COLUMN_ID))); // 设置意图的数据URI// 创建PendingIntent，它是一个延迟的意图，可以在特定时间由系统触发PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, 0); // 创建PendingIntent// 获取AlarmManager服务，用于设置提醒AlarmManager alermManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE); // 获取AlarmManager服务// 设置提醒alermManager.set(AlarmManager.RTC_WAKEUP, alertDate, pendingIntent); // 设置提醒时间} while (c.moveToNext()); // 移动到下一行}// 关闭Cursor，释放资源c.close(); // 关闭Cursor}}
}

3 AlarmReceiver

/** AlarmReceiver类 - 用于处理闹钟广播接收* 当接收到闹钟相关的广播时，该类会启动一个指定的Activity** extends BroadcastReceiver: 继承自Android的BroadcastReceiver类*/
package net.micode.notes.ui; // 定义该类的包路径import android.content.BroadcastReceiver; // 导入BroadcastReceiver类，用于接收广播
import android.content.Context; // 导入Context类，用于获取应用环境
import android.content.Intent; // 导入Intent类，用于启动活动和传递数据public class AlarmReceiver extends BroadcastReceiver { // 定义AlarmReceiver类，继承自BroadcastReceiver/** onReceive方法 - 系统调用的接收广播的方法* 当接收到广播时，该方法会被调用，然后启动AlarmAlertActivity** @param context 上下文对象，提供了调用环境的信息* @param intent  包含广播的内容*/@Overridepublic void onReceive(Context context, Intent intent) { // 重写onReceive方法，当接收到广播时执行// 设置Intent的类，以便启动AlarmAlertActivityintent.setClass(context, AlarmAlertActivity.class); // 设置Intent的目标Activity为AlarmAlertActivity// 添加标志，表示在一个新的任务中启动Activityintent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); // 添加标志，确保Activity在一个新的任务中启动// 根据设置的Intent启动Activitycontext.startActivity(intent); // 启动AlarmAlertActivity}
}

4 DateTimePicker

package net.micode.notes.ui;import java.text.DateFormatSymbols;
import java.util.Calendar;import net.micode.notes.R;import android.content.Context;
import android.text.format.DateFormat;
import android.view.View;
import android.widget.FrameLayout;
import android.widget.NumberPicker;public class DateTimePicker extends FrameLayout {// 默认启用状态private static final boolean DEFAULT_ENABLE_STATE = true;// 半天的小时数private static final int HOURS_IN_HALF_DAY = 12;// 一整天的小时数private static final int HOURS_IN_ALL_DAY = 24;// 一周的天数private static final int DAYS_IN_ALL_WEEK = 7;// 日期选择器的最小值private static final int DATE_SPINNER_MIN_VAL = 0;// 日期选择器的最大值private static final int DATE_SPINNER_MAX_VAL = DAYS_IN_ALL_WEEK - 1;// 24小时制小时选择器的最小值private static final int HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW = 0;// 24小时制小时选择器的最大值private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23;// 12小时制小时选择器的最小值private static final int HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW = 1;// 12小时制小时选择器的最大值private static final int HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW = 12;// 分钟选择器的最小值private static final int MINUT_SPINNER_MIN_VAL = 0;// 分钟选择器的最大值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;// 当前日期private Calendar mDate;// 用于显示日期的字符串数组private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];// 当前是否为上午private boolean mIsAm;// 当前是否为24小时制视图private boolean mIs24HourView;// 控件是否启用private boolean mIsEnabled = DEFAULT_ENABLE_STATE;// 是否正在初始化private boolean mInitialising;// 日期时间改变监听器private OnDateTimeChangedListener mOnDateTimeChangedListener;// 日期选择器的值改变监听器private NumberPicker.OnValueChangeListener mOnDateChangedListener = new NumberPicker.OnValueChangeListener() {@Overridepublic void onValueChange(NumberPicker picker, int oldVal, int newVal) {// 根据新旧值的差异更新日期mDate.add(Calendar.DAY_OF_YEAR, newVal - oldVal);updateDateControl();onDateTimeChanged();}};// 小时选择器的值改变监听器private NumberPicker.OnValueChangeListener mOnHourChangedListener = new NumberPicker.OnValueChangeListener() {@Overridepublic void onValueChange(NumberPicker picker, int oldVal, int newVal) {// 根据小时的变化更新日期和上下午状态boolean isDateChanged = false;Calendar cal = Calendar.getInstance();if (!mIs24HourView) {// 处理12小时制下的日期变化和上下午切换if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) {cal.setTimeInMillis(mDate.getTimeInMillis());cal.add(Calendar.DAY_OF_YEAR, 1);isDateChanged = true;} 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;}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();}} else {// 处理24小时制下的日期变化if (oldVal == HOURS_IN_ALL_DAY - 1 && newVal == 0) {cal.setTimeInMillis(mDate.getTimeInMillis());cal.add(Calendar.DAY_OF_YEAR, 1);isDateChanged = true;} else if (oldVal == 0 && newVal == HOURS_IN_ALL_DAY - 1) {cal.setTimeInMillis(mDate.getTimeInMillis());cal.add(Calendar.DAY_OF_YEAR, -1);isDateChanged = true;}}// 更新小时并触发日期时间改变事件int newHour = mHourSpinner.getValue() % HOURS_IN_HALF_DAY + (mIsAm ? 0 : HOURS_IN_HALF_DAY);mDate.set(Calendar.HOUR_OF_DAY, newHour);onDateTimeChanged();// 如果日期有变化，则更新年月日if (isDateChanged) {setCurrentYear(cal.get(Calendar.YEAR));setCurrentMonth(cal.get(Calendar.MONTH));setCurrentDay(cal.get(Calendar.DAY_OF_MONTH));}}};// 分别为分钟和AM/PM选择器监听器设置匿名内部类，实现数值变化时的处理逻辑。private NumberPicker.OnValueChangeListener mOnMinuteChangedListener = new NumberPicker.OnValueChangeListener() {@Overridepublic void onValueChange(NumberPicker picker, int oldVal, int newVal) {// 计算小时的偏移量，当从最大值变为最小值或从最小值变为最大值时调整int minValue = mMinuteSpinner.getMinValue();int maxValue = mMinuteSpinner.getMaxValue();int offset = 0;if (oldVal == maxValue && newVal == minValue) {offset += 1;} else if (oldVal == minValue && newVal == maxValue) {offset -= 1;}// 根据偏移量更新日期和小时选择器，并检查是否需要切换AM/PMif (offset != 0) {mDate.add(Calendar.HOUR_OF_DAY, offset);mHourSpinner.setValue(getCurrentHour());updateDateControl();int newHour = getCurrentHourOfDay();if (newHour >= HOURS_IN_HALF_DAY) {mIsAm = false;updateAmPmControl();} else {mIsAm = true;updateAmPmControl();}}// 更新分钟值并触发日期变化的回调mDate.set(Calendar.MINUTE, newVal);onDateTimeChanged();}};private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() {@Overridepublic void onValueChange(NumberPicker picker, int oldVal, int newVal) {// 切换AM/PM状态，并更新日期和AM/PM选择器mIsAm = !mIsAm;if (mIsAm) {mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY);} else {mDate.add(Calendar.HOUR_OF_DAY, HOURS_IN_HALF_DAY);}updateAmPmControl();onDateTimeChanged();}};// 定义日期时间变化的回调接口public interface OnDateTimeChangedListener {void onDateTimeChanged(DateTimePicker view, int year, int month,int dayOfMonth, int hourOfDay, int minute);}// 构造函数：初始化日期时间选择器public DateTimePicker(Context context) {this(context, System.currentTimeMillis());}// 构造函数：指定初始日期时间public DateTimePicker(Context context, long date) {this(context, date, DateFormat.is24HourFormat(context));}// 构造函数：指定是否使用24小时制视图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);// 初始化日期、小时、分钟和AM/PM选择器，并设置相应的监听器mDateSpinner = (NumberPicker) findViewById(R.id.date);mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL);mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL);mDateSpinner.setOnValueChangedListener(mOnDateChangedListener);mHourSpinner = (NumberPicker) findViewById(R.id.hour);mHourSpinner.setOnValueChangedListener(mOnHourChangedListener);mMinuteSpinner = (NumberPicker) findViewById(R.id.minute);mMinuteSpinner.setMinValue(MINUT_SPINNER_MIN_VAL);mMinuteSpinner.setMaxValue(MINUT_SPINNER_MAX_VAL);mMinuteSpinner.setOnLongPressUpdateInterval(100);mMinuteSpinner.setOnValueChangedListener(mOnMinuteChangedListener);String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings();mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm);mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL);mAmPmSpinner.setMaxValue(AMPM_SPINNER_MAX_VAL);mAmPmSpinner.setDisplayedValues(stringsForAmPm);mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener);// 更新控件至初始状态updateDateControl();updateHourControl();updateAmPmControl();set24HourView(is24HourView);// 设置为当前时间setCurrentDate(date);setEnabled(isEnabled());// 设置内容描述mInitialising = false;}/*** 设置控件的启用状态。* 如果当前状态与传入状态相同，则不进行任何操作。* 启用或禁用日期和时间选择器，并更新内部启用状态。** @param enabled 控件是否启用*/@Overridepublic void setEnabled(boolean enabled) {if (mIsEnabled == enabled) {return;}super.setEnabled(enabled);// 同时启用或禁用日期和时间选择器mDateSpinner.setEnabled(enabled);mMinuteSpinner.setEnabled(enabled);mHourSpinner.setEnabled(enabled);mAmPmSpinner.setEnabled(enabled);mIsEnabled = enabled;}/*** 获取控件的启用状态。** @return 控件是否启用*/@Overridepublic boolean isEnabled() {return mIsEnabled;}/*** 获取当前日期的时间戳（毫秒）。** @return 当前日期的毫秒时间戳*/public long getCurrentDateInTimeMillis() {return mDate.getTimeInMillis();}/*** 设置当前日期。* 根据传入的毫秒时间戳更新日期选择器的值。** @param date The current date in millis*/public void setCurrentDate(long date) {Calendar cal = Calendar.getInstance();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));}/*** 设置当前日期和时间。* 分别设置年、月、日、时和分。** @param year       当前年份* @param month      当前月份* @param dayOfMonth 当前日* @param hourOfDay  当前小时* @param minute     当前分钟*/public void setCurrentDate(int year, int month,int dayOfMonth, int hourOfDay, int minute) {// 分别设置年、月、日、时和分setCurrentYear(year);setCurrentMonth(month);setCurrentDay(dayOfMonth);setCurrentHour(hourOfDay);setCurrentMinute(minute);}/*** 获取当前年份** @return 当前的年份*/public int getCurrentYear() {return mDate.get(Calendar.YEAR);}/*** 设置当前年份** @param year 当前的年份*/public void setCurrentYear(int year) {// 如果不是初始化状态并且设置的年份与当前年份相同，则直接返回if (!mInitialising && year == getCurrentYear()) {return;}mDate.set(Calendar.YEAR, year);updateDateControl(); // 更新日期控件onDateTimeChanged(); // 触发日期时间改变事件}/*** 获取当前月份** @return 当前的月份（从0开始）*/public int getCurrentMonth() {return mDate.get(Calendar.MONTH);}/*** 设置当前月份** @param month 当前的月份（从0开始）*/public void setCurrentMonth(int month) {// 如果不是初始化状态并且设置的月份与当前月份相同，则直接返回if (!mInitialising && month == getCurrentMonth()) {return;}mDate.set(Calendar.MONTH, month);updateDateControl(); // 更新日期控件onDateTimeChanged(); // 触发日期时间改变事件}/*** 获取当前日期（月中的天数）** @return 当前的日期（月中的天数）*/public int getCurrentDay() {return mDate.get(Calendar.DAY_OF_MONTH);}/*** 设置当前日期（月中的天数）** @param dayOfMonth 当前的日期（月中的天数）*/public void setCurrentDay(int dayOfMonth) {// 如果不是初始化状态并且设置的日期与当前日期相同，则直接返回if (!mInitialising && dayOfMonth == getCurrentDay()) {return;}mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);updateDateControl(); // 更新日期控件onDateTimeChanged(); // 触发日期时间改变事件}/*** 获取当前小时（24小时制），范围为(0~23)** @return 当前的小时（24小时制）*/public int getCurrentHourOfDay() {return mDate.get(Calendar.HOUR_OF_DAY);}/*** 获取当前小时，根据是否为24小时制返回不同的值。* 如果是24小时制，与{@link #getCurrentHourOfDay()}返回相同结果；* 否则，将小时转换为12小时制，并考虑上午/下午。** @return 当前的小时（根据视图模式可能是12小时制）*/private int getCurrentHour() {if (mIs24HourView) {return getCurrentHourOfDay();} else {int hour = getCurrentHourOfDay();// 转换为12小时制if (hour > HOURS_IN_HALF_DAY) {return hour - HOURS_IN_HALF_DAY;} else {return hour == 0 ? HOURS_IN_HALF_DAY : hour;}}}/*** 设置当前小时（24小时制），范围为(0~23)** @param hourOfDay 当前小时数*/public void setCurrentHour(int hourOfDay) {// 如果在初始化中或者小时未改变，则直接返回if (!mInitialising && hourOfDay == getCurrentHourOfDay()) {return;}mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);// 如果不是24小时视图，则调整小时数并更新AM/PM控制if (!mIs24HourView) {if (hourOfDay >= HOURS_IN_HALF_DAY) {mIsAm = false;if (hourOfDay > HOURS_IN_HALF_DAY) {hourOfDay -= HOURS_IN_HALF_DAY;}} else {mIsAm = true;if (hourOfDay == 0) {hourOfDay = HOURS_IN_HALF_DAY;}}updateAmPmControl();}mHourSpinner.setValue(hourOfDay);onDateTimeChanged();}/*** 获取当前分钟数** @return 当前分钟数*/public int getCurrentMinute() {return mDate.get(Calendar.MINUTE);}/*** 设置当前分钟数** @param minute 当前分钟数值*/public void setCurrentMinute(int minute) {// 如果在初始化中或者分钟数未改变，则直接返回if (!mInitialising && minute == getCurrentMinute()) {return;}mMinuteSpinner.setValue(minute);mDate.set(Calendar.MINUTE, minute);onDateTimeChanged();}/*** 获取当前是否为24小时视图** @return 如果是24小时视图返回true，否则返回false*/public boolean is24HourView() {return mIs24HourView;}/*** 设置当前视图为24小时制还是AM/PM制** @param is24HourView 如果为true表示24小时制，false表示AM/PM制*/public void set24HourView(boolean is24HourView) {// 如果视图模式未改变，则直接返回if (mIs24HourView == is24HourView) {return;}mIs24HourView = is24HourView;mAmPmSpinner.setVisibility(is24HourView ? View.GONE : View.VISIBLE);int hour = getCurrentHourOfDay();updateHourControl();setCurrentHour(hour);updateAmPmControl();}/*** 更新日期控制组件，显示正确的日期选项*/private void updateDateControl() {Calendar cal = Calendar.getInstance();cal.setTimeInMillis(mDate.getTimeInMillis());cal.add(Calendar.DAY_OF_YEAR, -DAYS_IN_ALL_WEEK / 2 - 1);mDateSpinner.setDisplayedValues(null);// 循环设置一周内每一天的显示文本for (int i = 0; i < DAYS_IN_ALL_WEEK; ++i) {cal.add(Calendar.DAY_OF_YEAR, 1);mDateDisplayValues[i] = (String) DateFormat.format("MM.dd EEEE", cal);}mDateSpinner.setDisplayedValues(mDateDisplayValues);mDateSpinner.setValue(DAYS_IN_ALL_WEEK / 2);mDateSpinner.invalidate();}/*** 根据当前是否为24小时视图来更新AM/PM控制组件的显示和值*/private void updateAmPmControl() {if (mIs24HourView) {mAmPmSpinner.setVisibility(View.GONE);} else {int index = mIsAm ? Calendar.AM : Calendar.PM;mAmPmSpinner.setValue(index);mAmPmSpinner.setVisibility(View.VISIBLE);}}/*** 根据当前是否为24小时视图来更新小时控制组件的最小值和最大值*/private void updateHourControl() {if (mIs24HourView) {mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW);mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW);} else {mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW);mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW);}}/*** 设置点击“设置”按钮时的回调接口** @param callback 回调接口实例，如果为null则不执行任何操作*/public void setOnDateTimeChangedListener(OnDateTimeChangedListener callback) {mOnDateTimeChangedListener = callback;}/*** 当日期时间被改变时调用此方法，如果设置了日期时间改变监听器，则触发监听器的回调方法*/private void onDateTimeChanged() {if (mOnDateTimeChangedListener != null) {mOnDateTimeChangedListener.onDateTimeChanged(this, getCurrentYear(),getCurrentMonth(), getCurrentDay(), getCurrentHourOfDay(), getCurrentMinute());}}
}

5 DateTimePickerDialog

包声明：package net.micode.notes.ui; 声明了该类所在的包。
导入语句：导入了一系列Java和Android相关的类，包括日历、对话框、上下文、日期时间格式化等。
类声明：public class DateTimePickerDialog extends AlertDialog implements OnClickListener { 声明了一个名为 DateTimePickerDialog 的公共类，继承自 AlertDialog 并实现 OnClickListener 接口。
成员变量：
private Calendar mDate = Calendar.getInstance(); 声明了一个私有成员变量 mDate，用于存储当前选择的日期和时间。
private boolean mIs24HourView; 声明了一个私有成员变量 mIs24HourView，用于指示日期时间选择器是否使用24小时制。
private OnDateTimeSetListener mOnDateTimeSetListener; 声明了一个私有成员变量 mOnDateTimeSetListener，用于存储日期时间设置监听器。
private DateTimePicker mDateTimePicker; 声明了一个私有成员变量 mDateTimePicker，用于存储日期时间选择器视图。
接口声明：public interface OnDateTimeSetListener { ... } 声明了一个公共接口 OnDateTimeSetListener，用于处理日期时间被设置的事件。
构造函数：
public DateTimePickerDialog(Context context, long date) { ... } 声明了类的构造函数，接受上下文和初始日期时间值作为参数。
super(context); 调用父类构造函数。
mDateTimePicker = new DateTimePicker(context); 创建 DateTimePicker 实例。
setView(mDateTimePicker); 设置对话框视图为 DateTimePicker。
mDateTimePicker.setOnDateTimeChangedListener(new OnDateTimeChangedListener() { ... }); 设置日期时间改变的监听器。
mDate.setTimeInMillis(date); 设置初始日期时间。
mDate.set(Calendar.SECOND, 0); 设置秒数为0。
mDateTimePicker.setCurrentDate(mDate.getTimeInMillis()); 设置 DateTimePicker 的当前日期时间。
setButton(context.getString(R.string.datetime_dialog_ok), this); 设置对话框的确认按钮。
setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener) null); 设置对话框的取消按钮。
set24HourView(DateFormat.is24HourFormat(this.getContext())); 根据系统设置决定是否使用24小时制。
updateTitle(mDate.getTimeInMillis()); 更新标题以显示当前选择的日期和时间。
方法：
public void set24HourView(boolean is24HourView) { ... } 设置日期时间选择器是否使用24小时制。
public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) { ... } 设置日期时间被设置时的监听器。
private void updateTitle(long date) { ... } 更新对话框标题以显示当前选择的日期和时间。
public void onClick(DialogInterface arg0, int arg1) { ... } 点击按钮时的处理逻辑，如果设置了日期时间设置监听器，则调用其 OnDateTimeSet 方法。

/** DateTimePickerDialog类提供了一个日期和时间选择器对话框。* 用户可以选择一个日期和时间，然后通过监听器回调返回选择的值。*/
package net.micode.notes.ui; // 定义包名import java.util.Calendar; // 导入Calendar类，用于处理日期和时间import net.micode.notes.R; // 导入资源类，用于访问资源
import net.micode.notes.ui.DateTimePicker; // 导入DateTimePicker类，用于日期时间选择器视图
import net.micode.notes.ui.DateTimePicker.OnDateTimeChangedListener; // 导入日期时间改变监听器接口import android.app.AlertDialog; // 导入AlertDialog类，用于创建对话框
import android.content.Context; // 导入Context类，用于获取上下文
import android.content.DialogInterface; // 导入DialogInterface类，用于处理对话框事件
import android.content.DialogInterface.OnClickListener; // 导入OnClickListener接口，用于处理按钮点击事件
import android.text.format.DateFormat; // 导入DateFormat类，用于日期时间格式化
import android.text.format.DateUtils; // 导入DateUtils类，用于日期时间格式化public class DateTimePickerDialog extends AlertDialog implements OnClickListener { // 定义DateTimePickerDialog类，继承自AlertDialog并实现OnClickListener接口// 当前选择的日期和时间private Calendar mDate = Calendar.getInstance();// 用于指示日期时间选择器是否使用24小时制private boolean mIs24HourView;// 日期时间设置监听器，用于处理日期时间选择后的回调private OnDateTimeSetListener mOnDateTimeSetListener;// 日期时间选择器视图private DateTimePicker mDateTimePicker;/*** 日期时间设置监听器接口。* 实现此接口的类需要提供OnDateTimeSet方法来处理日期时间被设置的事件。*/public interface OnDateTimeSetListener {void OnDateTimeSet(AlertDialog dialog, long date);}/*** 构造函数初始化日期时间选择器对话框。** @param context 上下文对象，通常是指Activity。* @param date    初始显示的日期时间值。*/public DateTimePickerDialog(Context context, long date) {super(context); // 调用父类构造函数mDateTimePicker = new DateTimePicker(context); // 创建DateTimePicker实例setView(mDateTimePicker); // 设置对话框视图为DateTimePicker// 设置日期时间改变的监听器mDateTimePicker.setOnDateTimeChangedListener(new OnDateTimeChangedListener() {public void onDateTimeChanged(DateTimePicker view, int year, int month,int dayOfMonth, int hourOfDay, int minute) {// 更新内部日期时间值mDate.set(Calendar.YEAR, year);mDate.set(Calendar.MONTH, month);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); // 设置秒数为0mDateTimePicker.setCurrentDate(mDate.getTimeInMillis()); // 设置DateTimePicker的当前日期时间// 设置对话框的确认和取消按钮setButton(context.getString(R.string.datetime_dialog_ok), this);setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener) null);// 根据系统设置决定是否使用24小时制set24HourView(DateFormat.is24HourFormat(this.getContext()));// 更新标题以显示当前选择的日期和时间updateTitle(mDate.getTimeInMillis());}/*** 设置日期时间选择器是否使用24小时制。** @param is24HourView 是否使用24小时制。*/public void set24HourView(boolean is24HourView) {mIs24HourView = is24HourView;}/*** 设置日期时间被设置时的监听器。** @param callBack 日期时间设置监听器对象。*/public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) {mOnDateTimeSetListener = callBack;}/*** 更新对话框标题以显示当前选择的日期和时间。** @param date 当前选择的日期时间值。*/private void updateTitle(long date) {// 根据是否使用24小时制来格式化日期时间显示int flag =DateUtils.FORMAT_SHOW_YEAR |DateUtils.FORMAT_SHOW_DATE |DateUtils.FORMAT_SHOW_TIME;flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_24HOUR;setTitle(DateUtils.formatDateTime(this.getContext(), date, flag));}/*** 点击按钮时的处理逻辑。* 如果设置了日期时间设置监听器，则调用其OnDateTimeSet方法，传入当前选择的日期时间值。** @param arg0 对话框对象。* @param arg1 按钮标识。*/public void onClick(DialogInterface arg0, int arg1) {if (mOnDateTimeSetListener != null) {mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis());}}}

6 DropdownMenu

包声明：package net.micode.notes.ui; 声明了该类所在的包。
导入语句：导入了一系列Android相关的类，包括上下文、菜单、视图、按钮、弹出菜单等。
类声明：public class DropdownMenu { 声明了一个名为 DropdownMenu 的公共类。
成员变量：
private Button mButton; 声明了一个私有成员变量 mButton，用于存储按钮实例。
private PopupMenu mPopupMenu; 声明了一个私有成员变量 mPopupMenu，用于存储弹出菜单实例。
private Menu mMenu; 声明了一个私有成员变量 mMenu，用于存储菜单项集合。
构造函数：
public DropdownMenu(Context context, Button button, int menuId) { 声明了类的构造函数，接受上下文、按钮和菜单资源ID作为参数。
mButton = button; 初始化按钮。
mButton.setBackgroundResource(R.drawable.dropdown_icon); 设置按钮背景为下拉图标。
mPopupMenu = new PopupMenu(context, mButton); 创建 PopupMenu 实例，锚点为按钮。
mMenu = mPopupMenu.getMenu(); 获取菜单项的集合。
mPopupMenu.getMenuInflater().inflate(menuId, mMenu); 加载菜单项。
mButton.setOnClickListener(new OnClickListener() { ... }); 设置按钮点击事件，点击后显示下拉菜单。
方法：
public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) { ... } 设置下拉菜单项的点击事件监听器。
public MenuItem findItem(int id) { ... } 根据ID查找菜单项。
public void setTitle(CharSequence title) { ... } 设置按钮的标题。

/** DropdownMenu类用于创建和管理一个下拉菜单。* 该类封装了一个Button和一个PopupMenu，通过点击Button来显示下拉菜单。*/
package net.micode.notes.ui; // 定义包名import android.content.Context; // 导入Context类，用于获取上下文
import android.view.Menu; // 导入Menu类，用于管理菜单项
import android.view.MenuItem; // 导入MenuItem类，用于表示菜单项
import android.view.View; // 导入View类，用于处理视图
import android.view.View.OnClickListener; // 导入OnClickListener接口，用于处理点击事件
import android.widget.Button; // 导入Button类，用于创建按钮
import android.widget.PopupMenu; // 导入PopupMenu类，用于创建弹出菜单
import android.widget.PopupMenu.OnMenuItemClickListener; // 导入OnMenuItemClickListener接口，用于处理菜单项点击事件import net.micode.notes.R; // 导入资源类，用于访问资源public class DropdownMenu { // 定义DropdownMenu类private Button mButton; // 弹出下拉菜单的按钮private PopupMenu mPopupMenu; // 弹出的下拉菜单private Menu mMenu; // 下拉菜单的项目集合/*** DropdownMenu的构造函数。** @param context 上下文对象，通常是指Activity。* @param button  用于触发下拉菜单显示的按钮。* @param menuId  菜单资源ID，用于加载下拉菜单的项目。*/public DropdownMenu(Context context, Button button, int menuId) {mButton = button; // 初始化按钮mButton.setBackgroundResource(R.drawable.dropdown_icon); // 设置按钮背景为下拉图标mPopupMenu = new PopupMenu(context, mButton); // 创建PopupMenu实例，锚点为按钮mMenu = mPopupMenu.getMenu(); // 获取菜单项的集合mPopupMenu.getMenuInflater().inflate(menuId, mMenu); // 加载菜单项// 设置按钮点击事件，点击后显示下拉菜单mButton.setOnClickListener(new OnClickListener() {public void onClick(View v) {mPopupMenu.show(); // 显示下拉菜单}});}/*** 设置下拉菜单项的点击事件监听器。** @param listener PopupMenu的OnMenuItemClickListener，用于监听菜单项的点击事件。*/public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {if (mPopupMenu != null) {mPopupMenu.setOnMenuItemClickListener(listener); // 设置菜单项点击监听器}}/*** 根据ID查找菜单项。** @param id 菜单项的ID。* @return 返回找到的MenuItem对象，如果未找到则返回null。*/public MenuItem findItem(int id) {return mMenu.findItem(id); // 根据ID查找菜单项}/*** 设置按钮的标题。** @param title 按钮要显示的标题。*/public void setTitle(CharSequence title) {mButton.setText(title); // 设置按钮显示的文本}
}

7 FoldersListAdapter

包声明：package net.micode.notes.ui; 声明了该类所在的包。
导入语句：导入了一系列Java和Android相关的类，包括上下文、游标、视图、适配器、布局、文本显示等。
类声明：public class FoldersListAdapter extends CursorAdapter { 声明了一个名为 FoldersListAdapter 的公共类，继承自 CursorAdapter。
常量声明：
public static final String[] PROJECTION = { ... }; 声明了一个公共静态最终的字符串数组 PROJECTION，用于查询时使用的列名。
public static final int ID_COLUMN = 0; 声明了一个公共静态最终的整数 ID_COLUMN，表示ID列的索引。
public static final int NAME_COLUMN = 1; 声明了一个公共静态最终的整数 NAME_COLUMN，表示名称列的索引。
构造函数：
public FoldersListAdapter(Context context, Cursor c) { ... } 声明了类的构造函数，接受上下文和数据源游标作为参数，并调用父类构造函数。
方法：
@Override public View newView(Context context, Cursor cursor, ViewGroup parent) { ... } 重写了 newView 方法，用于创建新的列表项视图，返回 FolderListItem 实例。
@Override public void bindView(View view, Context context, Cursor cursor) { ... } 重写了 bindView 方法，用于绑定数据到已有的视图上，根据文件夹ID设置文件夹名称。
public String getFolderName(Context context, int position) { ... } 声明了一个公共方法 getFolderName，用于根据位置获取文件夹名称。
内部类：
private class FolderListItem extends LinearLayout { ... } 声明了一个私有内部类 FolderListItem，继承自 LinearLayout，用于表示文件夹列表中的一个项的视图。
public FolderListItem(Context context) { ... } 声明了 FolderListItem 的构造函数，加载布局文件并初始化文件夹名称的文本视图。
public void bind(String name) { ... } 声明了一个公共方法 bind，用于绑定文件夹名称到视图上。

/** FoldersListAdapter 类* 用于管理和适配文件夹列表的适配器，继承自 CursorAdapter。*/package net.micode.notes.ui; // 定义包名// 导入相关类
import android.content.Context; // 导入Context类，用于获取上下文
import android.database.Cursor; // 导入Cursor类，用于数据源游标
import android.view.View; // 导入View类，用于视图
import android.view.ViewGroup; // 导入ViewGroup类，用于视图的父容器
import android.widget.CursorAdapter; // 导入CursorAdapter类，用于适配器
import android.widget.LinearLayout; // 导入LinearLayout类，用于布局
import android.widget.TextView; // 导入TextView类，用于文本显示import net.micode.notes.R; // 导入资源类，用于访问资源
import net.micode.notes.data.Notes; // 导入Notes类，用于数据操作
import net.micode.notes.data.Notes.NoteColumns; // 导入NoteColumns类，用于数据列名public class FoldersListAdapter extends CursorAdapter { // 定义FoldersListAdapter类，继承自CursorAdapter// 查询时使用的列名数组public static final String[] PROJECTION = {NoteColumns.ID, // 文件夹ID列NoteColumns.SNIPPET // 文件夹名称列};// 列名数组中的索引常量public static final int ID_COLUMN = 0; // ID列索引public static final int NAME_COLUMN = 1; // 名称列索引/** 构造函数* @param context 上下文对象，通常指Activity或Application对象。* @param c 数据源游标Cursor。*/public FoldersListAdapter(Context context, Cursor c) {super(context, c); // 调用父类构造函数}/** 创建新的列表项View* @param context 上下文对象。* @param cursor 当前数据项的游标。* @param parent 视图的父容器。* @return 返回新创建的列表项View。*/@Overridepublic View newView(Context context, Cursor cursor, ViewGroup parent) {return new FolderListItem(context); // 返回新的FolderListItem实例}/** 绑定数据到已有的View上* @param view 要绑定数据的视图。* @param context 上下文对象。* @param cursor 当前数据项的游标。*/@Overridepublic void bindView(View view, Context context, Cursor cursor) {if (view instanceof FolderListItem) { // 判断视图是否为FolderListItem类型// 根据文件夹ID判断是根文件夹还是普通文件夹，并设置文件夹名称String folderName = (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context.getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);((FolderListItem) view).bind(folderName); // 绑定文件夹名称到视图}}/** 根据位置获取文件夹名称* @param context 上下文对象。* @param position 列表中的位置。* @return 返回该位置上文件夹的名称。*/public String getFolderName(Context context, int position) {Cursor cursor = (Cursor) getItem(position); // 获取指定位置的游标return (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context.getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN); // 返回文件夹名称}/** FolderListItem 内部类* 用于表示文件夹列表中的一个项的视图类。*/private class FolderListItem extends LinearLayout { // 定义FolderListItem内部类，继承自LinearLayoutprivate TextView mName; // 文件夹名称的文本视图/** 构造函数* @param context 上下文对象。*/public FolderListItem(Context context) {super(context); // 调用父类构造函数// 加载布局文件，并将自己作为根视图inflate(context, R.layout.folder_list_item, this);mName = (TextView) findViewById(R.id.tv_folder_name); // 获取文件夹名称的视图}/** 绑定数据到视图上* @param name 要显示的文件夹名称。*/public void bind(String name) {mName.setText(name); // 设置文件夹名称}}}

8 NoteEditActivity

package net.micode.notes.ui;import android.app.Activity;
import android.app.AlarmManager;
import android.app.AlertDialog;
import android.app.PendingIntent;
import android.app.SearchManager;
import android.appwidget.AppWidgetManager;
import android.content.ContentUris;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.graphics.Paint;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.text.Spannable;
import android.text.SpannableString;
import android.text.TextUtils;
import android.text.format.DateUtils;
import android.text.style.BackgroundColorSpan;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.WindowManager;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.CompoundButton.OnCheckedChangeListener;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;import net.micode.notes.R;
import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.TextNote;
import net.micode.notes.model.WorkingNote;
import net.micode.notes.model.WorkingNote.NoteSettingChangedListener;
import net.micode.notes.tool.DataUtils;
import net.micode.notes.tool.ResourceParser;
import net.micode.notes.tool.ResourceParser.TextAppearanceResources;
import net.micode.notes.ui.DateTimePickerDialog.OnDateTimeSetListener;
import net.micode.notes.ui.NoteEditText.OnTextViewChangeListener;
import net.micode.notes.widget.NoteWidgetProvider_2x;
import net.micode.notes.widget.NoteWidgetProvider_4x;import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;public class NoteEditActivity extends Activity implements OnClickListener,NoteSettingChangedListener, OnTextViewChangeListener {/*** 头部视图的ViewHolder类，用于存储头部视图中的UI组件引用。*/private class HeadViewHolder {public TextView tvModified; // 显示修改日期的文本视图public ImageView ivAlertIcon; // 提示图标图像视图public TextView tvAlertDate; // 显示提醒日期的文本视图public ImageView ibSetBgColor; // 设置背景颜色的图像视图}/*** 背景选择按钮与其对应选中状态图标的映射。*/private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<Integer, Integer>();static {// 初始化背景选择按钮映射sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW);sBgSelectorBtnsMap.put(R.id.iv_bg_red, ResourceParser.RED);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);}/*** 背景选择按钮选中状态与其对应图标的映射。*/private static final Map<Integer, Integer> sBgSelectorSelectionMap = new HashMap<Integer, Integer>();static {// 初始化背景选择按钮选中状态映射sBgSelectorSelectionMap.put(ResourceParser.YELLOW, R.id.iv_bg_yellow_select);sBgSelectorSelectionMap.put(ResourceParser.RED, R.id.iv_bg_red_select);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);}/*** 字号选择按钮与其对应字体大小的映射。*/private static final Map<Integer, Integer> sFontSizeBtnsMap = new HashMap<Integer, Integer>();static {// 初始化字号选择按钮映射sFontSizeBtnsMap.put(R.id.ll_font_large, ResourceParser.TEXT_LARGE);sFontSizeBtnsMap.put(R.id.ll_font_small, ResourceParser.TEXT_SMALL);sFontSizeBtnsMap.put(R.id.ll_font_normal, ResourceParser.TEXT_MEDIUM);sFontSizeBtnsMap.put(R.id.ll_font_super, ResourceParser.TEXT_SUPER);}/*** 字号选择按钮选中状态与其对应图标的映射。*/private static final Map<Integer, Integer> sFontSelectorSelectionMap = new HashMap<Integer, Integer>();static {// 初始化字号选择按钮选中状态映射sFontSelectorSelectionMap.put(ResourceParser.TEXT_LARGE, R.id.iv_large_select);sFontSelectorSelectionMap.put(ResourceParser.TEXT_SMALL, R.id.iv_small_select);sFontSelectorSelectionMap.put(ResourceParser.TEXT_MEDIUM, R.id.iv_medium_select);sFontSelectorSelectionMap.put(ResourceParser.TEXT_SUPER, R.id.iv_super_select);}private static final String TAG = "NoteEditActivity"; // 日志标签private HeadViewHolder mNoteHeaderHolder; // 头部视图的ViewHolderprivate View mHeadViewPanel; // 头部视图面板private View mNoteBgColorSelector; // 笔记背景颜色选择器private View mFontSizeSelector; // 字号选择器private EditText mNoteEditor; // 笔记编辑器private View mNoteEditorPanel; // 笔记编辑器面板private WorkingNote mWorkingNote; // 当前正在编辑的笔记private SharedPreferences mSharedPrefs; // 共享偏好设置private int mFontSizeId; // 当前选中的字体大小资源IDprivate static final String PREFERENCE_FONT_SIZE = "pref_font_size"; // 字体大小偏好设置键private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10; // 快捷图标标题的最大长度public static final String TAG_CHECKED = String.valueOf('\u221A'); // 标记为已检查的字符串public static final String TAG_UNCHECKED = String.valueOf('\u25A1'); // 标记为未检查的字符串private LinearLayout mEditTextList; // 编辑文本列表private String mUserQuery; // 用户查询字符串private Pattern mPattern; // 正则表达式模式@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);this.setContentView(R.layout.note_edit); // 设置活动的视图布局// 检查实例状态是否被保存，如果未保存且初始化活动状态失败，则结束该活动if (savedInstanceState == null && !initActivityState(getIntent())) {finish();return;}initResources(); // 初始化资源}/*** 当活动被系统销毁后，为了恢复之前的状态，此方法会被调用。* 主要用于处理活动重新创建时的数据恢复。** @param savedInstanceState 包含之前保存状态的Bundle，如果活动之前保存了状态，这里会传入非空的Bundle。*/@Overrideprotected void onRestoreInstanceState(Bundle savedInstanceState) {super.onRestoreInstanceState(savedInstanceState);// 检查是否有保存的状态并且包含必要的UID信息，用于恢复活动状态if (savedInstanceState != null && savedInstanceState.containsKey(Intent.EXTRA_UID)) {Intent intent = new Intent(Intent.ACTION_VIEW);intent.putExtra(Intent.EXTRA_UID, savedInstanceState.getLong(Intent.EXTRA_UID));// 使用intent尝试恢复活动状态，如果失败则结束该活动if (!initActivityState(intent)) {finish();return;}Log.d(TAG, "Restoring from killed activity"); // 日志记录，表示活动状态正在从被杀死的状态恢复}}/*** 初始化活动状态，根据传入的Intent确定是查看笔记、新建笔记还是编辑笔记。** @param intent 传入的Intent，包含了动作类型和相关数据。* @return boolean 返回true表示成功初始化活动状态，false表示初始化失败。*/private boolean initActivityState(Intent intent) {// 如果用户指定的是查看笔记的动作但未提供笔记ID，则跳转到笔记列表活动mWorkingNote = null;if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) {long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0);mUserQuery = "";// 从搜索结果开始if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) {noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY));mUserQuery = intent.getStringExtra(SearchManager.USER_QUERY);}// 检查指定的笔记在数据库中是否可见if (!DataUtils.visibleInNoteDatabase(getContentResolver(), noteId, Notes.TYPE_NOTE)) {Intent jump = new Intent(this, NotesListActivity.class);startActivity(jump);showToast(R.string.error_note_not_exist);finish();return false;} else {// 加载指定ID的笔记mWorkingNote = WorkingNote.load(this, noteId);if (mWorkingNote == null) {Log.e(TAG, "load note failed with note id" + noteId);finish();return false;}}// 隐藏软键盘getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN| WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);} else if (TextUtils.equals(Intent.ACTION_INSERT_OR_EDIT, 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);int widgetType = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_TYPE,Notes.TYPE_WIDGET_INVALIDE);int bgResId = intent.getIntExtra(Notes.INTENT_EXTRA_BACKGROUND_ID,ResourceParser.getDefaultBgId(this));// 解析通话记录笔记String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);long callDate = intent.getLongExtra(Notes.INTENT_EXTRA_CALL_DATE, 0);if (callDate != 0 && phoneNumber != null) {// 根据电话号码和通话日期尝试获取已有笔记IDif (TextUtils.isEmpty(phoneNumber)) {Log.w(TAG, "The call record number is null");}long noteId = 0;if ((noteId = DataUtils.getNoteIdByPhoneNumberAndCallDate(getContentResolver(),phoneNumber, callDate)) > 0) {// 加载该笔记mWorkingNote = WorkingNote.load(this, noteId);if (mWorkingNote == null) {Log.e(TAG, "load call note failed with note id" + noteId);finish();return false;}} else {// 创建新的通话记录笔记mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId,widgetType, bgResId);mWorkingNote.convertToCallNote(phoneNumber, callDate);}} else {// 创建普通空笔记mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId, widgetType,bgResId);}// 显示软键盘getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE| WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);} else {// 不支持的Intent动作Log.e(TAG, "Intent not specified action, should not support");finish();return false;}// 设置笔记状态改变的监听器mWorkingNote.setOnSettingStatusChangedListener(this);return true;}/*** 当Activity恢复到前台时调用。* 主要负责初始化笔记界面。*/@Overrideprotected void onResume() {super.onResume();initNoteScreen();}/*** 初始化笔记界面的函数。* 该函数设置笔记编辑器的外观，根据笔记类型切换到相应的模式，设置背景和头部信息，* 以及处理提醒头部的显示。*/private void initNoteScreen() {// 设置编辑器的文本外观mNoteEditor.setTextAppearance(this, TextAppearanceResources.getTexAppearanceResource(mFontSizeId));// 根据当前笔记的类型，切换到列表模式或高亮查询结果模式if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {switchToListMode(mWorkingNote.getContent());} else {mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));mNoteEditor.setSelection(mNoteEditor.getText().length());}// 隐藏所有背景选择器for (Integer id : sBgSelectorSelectionMap.keySet()) {findViewById(sBgSelectorSelectionMap.get(id)).setVisibility(View.GONE);}// 设置标题和编辑区域的背景mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());// 设置修改时间mNoteHeaderHolder.tvModified.setText(DateUtils.formatDateTime(this,mWorkingNote.getModifiedDate(), DateUtils.FORMAT_SHOW_DATE| DateUtils.FORMAT_NUMERIC_DATE | DateUtils.FORMAT_SHOW_TIME| DateUtils.FORMAT_SHOW_YEAR));// 显示提醒头部信息（当前禁用，因DateTimePicker未准备好）showAlertHeader();}/*** 显示提醒头部信息的方法。* 如果当前笔记设置了提醒，该方法将根据提醒时间显示相对的时间或者过期信息。*/private void showAlertHeader() {// 处理提醒显示if (mWorkingNote.hasClockAlert()) {long time = System.currentTimeMillis();// 如果提醒时间已过，显示提醒已过期的信息if (time > mWorkingNote.getAlertDate()) {mNoteHeaderHolder.tvAlertDate.setText(R.string.note_alert_expired);} else {// 否则，显示相对时间mNoteHeaderHolder.tvAlertDate.setText(DateUtils.getRelativeTimeSpanString(mWorkingNote.getAlertDate(), time, DateUtils.MINUTE_IN_MILLIS));}// 设置提醒视图可见mNoteHeaderHolder.tvAlertDate.setVisibility(View.VISIBLE);mNoteHeaderHolder.ivAlertIcon.setVisibility(View.VISIBLE);} else {// 如果没有设置提醒，隐藏提醒视图mNoteHeaderHolder.tvAlertDate.setVisibility(View.GONE);mNoteHeaderHolder.ivAlertIcon.setVisibility(View.GONE);}}/*** 当Activity接收到新的Intent时调用。* 用于根据新的Intent重新初始化Activity状态。** @param intent 新的Intent*/@Overrideprotected void onNewIntent(Intent intent) {super.onNewIntent(intent);initActivityState(intent);}/*** 保存Activity状态时调用。* 用于保存当前编辑的笔记，如果该笔记还未保存到数据库，则首先保存它。* 并且保存当前笔记的ID到Bundle中。** @param outState 用于保存Activity状态的Bundle*/@Overrideprotected void onSaveInstanceState(Bundle outState) {super.onSaveInstanceState(outState);// 如果当前编辑的笔记不存在于数据库中，即还未保存，先保存它if (!mWorkingNote.existInDatabase()) {saveNote();}// 保存笔记IDoutState.putLong(Intent.EXTRA_UID, mWorkingNote.getNoteId());Log.d(TAG, "Save working note id: " + mWorkingNote.getNoteId() + " onSaveInstanceState");}/*** 分发触摸事件。如果触摸事件不在指定视图范围内，则隐藏该视图。** @param ev 触摸事件* @return 如果事件被消费则返回true，否则返回false*/@Overridepublic 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);}/*** 判断触摸点是否在指定视图范围内。** @param view 视图* @param ev   触摸事件* @return 如果触摸点在视图范围内则返回true，否则返回false*/private boolean inRangeOfView(View view, MotionEvent ev) {int[] location = new int[2];view.getLocationOnScreen(location);int x = location[0];int y = location[1];// 判断触摸点是否在视图外if (ev.getX() < x|| ev.getX() > (x + view.getWidth())|| ev.getY() < y|| ev.getY() > (y + view.getHeight())) {return false;}return true;}/*** 初始化资源，包括视图和偏好设置。*/private void initResources() {// 初始化头部视图和相关组件mHeadViewPanel = findViewById(R.id.note_title);mNoteHeaderHolder = new HeadViewHolder();mNoteHeaderHolder.tvModified = (TextView) findViewById(R.id.tv_modified_date);mNoteHeaderHolder.ivAlertIcon = (ImageView) findViewById(R.id.iv_alert_icon);mNoteHeaderHolder.tvAlertDate = (TextView) findViewById(R.id.tv_alert_date);mNoteHeaderHolder.ibSetBgColor = (ImageView) findViewById(R.id.btn_set_bg_color);mNoteHeaderHolder.ibSetBgColor.setOnClickListener(this);// 初始化编辑器和相关组件mNoteEditor = (EditText) findViewById(R.id.note_edit_view);mNoteEditorPanel = findViewById(R.id.sv_note_edit);mNoteBgColorSelector = findViewById(R.id.note_bg_color_selector);// 设置背景选择器按钮点击监听器for (int id : sBgSelectorBtnsMap.keySet()) {ImageView iv = (ImageView) findViewById(id);iv.setOnClickListener(this);}mFontSizeSelector = findViewById(R.id.font_size_selector);// 设置字体大小选择器按钮点击监听器for (int id : sFontSizeBtnsMap.keySet()) {View view = findViewById(id);view.setOnClickListener(this);};// 从偏好设置中读取字体大小mSharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);mFontSizeId = mSharedPrefs.getInt(PREFERENCE_FONT_SIZE, ResourceParser.BG_DEFAULT_FONT_SIZE);// 修复存储在偏好设置中的字体大小资源ID的错误if (mFontSizeId >= TextAppearanceResources.getResourcesSize()) {mFontSizeId = ResourceParser.BG_DEFAULT_FONT_SIZE;}// 初始化编辑列表mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list);}/*** 暂停时保存笔记数据并清除设置状态。*/@Overrideprotected void onPause() {super.onPause();// 保存笔记数据if (saveNote()) {Log.d(TAG, "Note data was saved with length:" + mWorkingNote.getContent().length());}// 清除设置状态clearSettingState();}/*** 更新小部件显示。*/private void updateWidget() {Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);// 根据小部件类型设置对应的类if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_2X) {intent.setClass(this, NoteWidgetProvider_2x.class);} else if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_4X) {intent.setClass(this, NoteWidgetProvider_4x.class);} else {Log.e(TAG, "Unspported widget type");return;}// 设置小部件IDintent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[]{mWorkingNote.getWidgetId()});// 发送广播更新小部件sendBroadcast(intent);// 设置结果为OKsetResult(RESULT_OK, intent);}/*** 点击事件的处理函数。** @param v 被点击的视图对象。*/public void onClick(View v) {int id = v.getId();// 如果点击的是设置背景颜色的按钮if (id == R.id.btn_set_bg_color) {mNoteBgColorSelector.setVisibility(View.VISIBLE);// 根据当前笔记的背景颜色，设置对应的色板按钮可见findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(View.VISIBLE);} else if (sBgSelectorBtnsMap.containsKey(id)) {// 如果点击的是背景色板上的颜色findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(View.GONE); // 隐藏当前选择的背景颜色mWorkingNote.setBgColorId(sBgSelectorBtnsMap.get(id)); // 更新笔记的背景颜色mNoteBgColorSelector.setVisibility(View.GONE); // 隐藏背景颜色选择器} else if (sFontSizeBtnsMap.containsKey(id)) {// 如果点击的是字体大小按钮findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.GONE); // 隐藏当前选择的字体大小mFontSizeId = sFontSizeBtnsMap.get(id); // 更新选择的字体大小mSharedPrefs.edit().putInt(PREFERENCE_FONT_SIZE, mFontSizeId).commit(); // 保存选择的字体大小到SharedPreferencesfindViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE); // 设置新选择的字体大小按钮为可见// 根据当前笔记是否为清单模式，进行相应的文本更新if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {getWorkingText();switchToListMode(mWorkingNote.getContent());} else {mNoteEditor.setTextAppearance(this,TextAppearanceResources.getTexAppearanceResource(mFontSizeId));}mFontSizeSelector.setVisibility(View.GONE); // 隐藏字体大小选择器}}/*** 按下返回键时的处理函数。*/@Overridepublic void onBackPressed() {// 尝试清除设置状态，如果成功，则不执行保存笔记操作if (clearSettingState()) {return;}// 保存笔记并执行父类的onBackPressed()方法（结束当前Activity）saveNote();super.onBackPressed();}/*** 尝试清除设置状态（背景颜色选择或字体大小选择）。** @return 如果成功清除设置状态，返回true；否则返回false。*/private boolean clearSettingState() {// 如果背景颜色选择器可见，则隐藏它并返回trueif (mNoteBgColorSelector.getVisibility() == View.VISIBLE) {mNoteBgColorSelector.setVisibility(View.GONE);return true;} else if (mFontSizeSelector.getVisibility() == View.VISIBLE) { // 如果字体大小选择器可见，则隐藏它并返回truemFontSizeSelector.setVisibility(View.GONE);return true;}return false; // 没有可见的设置状态需要清除，返回false}/*** 当背景颜色发生变化时的处理函数。*/public void onBackgroundColorChanged() {// 根据当前笔记的背景颜色，设置对应的色板按钮可见，并更新编辑器及标题栏的背景颜色findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(View.VISIBLE);mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());}/*** 准备选项菜单的函数。** @param menu 选项菜单对象。* @return 总是返回true。*/@Overridepublic boolean onPrepareOptionsMenu(Menu menu) {// 如果Activity正在结束，则不进行任何操作if (isFinishing()) {return true;}// 尝试清除设置状态clearSettingState();menu.clear(); // 清除菜单项// 根据笔记所属的文件夹，加载不同的菜单资源if (mWorkingNote.getFolderId() == Notes.ID_CALL_RECORD_FOLDER) {getMenuInflater().inflate(R.menu.call_note_edit, menu);} else {getMenuInflater().inflate(R.menu.note_edit, menu);}// 根据当前笔记的清单模式，更新“清单模式”菜单项的标题if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_normal_mode);} else {menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_list_mode);}// 根据笔记是否有提醒，更新“删除提醒”菜单项的可见性if (mWorkingNote.hasClockAlert()) {menu.findItem(R.id.menu_alert).setVisible(false);} else {menu.findItem(R.id.menu_delete_remind).setVisible(false);}return true;}/*** 处理选项菜单项的选择事件。** @param item 选中的菜单项* @return 总是返回true，表示事件已处理。*/@Overridepublic boolean onOptionsItemSelected(MenuItem item) {switch (item.getItemId()) {case R.id.menu_new_note:// 创建新笔记createNewNote();break;case R.id.menu_delete:// 显示删除笔记的确认对话框AlertDialog.Builder builder = new AlertDialog.Builder(this);builder.setTitle(getString(R.string.alert_title_delete));builder.setIcon(android.R.drawable.ic_dialog_alert);builder.setMessage(getString(R.string.alert_message_delete_note));builder.setPositiveButton(android.R.string.ok,new DialogInterface.OnClickListener() {public void onClick(DialogInterface dialog, int which) {// 确认删除当前笔记并结束当前活动deleteCurrentNote();finish();}});builder.setNegativeButton(android.R.string.cancel, null);builder.show();break;case R.id.menu_font_size:// 显示字体大小选择器mFontSizeSelector.setVisibility(View.VISIBLE);findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);break;case R.id.menu_list_mode:// 切换笔记的列表模式mWorkingNote.setCheckListMode(mWorkingNote.getCheckListMode() == 0 ?TextNote.MODE_CHECK_LIST : 0);break;case R.id.menu_share:// 获取当前编辑的笔记内容并分享getWorkingText();sendTo(this, mWorkingNote.getContent());break;case R.id.menu_send_to_desktop:// 将笔记发送到桌面sendToDesktop();break;case R.id.menu_alert:// 设置提醒setReminder();break;case R.id.menu_delete_remind:// 删除提醒设置mWorkingNote.setAlertDate(0, false);break;default:break;}return true;}/*** 弹出日期时间选择器，用于设置提醒时间。*/private void setReminder() {DateTimePickerDialog d = new DateTimePickerDialog(this, System.currentTimeMillis());d.setOnDateTimeSetListener(new OnDateTimeSetListener() {public void OnDateTimeSet(AlertDialog dialog, long date) {// 用户设定时间后，设置提醒mWorkingNote.setAlertDate(date, true);}});d.show();}/*** 分享笔记到支持 {@link Intent#ACTION_SEND} 操作和 {@text/plain} 类型的应用。** @param context 上下文* @param info    要分享的信息*/private void sendTo(Context context, String info) {Intent intent = new Intent(Intent.ACTION_SEND);intent.putExtra(Intent.EXTRA_TEXT, info);intent.setType("text/plain");context.startActivity(intent);}/*** 首先保存当前正在编辑的笔记，然后启动一个新的NoteEditActivity用于创建新笔记。*/private void createNewNote() {// 首先保存当前笔记saveNote();// 安全地开始一个新的NoteEditActivityfinish();Intent intent = new Intent(this, NoteEditActivity.class);intent.setAction(Intent.ACTION_INSERT_OR_EDIT);intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mWorkingNote.getFolderId());startActivity(intent);}/*** 删除当前正在编辑的笔记。* 如果笔记存在于数据库中，并且当前不是同步模式，将直接删除该笔记；* 如果处于同步模式，则将笔记移动到回收站文件夹。*/private void deleteCurrentNote() {if (mWorkingNote.existInDatabase()) {HashSet<Long> ids = new HashSet<Long>();long id = mWorkingNote.getNoteId();if (id != Notes.ID_ROOT_FOLDER) {ids.add(id);} else {Log.d(TAG, "Wrong note id, should not happen");}if (!isSyncMode()) {// 非同步模式下直接删除笔记if (!DataUtils.batchDeleteNotes(getContentResolver(), ids)) {Log.e(TAG, "Delete Note error");}} else {// 同步模式下将笔记移动到回收站if (!DataUtils.batchMoveToFolder(getContentResolver(), ids, Notes.ID_TRASH_FOLER)) {Log.e(TAG, "Move notes to trash folder error, should not happens");}}}mWorkingNote.markDeleted(true);}/*** 判断当前是否为同步模式。* 同步模式是指在设置中配置了同步账户名。** @return 如果配置了同步账户名返回true，否则返回false。*/private boolean isSyncMode() {return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;}/*** 处理时钟提醒变更事件。* 首先检查当前笔记是否已保存，未保存则先保存。* 如果笔记存在，根据set参数设置或取消提醒。* 如果笔记不存在（即无有效ID），记录错误并提示用户输入内容。** @param date 提醒的日期时间戳* @param set  是否设置提醒*/public void onClockAlertChanged(long date, boolean set) {if (!mWorkingNote.existInDatabase()) {saveNote();}if (mWorkingNote.getNoteId() > 0) {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);AlarmManager alarmManager = ((AlarmManager) getSystemService(ALARM_SERVICE));showAlertHeader();if (!set) {alarmManager.cancel(pendingIntent);} else {alarmManager.set(AlarmManager.RTC_WAKEUP, date, pendingIntent);}} else {Log.e(TAG, "Clock alert setting error");showToast(R.string.error_note_empty_for_clock);}}/*** 更新小部件显示。*/public void onWidgetChanged() {updateWidget();}/*** 当删除某个编辑框中的文本时的处理逻辑。* 重新设置后续编辑框的索引，并将删除的文本添加到前一个或当前编辑框中。** @param index 被删除文本的编辑框索引* @param text  被删除的文本内容*/public void onEditTextDelete(int index, String text) {int childCount = mEditTextList.getChildCount();if (childCount == 1) {return;}for (int i = index + 1; i < childCount; i++) {((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text)).setIndex(i - 1);}mEditTextList.removeViewAt(index);NoteEditText edit = null;if (index == 0) {edit = (NoteEditText) mEditTextList.getChildAt(0).findViewById(R.id.et_edit_text);} else {edit = (NoteEditText) mEditTextList.getChildAt(index - 1).findViewById(R.id.et_edit_text);}int length = edit.length();edit.append(text);edit.requestFocus();edit.setSelection(length);}/*** 当在编辑框中按下“Enter”键时的处理逻辑。* 在列表中添加一个新的编辑框，并重新设置后续编辑框的索引。** @param index 当前编辑框的索引* @param text  当前编辑框中的文本内容*/public void onEditTextEnter(int index, String text) {if (index > mEditTextList.getChildCount()) {Log.e(TAG, "Index out of mEditTextList boundrary, should not happen");}View view = getListItem(text, index);mEditTextList.addView(view, index);NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);edit.requestFocus();edit.setSelection(0);for (int i = index + 1; i < mEditTextList.getChildCount(); i++) {((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text)).setIndex(i);}}/*** 切换到列表模式。* 将文本分割成多行，并为每行创建一个列表项，展示在编辑文本列表中。** @param text 要转换成列表模式的文本，每行代表一个列表项。*/private void switchToListMode(String text) {// 清空当前的视图mEditTextList.removeAllViews();// 使用换行符分割文本，创建列表项String[] items = text.split("\n");int index = 0;for (String item : items) {// 忽略空行if (!TextUtils.isEmpty(item)) {mEditTextList.addView(getListItem(item, index));index++;}}// 添加一个空的列表项作为占位符mEditTextList.addView(getListItem("", index));// 请求焦点以便于编辑mEditTextList.getChildAt(index).findViewById(R.id.et_edit_text).requestFocus();// 隐藏编辑器，显示列表mNoteEditor.setVisibility(View.GONE);mEditTextList.setVisibility(View.VISIBLE);}/*** 高亮显示查询结果。* 在给定的文本中，根据用户查询字符串高亮显示匹配的部分。** @param fullText  完整的文本。* @param userQuery 用户的查询字符串。* @return 包含高亮显示的文本的Spannable对象。*/private Spannable getHighlightQueryResult(String fullText, String userQuery) {SpannableString spannable = new SpannableString(fullText == null ? "" : fullText);// 如果有查询字符串，则进行高亮处理if (!TextUtils.isEmpty(userQuery)) {mPattern = Pattern.compile(userQuery);Matcher m = mPattern.matcher(fullText);int start = 0;while (m.find(start)) {// 设置高亮背景spannable.setSpan(new BackgroundColorSpan(this.getResources().getColor(R.color.user_query_highlight)), m.start(), m.end(),Spannable.SPAN_INCLUSIVE_EXCLUSIVE);start = m.end();}}return spannable;}/*** 创建列表项视图。* 为列表模式创建并配置一个包含文本编辑框和复选框的视图。** @param item  列表项的文本内容。* @param index 列表项的索引。* @return 配置好的列表项视图。*/private View getListItem(String item, int index) {// 加载列表项布局View view = LayoutInflater.from(this).inflate(R.layout.note_edit_list_item, null);final NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);// 设置文本样式edit.setTextAppearance(this, TextAppearanceResources.getTexAppearanceResource(mFontSizeId));CheckBox cb = ((CheckBox) view.findViewById(R.id.cb_edit_item));// 复选框的监听器，用于切换文本的划线状态cb.setOnCheckedChangeListener(new OnCheckedChangeListener() {public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {if (isChecked) {edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);} else {edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG);}}});// 根据文本前缀设置复选框状态和文本内容if (item.startsWith(TAG_CHECKED)) {cb.setChecked(true);edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);item = item.substring(TAG_CHECKED.length(), item.length()).trim();} else if (item.startsWith(TAG_UNCHECKED)) {cb.setChecked(false);edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG);item = item.substring(TAG_UNCHECKED.length(), item.length()).trim();}// 设置文本变化监听和索引edit.setOnTextViewChangeListener(this);edit.setIndex(index);// 设置带有查询结果高亮的文本edit.setText(getHighlightQueryResult(item, mUserQuery));return view;}/*** 根据文本内容是否为空，切换复选框的可见性。** @param index   列表项索引。* @param hasText 列表项是否包含文本。*/public void onTextChange(int index, boolean hasText) {if (index >= mEditTextList.getChildCount()) {Log.e(TAG, "Wrong index, should not happen");return;}// 根据文本内容决定复选框的可见性if (hasText) {mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.VISIBLE);} else {mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.GONE);}}/*** 在切换编辑模式和列表模式时更新UI。** @param oldMode 旧的编辑模式。* @param newMode 新的编辑模式。*/public void onCheckListModeChanged(int oldMode, int newMode) {// 切换到列表模式if (newMode == TextNote.MODE_CHECK_LIST) {switchToListMode(mNoteEditor.getText().toString());} else {// 切换回编辑模式if (!getWorkingText()) {mWorkingNote.setWorkingText(mWorkingNote.getContent().replace(TAG_UNCHECKED + " ",""));}mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));mEditTextList.setVisibility(View.GONE);mNoteEditor.setVisibility(View.VISIBLE);}}/*** 根据当前列表项的选中状态，构建并返回工作文本。** @return 是否有已选中的列表项。*/private boolean getWorkingText() {boolean hasChecked = false;if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {StringBuilder sb = new StringBuilder();for (int i = 0; i < mEditTextList.getChildCount(); i++) {View view = mEditTextList.getChildAt(i);NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);// 构建带有选中状态前缀的文本if (!TextUtils.isEmpty(edit.getText())) {if (((CheckBox) view.findViewById(R.id.cb_edit_item)).isChecked()) {sb.append(TAG_CHECKED).append(" ").append(edit.getText()).append("\n");hasChecked = true;} else {sb.append(TAG_UNCHECKED).append(" ").append(edit.getText()).append("\n");}}}mWorkingNote.setWorkingText(sb.toString());} else {mWorkingNote.setWorkingText(mNoteEditor.getText().toString());}return hasChecked;}/*** 保存笔记。* 更新笔记内容并保存。** @return 是否成功保存笔记。*/private boolean saveNote() {getWorkingText();boolean saved = mWorkingNote.saveNote();if (saved) {// 设置结果为成功，以便外部调用者知道保存操作的状态setResult(RESULT_OK);}return saved;}/*** 将当前编辑的笔记发送到桌面。首先会检查当前编辑的笔记是否已存在于数据库中，* 如果不存在，则先保存。如果存在，会创建一个快捷方式放在桌面。*/private void sendToDesktop() {// 检查当前编辑的笔记是否存在于数据库，若不存在则先保存if (!mWorkingNote.existInDatabase()) {saveNote();}// 如果笔记存在于数据库（有noteId），则创建快捷方式if (mWorkingNote.getNoteId() > 0) {Intent sender = new Intent();Intent shortcutIntent = new Intent(this, NoteEditActivity.class);shortcutIntent.setAction(Intent.ACTION_VIEW);shortcutIntent.putExtra(Intent.EXTRA_UID, mWorkingNote.getNoteId());sender.putExtra(Intent.EXTRA_SHORTCUT_INTENT, shortcutIntent);sender.putExtra(Intent.EXTRA_SHORTCUT_NAME,makeShortcutIconTitle(mWorkingNote.getContent()));sender.putExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE,Intent.ShortcutIconResource.fromContext(this, R.drawable.icon_app));sender.putExtra("duplicate", true);sender.setAction("com.android.launcher.action.INSTALL_SHORTCUT");showToast(R.string.info_note_enter_desktop);sendBroadcast(sender);} else {// 如果用户未输入任何内容，无法创建快捷方式，提醒用户输入内容Log.e(TAG, "Send to desktop error");showToast(R.string.error_note_empty_for_send_to_desktop);}}/*** 根据笔记内容生成快捷方式的标题。移除内容中的已选和未选标签，并确保标题长度不超过上限。** @param content 符合快捷方式图标标题要求的笔记内容* @return 标题字符串*/private String makeShortcutIconTitle(String content) {content = content.replace(TAG_CHECKED, "");content = content.replace(TAG_UNCHECKED, "");return content.length() > SHORTCUT_ICON_TITLE_MAX_LEN ? content.substring(0,SHORTCUT_ICON_TITLE_MAX_LEN) : content;}/*** 显示一个Toast消息。** @param resId 资源ID，指向要显示的字符串*/private void showToast(int resId) {showToast(resId, Toast.LENGTH_SHORT);}/*** 显示一个指定时长的Toast消息。** @param resId    资源ID，指向要显示的字符串* @param duration 显示时长，可以是Toast.LENGTH_SHORT或Toast.LENGTH_LONG*/private void showToast(int resId, int duration) {Toast.makeText(this, resId, duration).show();}}

9 NoteltemData

包声明：package net.micode.notes.ui; 声明了该类所在的包。
导入语句：导入了一系列Java和Android相关的类，包括上下文、游标、字符串操作、联系人数据操作、笔记数据操作、数据工具操作等。
类声明：public class NoteItemData { 声明了一个名为 NoteItemData 的公共类。
常量声明：
static final String[] PROJECTION = new String[]{ ... }; 声明了一个静态最终的字符串数组 PROJECTION，用于查询时使用的列名。
private static final int ID_COLUMN = 0; 声明了一个私有静态最终的整数 ID_COLUMN，表示ID列的索引。
private static final int ALERTED_DATE_COLUMN = 1; 声明了一个私有静态最终的整数 ALERTED_DATE_COLUMN，表示提醒日期列的索引。
其他列索引常量的声明类似。
成员变量：
private long mId; 声明了一个私有长整型变量 mId，用于存储笔记ID。
private long mAlertDate; 声明了一个私有长整型变量 mAlertDate，用于存储提醒日期。
其他成员变量的声明类似。
构造函数：
public NoteItemData(Context context, Cursor cursor) { ... } 声明了类的构造函数，接受上下文和数据源游标作为参数，并从游标中提取各项数据赋值给成员变量。
方法：
private void checkPostion(Cursor cursor) { ... } 声明了一个私有方法 checkPostion，用于根据当前游标位置更新笔记在列表中的位置状态。
public boolean isOneFollowingFolder() { ... } 声明了一个公共方法 isOneFollowingFolder，用于返回一个笔记跟随文件夹状态。
public boolean isMultiFollowingFolder() { ... } 声明了一个公共方法 isMultiFollowingFolder，用于返回多个笔记跟随文件夹状态。
其他获取属性的方法类似。
静态方法：
public static int getNoteType(Cursor cursor) { ... } 声明了一个公共静态方法 getNoteType，用于从游标中获取笔记的类型。

package net.micode.notes.ui; // 定义包名import android.content.Context; // 导入Context类，用于获取上下文
import android.database.Cursor; // 导入Cursor类，用于数据源游标
import android.text.TextUtils; // 导入TextUtils类，用于字符串操作import net.micode.notes.data.Contact; // 导入Contact类，用于联系人数据操作
import net.micode.notes.data.Notes; // 导入Notes类，用于笔记数据操作
import net.micode.notes.data.Notes.NoteColumns; // 导入NoteColumns类，用于笔记数据列名
import net.micode.notes.tool.DataUtils; // 导入DataUtils类，用于数据工具操作/*** 代表一个笔记项的数据类，用于存储和管理笔记的各种信息。*/
public class NoteItemData { // 定义NoteItemData类// 定义查询时要投影的列static final String[] PROJECTION = new String[]{NoteColumns.ID, // 笔记IDNoteColumns.ALERTED_DATE, // 提醒日期NoteColumns.BG_COLOR_ID, // 背景颜色IDNoteColumns.CREATED_DATE, // 创建日期NoteColumns.HAS_ATTACHMENT, // 是否有附件NoteColumns.MODIFIED_DATE, // 修改日期NoteColumns.NOTES_COUNT, // 笔记数量NoteColumns.PARENT_ID, // 父IDNoteColumns.SNIPPET, // 摘要NoteColumns.TYPE, // 类型NoteColumns.WIDGET_ID, // 小部件IDNoteColumns.WIDGET_TYPE, // 小部件类型};// 各列数据的索引private static final int ID_COLUMN = 0; // ID列索引private static final int ALERTED_DATE_COLUMN = 1; // 提醒日期列索引private static final int BG_COLOR_ID_COLUMN = 2; // 背景颜色ID列索引private static final int CREATED_DATE_COLUMN = 3; // 创建日期列索引private static final int HAS_ATTACHMENT_COLUMN = 4; // 是否有附件列索引private static final int MODIFIED_DATE_COLUMN = 5; // 修改日期列索引private static final int NOTES_COUNT_COLUMN = 6; // 笔记数量列索引private static final int PARENT_ID_COLUMN = 7; // 父ID列索引private static final int SNIPPET_COLUMN = 8; // 摘要列索引private static final int TYPE_COLUMN = 9; // 类型列索引private static final int WIDGET_ID_COLUMN = 10; // 小部件ID列索引private static final int WIDGET_TYPE_COLUMN = 11; // 小部件类型列索引// 笔记的各项数据private long mId; // 笔记IDprivate long mAlertDate; // 提醒日期private int mBgColorId; // 背景颜色IDprivate long mCreatedDate; // 创建日期private boolean mHasAttachment; // 是否有附件private long mModifiedDate; // 修改日期private int mNotesCount; // 笔记数量private long mParentId; // 父IDprivate String mSnippet; // 摘要private int mType; // 类型private int mWidgetId; // 小部件IDprivate int mWidgetType; // 小部件类型private String mName; // 联系人名称private String mPhoneNumber; // 电话号码// 用于标识笔记在列表中的位置状态private boolean mIsLastItem; // 是否为最后一个项目private boolean mIsFirstItem; // 是否为第一个项目private boolean mIsOnlyOneItem; // 是否为唯一一个项目private boolean mIsOneNoteFollowingFolder; // 是否为一个笔记跟随文件夹private boolean mIsMultiNotesFollowingFolder; // 是否为多个笔记跟随文件夹/*** 根据Cursor数据构造一个NoteItemData对象。** @param context 上下文对象，用于访问应用全局功能。* @param cursor  包含笔记数据的Cursor对象。*/public NoteItemData(Context context, Cursor cursor) {// 从Cursor中提取各项数据并赋值mId = cursor.getLong(ID_COLUMN); // 获取笔记IDmAlertDate = cursor.getLong(ALERTED_DATE_COLUMN); // 获取提醒日期mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN); // 获取背景颜色IDmCreatedDate = cursor.getLong(CREATED_DATE_COLUMN); // 获取创建日期mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0) ? true : false; // 获取是否有附件mModifiedDate = cursor.getLong(MODIFIED_DATE_COLUMN); // 获取修改日期mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN); // 获取笔记数量mParentId = cursor.getLong(PARENT_ID_COLUMN); // 获取父IDmSnippet = cursor.getString(SNIPPET_COLUMN); // 获取摘要mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(NoteEditActivity.TAG_UNCHECKED, ""); // 清理摘要中的特殊标记mType = cursor.getInt(TYPE_COLUMN); // 获取类型mWidgetId = cursor.getInt(WIDGET_ID_COLUMN); // 获取小部件IDmWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN); // 获取小部件类型// 如果是通话记录笔记，尝试获取通话号码和联系人名称mPhoneNumber = ""; // 初始化电话号码if (mParentId == Notes.ID_CALL_RECORD_FOLDER) { // 判断是否为通话记录笔记mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId); // 获取电话号码if (!TextUtils.isEmpty(mPhoneNumber)) { // 判断电话号码是否为空mName = Contact.getContact(context, mPhoneNumber); // 获取联系人名称if (mName == null) { // 判断联系人名称是否为空mName = mPhoneNumber; // 如果为空，则使用电话号码作为名称}}}// 如果没有获取到联系人名称，则默认为空字符串if (mName == null) { // 判断联系人名称是否为空mName = ""; // 如果为空，则默认为空字符串}checkPostion(cursor); // 检查笔记在列表中的位置}/*** 根据当前Cursor位置，更新NoteItemData的状态信息（如是否为列表中的最后一个项目等）。** @param cursor 包含笔记数据的Cursor对象。*/private void checkPostion(Cursor cursor) {// 更新位置状态信息mIsLastItem = cursor.isLast(); // 判断是否为最后一个项目mIsFirstItem = cursor.isFirst(); // 判断是否为第一个项目mIsOnlyOneItem = (cursor.getCount() == 1); // 判断是否为唯一一个项目mIsMultiNotesFollowingFolder = false; // 初始化多个笔记跟随文件夹状态mIsOneNoteFollowingFolder = false; // 初始化一个笔记跟随文件夹状态// 检查当前笔记是否跟随文件夹，并更新相应状态if (mType == Notes.TYPE_NOTE && !mIsFirstItem) { // 判断是否为笔记且不是第一个项目int position = cursor.getPosition(); // 获取当前位置if (cursor.moveToPrevious()) { // 移动到前一个位置if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER|| cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) { // 判断前一个项目是否为文件夹或系统类型if (cursor.getCount() > (position + 1)) { // 判断是否有多于一个项目mIsMultiNotesFollowingFolder = true; // 设置多个笔记跟随文件夹状态} else {mIsOneNoteFollowingFolder = true; // 设置一个笔记跟随文件夹状态}}// 确保Cursor能够回到原来的位置if (!cursor.moveToNext()) { // 移动回原来的位置throw new IllegalStateException("cursor move to previous but can't move back"); // 抛出异常}}}}// 以下为获取NoteItemData各项属性的方法public boolean isOneFollowingFolder() {return mIsOneNoteFollowingFolder; // 返回一个笔记跟随文件夹状态}public boolean isMultiFollowingFolder() {return mIsMultiNotesFollowingFolder; // 返回多个笔记跟随文件夹状态}public boolean isLast() {return mIsLastItem; // 返回是否为最后一个项目}public String getCallName() {return mName; // 返回联系人名称}public boolean isFirst() {return mIsFirstItem; // 返回是否为第一个项目}public boolean isSingle() {return mIsOnlyOneItem; // 返回是否为唯一一个项目}public long getId() {return mId; // 返回笔记ID}public long getAlertDate() {return mAlertDate; // 返回提醒日期}public long getCreatedDate() {return mCreatedDate; // 返回创建日期}public boolean hasAttachment() {return mHasAttachment; // 返回是否有附件}public long getModifiedDate() {return mModifiedDate; // 返回修改日期}public int getBgColorId() {return mBgColorId; // 返回背景颜色ID}public long getParentId() {return mParentId; // 返回父ID}public int getNotesCount() {return mNotesCount; // 返回笔记数量}public long getFolderId() {return mParentId; // 返回文件夹ID}public int getType() {return mType; // 返回类型}public int getWidgetType() {return mWidgetType; // 返回小部件类型}public int getWidgetId() {return mWidgetId; // 返回小部件ID}public String getSnippet() {return mSnippet; // 返回摘要}public boolean hasAlert() {return (mAlertDate > 0); // 返回是否有提醒}public boolean isCallRecord() {return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber)); // 返回是否为通话记录笔记}/*** 从Cursor中获取笔记的类型。** @param cursor 包含笔记数据的Cursor对象。* @return 笔记的类型。*/public static int getNoteType(Cursor cursor) {return cursor.getInt(TYPE_COLUMN); // 返回笔记类型}
}

10 NotesListActivity

package net.micode.notes.ui;import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.appwidget.AppWidgetManager;
import android.content.AsyncQueryHandler;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.database.Cursor;
import android.os.AsyncTask;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.text.Editable;
import android.text.TextUtils;
import android.text.TextWatcher;
import android.util.Log;
import android.view.ActionMode;
import android.view.ContextMenu;
import android.view.ContextMenu.ContextMenuInfo;
import android.view.Display;
import android.view.HapticFeedbackConstants;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.MenuItem.OnMenuItemClickListener;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.View.OnCreateContextMenuListener;
import android.view.View.OnTouchListener;
import android.view.inputmethod.InputMethodManager;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.AdapterView.OnItemLongClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ListView;
import android.widget.PopupMenu;
import android.widget.TextView;
import android.widget.Toast;import net.micode.notes.R;
import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.gtask.remote.GTaskSyncService;
import net.micode.notes.model.WorkingNote;
import net.micode.notes.tool.BackupUtils;
import net.micode.notes.tool.DataUtils;
import net.micode.notes.tool.ResourceParser;
import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;
import net.micode.notes.widget.NoteWidgetProvider_2x;
import net.micode.notes.widget.NoteWidgetProvider_4x;import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashSet;public class NotesListActivity extends Activity implements OnClickListener, OnItemLongClickListener {// 定义文件夹中笔记列表查询的标记private static final int FOLDER_NOTE_LIST_QUERY_TOKEN = 0;// 定义文件夹列表查询的标记private static final int FOLDER_LIST_QUERY_TOKEN = 1;// 菜单中删除文件夹的选项private static final int MENU_FOLDER_DELETE = 0;// 菜单中查看文件夹的选项private static final int MENU_FOLDER_VIEW = 1;// 菜单中更改文件夹名称的选项private static final int MENU_FOLDER_CHANGE_NAME = 2;// 首次使用应用时，添加介绍信息的偏好设置键private static final String PREFERENCE_ADD_INTRODUCTION = "net.micode.notes.introduction";// 列表编辑状态的枚举，包括笔记列表、子文件夹和通话记录文件夹private enum ListEditState {NOTE_LIST, SUB_FOLDER, CALL_RECORD_FOLDER};// 当前编辑状态private ListEditState mState;// 后台查询处理器private BackgroundQueryHandler mBackgroundQueryHandler;// 笔记列表的适配器private NotesListAdapter mNotesListAdapter;// 笔记列表视图private ListView mNotesListView;// 添加新笔记的按钮private Button mAddNewNote;// 是否分发事件的标志private boolean mDispatch;// 触摸点的原始Y坐标private int mOriginY;// 分发事件时的Y坐标private int mDispatchY;// 标题栏文本视图private TextView mTitleBar;// 当前文件夹的IDprivate long mCurrentFolderId;// 内容解析器private ContentResolver mContentResolver;// 模式回调接口private ModeCallback mModeCallBack;// 日志标签private static final String TAG = "NotesListActivity";// 笔记列表视图滚动速率public static final int NOTES_LISTVIEW_SCROLL_RATE = 30;// 聚焦的笔记数据项private NoteItemData mFocusNoteDataItem;// 普通文件夹选择条件private static final String NORMAL_SELECTION = NoteColumns.PARENT_ID + "=?";// 根文件夹选择条件private static final String ROOT_FOLDER_SELECTION = "(" + NoteColumns.TYPE + "<>"+ Notes.TYPE_SYSTEM + " AND " + NoteColumns.PARENT_ID + "=?)" + " OR ("+ NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER + " AND "+ NoteColumns.NOTES_COUNT + ">0)";// 打开节点请求代码private final static int REQUEST_CODE_OPEN_NODE = 102;// 新建节点请求代码private final static int REQUEST_CODE_NEW_NODE = 103;/*** 在活动创建时调用，用于初始化资源和设置应用信息。** @param savedInstanceState 如果活动之前被销毁，这参数包含之前的状态。如果活动没被销毁之前，这参数是null。*/@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.note_list);initResources();// 用户首次使用时插入介绍信息setAppInfoFromRawRes();}/*** 处理从其他活动返回的结果。** @param requestCode 启动其他活动时传入的请求代码。* @param resultCode  其他活动返回的结果代码。* @param data        其他活动返回的数据。*/@Overrideprotected void onActivityResult(int requestCode, int resultCode, Intent data) {// 如果返回结果为OK且请求代码为打开节点或新建节点，则刷新列表if (resultCode == RESULT_OK&& (requestCode == REQUEST_CODE_OPEN_NODE || requestCode == REQUEST_CODE_NEW_NODE)) {mNotesListAdapter.changeCursor(null);} else {super.onActivityResult(requestCode, resultCode, data);}}/*** 从原始资源中设置应用信息。此方法会读取R.raw.introduction中的内容，* 并且只有当之前未添加介绍信息时，才将读取到的内容保存为一个工作笔记。*/private void setAppInfoFromRawRes() {// 获取SharedPreferences实例SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);// 检查是否已经添加了介绍信息if (!sp.getBoolean(PREFERENCE_ADD_INTRODUCTION, false)) {StringBuilder sb = new StringBuilder();InputStream in = null;try {// 从资源中打开introduction文件in = getResources().openRawResource(R.raw.introduction);if (in != null) {// 读取文件内容到StringBuilderInputStreamReader isr = new InputStreamReader(in);BufferedReader br = new BufferedReader(isr);char[] buf = new char[1024];int len = 0;while ((len = br.read(buf)) > 0) {sb.append(buf, 0, len);}} else {// 打印错误日志，如果无法打开文件Log.e(TAG, "Read introduction file error");return;}} catch (IOException e) {e.printStackTrace();return;} finally {// 确保InputStream被关闭if (in != null) {try {in.close();} catch (IOException e) {e.printStackTrace();}}}// 创建一个新的工作笔记并设置其内容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()) {sp.edit().putBoolean(PREFERENCE_ADD_INTRODUCTION, true).commit();} else {// 打印错误日志，如果保存工作笔记失败Log.e(TAG, "Save introduction note error");return;}}}/*** Activity启动时调用，开始异步查询笔记列表。*/@Overrideprotected void onStart() {super.onStart();startAsyncNotesListQuery();}/*** 初始化资源，包括ListView、适配器和其他UI组件。*/private void initResources() {// 获取ContentResolver实例mContentResolver = this.getContentResolver();// 创建后台查询处理器mBackgroundQueryHandler = new BackgroundQueryHandler(this.getContentResolver());mCurrentFolderId = Notes.ID_ROOT_FOLDER;// 初始化ListView和相关监听器mNotesListView = (ListView) findViewById(R.id.notes_list);mNotesListView.addFooterView(LayoutInflater.from(this).inflate(R.layout.note_list_footer, null),null, false);mNotesListView.setOnItemClickListener(new OnListItemClickListener());mNotesListView.setOnItemLongClickListener(this);// 初始化并设置笔记列表适配器mNotesListAdapter = new NotesListAdapter(this);mNotesListView.setAdapter(mNotesListAdapter);// 初始化新建笔记按钮并设置点击监听器mAddNewNote = (Button) findViewById(R.id.btn_new_note);mAddNewNote.setOnClickListener(this);mAddNewNote.setOnTouchListener(new NewNoteOnTouchListener());// 初始化状态变量和触摸相关的变量mDispatch = false;mDispatchY = 0;mOriginY = 0;// 初始化标题栏和其他状态变量mTitleBar = (TextView) findViewById(R.id.tv_title_bar);mState = ListEditState.NOTE_LIST;mModeCallBack = new ModeCallback();}/*** 用于处理列表的多选择模式和菜单点击事件的回调类。*/private class ModeCallback implements ListView.MultiChoiceModeListener, OnMenuItemClickListener {private DropdownMenu mDropDownMenu; // 下拉菜单private ActionMode mActionMode; // 动作模式private MenuItem mMoveMenu; // 移动菜单项/*** 创建动作模式时的回调方法。** @param mode 动作模式实例。* @param menu 菜单实例。* @return 如果成功创建动作模式，返回true；否则返回false。*/public boolean onCreateActionMode(ActionMode mode, Menu menu) {// 加载菜单项getMenuInflater().inflate(R.menu.note_list_options, menu);// 设置删除项的点击监听器menu.findItem(R.id.delete).setOnMenuItemClickListener(this);mMoveMenu = menu.findItem(R.id.move);// 根据条件决定是否显示移动菜单项if (mFocusNoteDataItem.getParentId() == Notes.ID_CALL_RECORD_FOLDER|| DataUtils.getUserFolderCount(mContentResolver) == 0) {mMoveMenu.setVisible(false);} else {mMoveMenu.setVisible(true);mMoveMenu.setOnMenuItemClickListener(this);}// 初始化动作模式和列表选择模式mActionMode = mode;mNotesListAdapter.setChoiceMode(true);mNotesListView.setLongClickable(false);mAddNewNote.setVisibility(View.GONE);// 设置自定义视图并初始化下拉菜单View customView = LayoutInflater.from(NotesListActivity.this).inflate(R.layout.note_list_dropdown_menu, null);mode.setCustomView(customView);mDropDownMenu = new DropdownMenu(NotesListActivity.this,(Button) customView.findViewById(R.id.selection_menu),R.menu.note_list_dropdown);// 设置下拉菜单项点击监听器mDropDownMenu.setOnDropdownMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() {public boolean onMenuItemClick(MenuItem item) {mNotesListAdapter.selectAll(!mNotesListAdapter.isAllSelected());updateMenu();return true;}});return true;}/*** 更新动作模式下的菜单项。*/private void updateMenu() {int selectedCount = mNotesListAdapter.getSelectedCount();// 更新下拉菜单标题String format = getResources().getString(R.string.menu_select_title, selectedCount);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 {item.setChecked(false);item.setTitle(R.string.menu_select_all);}}}/*** 准备动作模式时的回调方法。** @param mode 动作模式实例。* @param menu 菜单实例。* @return 返回false，表示未进行任何操作。*/public boolean onPrepareActionMode(ActionMode mode, Menu menu) {// TODO Auto-generated method stubreturn false;}/*** 点击动作模式中的菜单项时的回调方法。** @param mode 动作模式实例。* @param item 被点击的菜单项。* @return 返回false，表示未进行任何操作。*/public boolean onActionItemClicked(ActionMode mode, MenuItem item) {// TODO Auto-generated method stubreturn false;}/*** 销毁动作模式时的回调方法。** @param mode 动作模式实例。*/public void onDestroyActionMode(ActionMode mode) {// 还原列表选择模式和设置mNotesListAdapter.setChoiceMode(false);mNotesListView.setLongClickable(true);mAddNewNote.setVisibility(View.VISIBLE);}public void finishActionMode() {mActionMode.finish();}/*** 处理列表项选择状态变化的回调方法。** @param mode     动作模式实例。* @param position 列表中被改变选择状态的项的位置。* @param id       项的ID。* @param checked  项的新选择状态。*/public void onItemCheckedStateChanged(ActionMode mode, int position, long id,boolean checked) {// 更新列表项的选择状态并更新菜单mNotesListAdapter.setCheckedItem(position, checked);updateMenu();}/*** 处理菜单项点击事件的回调方法。** @param item 被点击的菜单项。* @return 如果已处理点击事件，返回true；否则返回false。*/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执行相应操作switch (item.getItemId()) {case R.id.delete:// 显示删除确认对话框AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);builder.setTitle(getString(R.string.alert_title_delete));builder.setIcon(android.R.drawable.ic_dialog_alert);builder.setMessage(getString(R.string.alert_message_delete_notes,mNotesListAdapter.getSelectedCount()));builder.setPositiveButton(android.R.string.ok,new DialogInterface.OnClickListener() {public void onClick(DialogInterface dialog,int which) {batchDelete();}});builder.setNegativeButton(android.R.string.cancel, null);builder.show();break;case R.id.move:// 启动查询目标文件夹的操作startQueryDestinationFolders();break;default:return false;}return true;}}/*** 为“新建笔记”按钮添加触摸监听器的内部类，实现点击和拖动事件的处理。*/private class NewNoteOnTouchListener implements OnTouchListener {/*** 处理触摸事件。** @param v     触摸的视图。* @param event 触摸事件。* @return 如果事件被处理则返回true，否则返回false。*/public boolean onTouch(View v, MotionEvent event) {// 根据触摸事件的动作进行不同的处理switch (event.getAction()) {case MotionEvent.ACTION_DOWN: {// 获取屏幕高度和“新建笔记”视图的高度Display display = getWindowManager().getDefaultDisplay();int screenHeight = display.getHeight();int newNoteViewHeight = mAddNewNote.getHeight();int start = screenHeight - newNoteViewHeight;int eventY = start + (int) event.getY();// 如果当前状态为子文件夹编辑状态，需减去标题栏的高度if (mState == ListEditState.SUB_FOLDER) {eventY -= mTitleBar.getHeight();start -= mTitleBar.getHeight();}// 当点击到“新建笔记”按钮透明部分时，将事件分发给背后的列表视图// 这里使用了一种硬编码的方式处理透明部分的点击，依赖于当前的背景公式if (event.getY() < (event.getX() * (-0.12) + 94)) {View view = mNotesListView.getChildAt(mNotesListView.getChildCount() - 1- mNotesListView.getFooterViewsCount());if (view != null && view.getBottom() > start&& (view.getTop() < (start + 94))) {mOriginY = (int) event.getY();mDispatchY = eventY;event.setLocation(event.getX(), mDispatchY);mDispatch = true;return mNotesListView.dispatchTouchEvent(event);}}break;}case MotionEvent.ACTION_MOVE: {// 如果正在分发触摸事件，则更新事件的位置并继续分发if (mDispatch) {mDispatchY += (int) event.getY() - mOriginY;event.setLocation(event.getX(), mDispatchY);return mNotesListView.dispatchTouchEvent(event);}break;}default: {// 当触摸动作结束或取消时，停止分发事件if (mDispatch) {event.setLocation(event.getX(), mDispatchY);mDispatch = false;return mNotesListView.dispatchTouchEvent(event);}break;}}// 如果事件未被分发，则返回falsereturn false;}};/*** 异步查询笔记列表。* 根据当前文件夹ID选择不同的查询条件，启动一个后台查询处理该查询。*/private void startAsyncNotesListQuery() {// 根据当前文件夹ID选择查询条件String selection = (mCurrentFolderId == Notes.ID_ROOT_FOLDER) ? ROOT_FOLDER_SELECTION: NORMAL_SELECTION;// 启动查询，排序方式为类型降序，修改日期降序mBackgroundQueryHandler.startQuery(FOLDER_NOTE_LIST_QUERY_TOKEN, null,Notes.CONTENT_NOTE_URI, NoteItemData.PROJECTION, selection, new String[]{String.valueOf(mCurrentFolderId)}, NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC");}/*** 处理后台查询的类。* 继承自AsyncQueryHandler，用于处理异步查询完成后的操作。*/private final class BackgroundQueryHandler extends AsyncQueryHandler {public BackgroundQueryHandler(ContentResolver contentResolver) {super(contentResolver);}/*** 查询完成时的处理逻辑。* 根据查询标记的不同，执行不同的操作，如更新笔记列表或显示文件夹列表。** @param token  查询标记，用于区分不同的查询。* @param cookie 查询时传入的附加对象。* @param cursor 查询结果的游标。*/@Overrideprotected 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);} else {Log.e(TAG, "Query folder failed");}break;default:// 对未知标记不做处理return;}}}/*** 显示文件夹列表的菜单。* 使用查询结果构建一个对话框，让用户选择一个文件夹。** @param cursor 查询结果的游标，包含文件夹信息。*/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() {/*** 用户选择文件夹时的处理逻辑。* 将选中的笔记移动到用户选择的文件夹中，并给出反馈。** @param dialog 对话框实例。* @param which  用户选择的项的索引。*/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();}});builder.show();}/*** 创建新的笔记。* 启动一个活动用于编辑新笔记或编辑现有笔记。*/private void createNewNote() {// 构建意图并指定动作为插入或编辑，以及初始文件夹IDIntent 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);}/*** 批量删除笔记的函数。根据当前是否处于同步模式，采取不同的删除策略：如果不处于同步模式，则直接删除笔记；如果处于同步模式，则将笔记移动到回收站文件夹。* 执行删除操作后，会更新相应的widgets。*/private void batchDelete() {new AsyncTask<Void, Void, HashSet<AppWidgetAttribute>>() {// 在后台执行任务，获取选中的widgets并执行删除操作protected HashSet<AppWidgetAttribute> doInBackground(Void... unused) {// 获取当前选中的widgetsHashSet<AppWidgetAttribute> widgets = mNotesListAdapter.getSelectedWidget();if (!isSyncMode()) {// 如果当前不处于同步模式，直接删除笔记if (DataUtils.batchDeleteNotes(mContentResolver, mNotesListAdapter.getSelectedItemIds())) {// 删除成功无需额外操作} else {// 删除失败，记录错误Log.e(TAG, "Delete notes error, should not happens");}} else {// 如果处于同步模式，将笔记移动到回收站文件夹if (!DataUtils.batchMoveToFolder(mContentResolver, mNotesListAdapter.getSelectedItemIds(), Notes.ID_TRASH_FOLER)) {// 移动失败，记录错误Log.e(TAG, "Move notes to trash folder error, should not happens");}}return widgets;}// 删除操作完成后，在UI线程执行后续操作@Overrideprotected void onPostExecute(HashSet<AppWidgetAttribute> widgets) {// 遍历所有受影响的widgets，对有效的widgets进行更新if (widgets != null) {for (AppWidgetAttribute widget : widgets) {if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID&& widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) {// 更新有效的widgetupdateWidget(widget.widgetId, widget.widgetType);}}}// 结束动作模式mModeCallBack.finishActionMode();}}.execute();}/*** 删除指定的文件夹。* 如果是在同步模式下，文件夹会被移动到回收站，否则直接删除。* 同时，也会更新与该文件夹相关的所有小部件。** @param folderId 要删除的文件夹ID。*/private void deleteFolder(long folderId) {// 根据ID判断是否为根文件夹，根文件夹不能被删除if (folderId == Notes.ID_ROOT_FOLDER) {Log.e(TAG, "Wrong folder id, should not happen " + folderId);return;}HashSet<Long> ids = new HashSet<Long>();ids.add(folderId);// 获取与文件夹相关联的小部件信息HashSet<AppWidgetAttribute> widgets = DataUtils.getFolderNoteWidget(mContentResolver,folderId);if (!isSyncMode()) {// 非同步模式下直接删除文件夹DataUtils.batchDeleteNotes(mContentResolver, ids);} else {// 同步模式下将文件夹移动到回收站DataUtils.batchMoveToFolder(mContentResolver, ids, Notes.ID_TRASH_FOLER);}// 更新相关小部件if (widgets != null) {for (AppWidgetAttribute widget : widgets) {// 有效的小部件才进行更新if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID&& widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) {updateWidget(widget.widgetId, widget.widgetType);}}}}/*** 打开指定的笔记节点进行编辑。** @param data 包含要打开的笔记节点信息的对象。*/private void openNode(NoteItemData data) {// 构造Intent并设置动作和额外数据，然后启动ActivityIntent intent = new Intent(this, NoteEditActivity.class);intent.setAction(Intent.ACTION_VIEW);intent.putExtra(Intent.EXTRA_UID, data.getId());this.startActivityForResult(intent, REQUEST_CODE_OPEN_NODE);}/*** 打开指定的文件夹，并加载其笔记列表。* 根据文件夹ID的不同，更新UI状态，包括标题和新增笔记按钮的可见性。** @param data 包含要打开的文件夹信息的对象。*/private void openFolder(NoteItemData data) {// 设置当前文件夹ID并启动异步查询mCurrentFolderId = data.getId();startAsyncNotesListQuery();// 根据文件夹ID更新UI状态if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {mState = ListEditState.CALL_RECORD_FOLDER;mAddNewNote.setVisibility(View.GONE);} else {mState = ListEditState.SUB_FOLDER;}// 更新标题栏显示if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {mTitleBar.setText(R.string.call_record_folder_name);} else {mTitleBar.setText(data.getSnippet());}mTitleBar.setVisibility(View.VISIBLE);}/*** 点击事件的处理方法。* 目前仅处理新建笔记按钮的点击事件。** @param v 被点击的视图对象。*/public void onClick(View v) {// 根据视图ID执行相应的操作switch (v.getId()) {case R.id.btn_new_note:createNewNote();break;default:break;}}/*** 显示软键盘。*/private void showSoftInput() {InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);if (inputMethodManager != null) {inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);}}/*** 隐藏软键盘。** @param view 触发隐藏软键盘的视图。*/private void hideSoftInput(View view) {InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);}/*** 显示创建或修改文件夹的对话框。** @param create 如果为true，则为创建文件夹；如果为false，则为修改文件夹。*/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);final EditText etName = (EditText) view.findViewById(R.id.et_foler_name);showSoftInput(); // 显示软键盘if (!create) {// 如果是修改文件夹if (mFocusNoteDataItem != null) {etName.setText(mFocusNoteDataItem.getSnippet()); // 设置当前文件夹名称builder.setTitle(getString(R.string.menu_folder_change_name)); // 设置对话框标题} else {Log.e(TAG, "The long click data item is null"); // 日志记录，长按的数据项为nullreturn;}} else {// 如果是创建文件夹etName.setText(""); // 清空输入框内容builder.setTitle(this.getString(R.string.menu_create_folder)); // 设置对话框标题}// 设置对话框的确定和取消按钮builder.setPositiveButton(android.R.string.ok, null);builder.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {public void onClick(DialogInterface dialog, int which) {hideSoftInput(etName); // 点击取消时隐藏软键盘}});final Dialog dialog = builder.setView(view).show(); // 显示对话框final Button positive = (Button) dialog.findViewById(android.R.id.button1); // 获取确定按钮positive.setOnClickListener(new OnClickListener() {public void onClick(View v) {hideSoftInput(etName); // 隐藏软键盘String name = etName.getText().toString(); // 获取输入的文件夹名称if (DataUtils.checkVisibleFolderName(mContentResolver, name)) { // 检查文件夹名称是否已存在Toast.makeText(NotesListActivity.this, getString(R.string.folder_exist, name),Toast.LENGTH_LONG).show(); // 显示文件夹已存在的提示etName.setSelection(0, etName.length()); // 选中输入框中的所有文本return;}if (!create) {// 如果是修改文件夹if (!TextUtils.isEmpty(name)) { // 验证输入的文件夹名称不为空ContentValues values = new ContentValues();values.put(NoteColumns.SNIPPET, name); // 设置新的文件夹名称values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER); // 设置类型为文件夹values.put(NoteColumns.LOCAL_MODIFIED, 1); // 标记为已修改mContentResolver.update(Notes.CONTENT_NOTE_URI, values, NoteColumns.ID+ "=?", new String[]{String.valueOf(mFocusNoteDataItem.getId())}); // 更新数据库中的文件夹信息}} else if (!TextUtils.isEmpty(name)) { // 如果是创建文件夹ContentValues values = new ContentValues();values.put(NoteColumns.SNIPPET, name); // 设置文件夹名称values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER); // 设置类型为文件夹mContentResolver.insert(Notes.CONTENT_NOTE_URI, values); // 在数据库中插入新的文件夹信息}dialog.dismiss(); // 关闭对话框}});// 初始状态下，如果输入框为空，则禁用确定按钮if (TextUtils.isEmpty(etName.getText())) {positive.setEnabled(false);}// 监听输入框文本变化，以动态启用或禁用确定按钮etName.addTextChangedListener(new TextWatcher() {public void beforeTextChanged(CharSequence s, int start, int count, int after) {// 空实现}public void onTextChanged(CharSequence s, int start, int before, int count) {if (TextUtils.isEmpty(etName.getText())) { // 当输入框为空时，禁用确定按钮positive.setEnabled(false);} else { // 当输入框不为空时，启用确定按钮positive.setEnabled(true);}}public void afterTextChanged(Editable s) {// 空实现}});}/*** 当用户按下返回键时调用的方法，根据当前状态执行不同的操作。* 在子文件夹状态下，返回根文件夹并显示笔记列表；* 在通话记录文件夹状态下，也返回根文件夹但显示添加新笔记按钮；* 在笔记列表状态下，执行父类的onBackPressed方法，通常是退出或返回上一级。*/@Overridepublic void onBackPressed() {switch (mState) {case SUB_FOLDER:// 从子文件夹状态返回到根文件夹的笔记列表状态mCurrentFolderId = Notes.ID_ROOT_FOLDER;mState = ListEditState.NOTE_LIST;startAsyncNotesListQuery();mTitleBar.setVisibility(View.GONE);break;case CALL_RECORD_FOLDER:// 从通话记录文件夹状态返回到根文件夹的笔记列表状态，并显示添加新笔记按钮mCurrentFolderId = Notes.ID_ROOT_FOLDER;mState = ListEditState.NOTE_LIST;mAddNewNote.setVisibility(View.VISIBLE);mTitleBar.setVisibility(View.GONE);startAsyncNotesListQuery();break;case NOTE_LIST:// 在笔记列表状态下，执行父类的返回操作super.onBackPressed();break;default:// 对于其他状态，不执行任何操作break;}}/*** 更新小部件显示。* 根据传入的小部件类型，设置对应的Provider并发送更新广播。** @param appWidgetId   小部件ID* @param appWidgetType 小部件类型*/private void updateWidget(int appWidgetId, int appWidgetType) {Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);// 根据小部件类型设置Providerif (appWidgetType == Notes.TYPE_WIDGET_2X) {intent.setClass(this, NoteWidgetProvider_2x.class);} else if (appWidgetType == Notes.TYPE_WIDGET_4X) {intent.setClass(this, NoteWidgetProvider_4x.class);} else {Log.e(TAG, "Unspported widget type");return;}intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[]{appWidgetId});sendBroadcast(intent);setResult(RESULT_OK, intent);}/*** 文件夹列表的上下文菜单创建监听器。* 在焦点笔记项不为空时，添加查看、删除和重命名菜单项。*/private final OnCreateContextMenuListener mFolderOnCreateContextMenuListener = new OnCreateContextMenuListener() {public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {if (mFocusNoteDataItem != null) {menu.setHeaderTitle(mFocusNoteDataItem.getSnippet());menu.add(0, MENU_FOLDER_VIEW, 0, R.string.menu_folder_view);menu.add(0, MENU_FOLDER_DELETE, 0, R.string.menu_folder_delete);menu.add(0, MENU_FOLDER_CHANGE_NAME, 0, R.string.menu_folder_change_name);}}};/*** 上下文菜单关闭时的回调方法。* 在列表视图中取消上下文菜单的监听器。** @param menu 被关闭的菜单对象*/@Overridepublic void onContextMenuClosed(Menu menu) {if (mNotesListView != null) {mNotesListView.setOnCreateContextMenuListener(null);}super.onContextMenuClosed(menu);}/*** 当上下文菜单中的项目被选择时调用。** @param item 被选择的菜单项。* @return 如果事件已成功处理，则返回true；否则如果事件未处理，则返回false。*/@Overridepublic boolean onContextItemSelected(MenuItem item) {if (mFocusNoteDataItem == null) {Log.e(TAG, "The long click data item is null");return false;}switch (item.getItemId()) {case MENU_FOLDER_VIEW:openFolder(mFocusNoteDataItem); // 打开指定的文件夹break;case MENU_FOLDER_DELETE:// 显示删除文件夹的确认对话框AlertDialog.Builder builder = new AlertDialog.Builder(this);builder.setTitle(getString(R.string.alert_title_delete));builder.setIcon(android.R.drawable.ic_dialog_alert);builder.setMessage(getString(R.string.alert_message_delete_folder));builder.setPositiveButton(android.R.string.ok,new DialogInterface.OnClickListener() {public void onClick(DialogInterface dialog, int which) {deleteFolder(mFocusNoteDataItem.getId()); // 确认后删除文件夹}});builder.setNegativeButton(android.R.string.cancel, null);builder.show();break;case MENU_FOLDER_CHANGE_NAME:showCreateOrModifyFolderDialog(false); // 显示修改文件夹名称的对话框break;default:break;}return true;}/*** 准备选项菜单。** @param menu 菜单对象。* @return 总是返回true。*/@Overridepublic boolean onPrepareOptionsMenu(Menu menu) {menu.clear(); // 清除之前的菜单项// 根据当前状态加载不同的菜单布局if (mState == ListEditState.NOTE_LIST) {getMenuInflater().inflate(R.menu.note_list, menu);// 设置同步或取消同步菜单项的标题menu.findItem(R.id.menu_sync).setTitle(GTaskSyncService.isSyncing() ? R.string.menu_sync_cancel : R.string.menu_sync);} else if (mState == ListEditState.SUB_FOLDER) {getMenuInflater().inflate(R.menu.sub_folder, menu);} else if (mState == ListEditState.CALL_RECORD_FOLDER) {getMenuInflater().inflate(R.menu.call_record_folder, menu);} else {Log.e(TAG, "Wrong state:" + mState);}return true;}/*** 处理选项菜单项的选择。** @param item 被选择的菜单项。* @return 如果事件已成功处理，则返回true；否则如果事件未处理，则返回false。*/@Overridepublic boolean onOptionsItemSelected(MenuItem item) {switch (item.getItemId()) {case R.id.menu_new_folder: {showCreateOrModifyFolderDialog(true); // 显示创建新文件夹的对话框break;}case R.id.menu_export_text: {exportNoteToText(); // 导出笔记为文本break;}case R.id.menu_sync: {// 处理同步菜单项的点击事件if (isSyncMode()) {if (TextUtils.equals(item.getTitle(), getString(R.string.menu_sync))) {GTaskSyncService.startSync(this);} else {GTaskSyncService.cancelSync(this);}} else {startPreferenceActivity();}break;}case R.id.menu_setting: {startPreferenceActivity(); // 打开设置界面break;}case R.id.menu_new_note: {createNewNote(); // 创建新笔记break;}case R.id.menu_search:onSearchRequested(); // 触发搜索请求break;default:break;}return true;}/*** 处理搜索请求。** @return 总是返回true。*/@Overridepublic boolean onSearchRequested() {startSearch(null, false, null /* appData */, false);return true;}/*** 将笔记导出为文本文件。* 在后台任务中执行导出操作，并根据操作结果展示不同的对话框。*/private void exportNoteToText() {final BackupUtils backup = BackupUtils.getInstance(NotesListActivity.this);new AsyncTask<Void, Void, Integer>() {@Overrideprotected Integer doInBackground(Void... unused) {// 执行导出操作return backup.exportToText();}@Overrideprotected void onPostExecute(Integer result) {// 根据导出结果展示不同的对话框if (result == BackupUtils.STATE_SD_CARD_UNMOUONTED) {showExportFailedDialog(NotesListActivity.this.getString(R.string.failed_sdcard_export),NotesListActivity.this.getString(R.string.error_sdcard_unmounted));} else if (result == BackupUtils.STATE_SUCCESS) {showExportSuccessDialog(NotesListActivity.this.getString(R.string.success_sdcard_export),backup.getExportedTextFileName(), backup.getExportedTextFileDir());} else if (result == BackupUtils.STATE_SYSTEM_ERROR) {showExportFailedDialog(NotesListActivity.this.getString(R.string.failed_sdcard_export),NotesListActivity.this.getString(R.string.error_sdcard_export));}}}.execute();}/*** 检查当前是否为同步模式。** @return 如果已配置同步账户名则返回true，否则返回false。*/private boolean isSyncMode() {return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;}/*** 启动设置活动。* 用于打开设置界面。*/private void startPreferenceActivity() {Activity from = getParent() != null ? getParent() : this;Intent intent = new Intent(from, NotesPreferenceActivity.class);from.startActivityIfNeeded(intent, -1);}/*** 列表项点击监听器。* 处理列表项的点击事件，根据不同的状态和项类型执行相应的操作。*/private class OnListItemClickListener implements OnItemClickListener {public void onItemClick(AdapterView<?> parent, View view, int position, long id) {if (view instanceof NotesListItem) {NoteItemData item = ((NotesListItem) view).getItemData();if (mNotesListAdapter.isInChoiceMode()) {// 在选择模式下处理项的点击事件if (item.getType() == Notes.TYPE_NOTE) {position = position - mNotesListView.getHeaderViewsCount();mModeCallBack.onItemCheckedStateChanged(null, position, id,!mNotesListAdapter.isSelectedItem(position));}return;}// 根据当前状态处理项的点击事件switch (mState) {case NOTE_LIST:if (item.getType() == Notes.TYPE_FOLDER|| item.getType() == Notes.TYPE_SYSTEM) {openFolder(item);} else if (item.getType() == Notes.TYPE_NOTE) {openNode(item);} else {Log.e(TAG, "Wrong note type in NOTE_LIST");}break;case SUB_FOLDER:case CALL_RECORD_FOLDER:if (item.getType() == Notes.TYPE_NOTE) {openNode(item);} else {Log.e(TAG, "Wrong note type in SUB_FOLDER");}break;default:break;}}}}/*** 启动查询目标文件夹。* 根据当前状态查询并显示文件夹列表。*/private void startQueryDestinationFolders() {String selection = NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>? AND " + NoteColumns.ID + "<>?";selection = (mState == ListEditState.NOTE_LIST) ? selection :"(" + selection + ") OR (" + NoteColumns.ID + "=" + Notes.ID_ROOT_FOLDER + ")";mBackgroundQueryHandler.startQuery(FOLDER_LIST_QUERY_TOKEN,null,Notes.CONTENT_NOTE_URI,FoldersListAdapter.PROJECTION,selection,new String[]{String.valueOf(Notes.TYPE_FOLDER),String.valueOf(Notes.ID_TRASH_FOLER),String.valueOf(mCurrentFolderId)},NoteColumns.MODIFIED_DATE + " DESC");}/*** 长按列表项时的处理。* 根据不同的项类型启动选择模式或显示上下文菜单。** @return 总是返回false。*/public boolean onItemLongClick(AdapterView<?> parent, View view, int position, long id) {if (view instanceof 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);} else {Log.e(TAG, "startActionMode fails");}} else if (mFocusNoteDataItem.getType() == Notes.TYPE_FOLDER) {// 长按文件夹项时设置上下文菜单监听器mNotesListView.setOnCreateContextMenuListener(mFolderOnCreateContextMenuListener);}}return false;}/*** 显示导出失败的对话框。** @param title   对话框标题* @param message 对话框消息内容*/private void showExportFailedDialog(String title, String message) {AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);builder.setTitle(title);builder.setMessage(message);builder.setPositiveButton(android.R.string.ok, null);builder.show();}/*** 显示导出成功的对话框。** @param title    对话框标题* @param fileName 导出文件的名称* @param fileDir  导出文件的目录*/private void showExportSuccessDialog(String title, String fileName, String fileDir) {AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);builder.setTitle(title);builder.setMessage(NotesListActivity.this.getString(R.string.format_exported_file_location, fileName, fileDir));builder.setPositiveButton(android.R.string.ok, null);builder.show();}}

11 NoteEditText

/** Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)** Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at**        http://www.apache.org/licenses/LICENSE-2.0** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.* See the License for the specific language governing permissions and* limitations under the License.*/package net.micode.notes.ui;import android.content.Context;
import android.graphics.Rect;
import android.text.Layout;
import android.text.Selection;
import android.text.Spanned;
import android.text.TextUtils;
import android.text.style.URLSpan;
import android.util.AttributeSet;
import android.util.Log;
import android.view.ContextMenu;
import android.view.KeyEvent;
import android.view.MenuItem;
import android.view.MenuItem.OnMenuItemClickListener;
import android.view.MotionEvent;
import android.widget.EditText;import net.micode.notes.R;import java.util.HashMap;
import java.util.Map;/*** 自定义的可编辑文本视图，支持文本变化监听、删除和新增文本事件。*/
public class NoteEditText extends EditText {private static final String TAG = "NoteEditText";private int mIndex; // 当前文本视图的索引private int mSelectionStartBeforeDelete; // 删除操作前的选择起始位置private static final String SCHEME_TEL = "tel:";private static final String SCHEME_HTTP = "http:";private static final String SCHEME_EMAIL = "mailto:";// URL方案与对应操作资源ID的映射private static final Map<String, Integer> sSchemaActionResMap = new HashMap<String, Integer>();static {sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel);sSchemaActionResMap.put(SCHEME_HTTP, R.string.note_link_web);sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email);}/*** 文本视图变化监听接口。*/public interface OnTextViewChangeListener {/*** 当按下删除键且文本为空时，删除当前文本视图。*/void onEditTextDelete(int index, String text);/*** 当按下回车键时，新增一个文本视图。*/void onEditTextEnter(int index, String text);/*** 当文本变化时，隐藏或显示项目选项。*/void onTextChange(int index, boolean hasText);}private OnTextViewChangeListener mOnTextViewChangeListener;/*** 构造函数，初始化编辑文本视图。** @param context 上下文对象*/public NoteEditText(Context context) {super(context, null);mIndex = 0;}/*** 设置当前文本视图的索引。** @param index 当前文本视图的索引*/public void setIndex(int index) {mIndex = index;}/*** 设置文本视图变化监听器。** @param listener 文本视图变化监听器*/public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {mOnTextViewChangeListener = listener;}/*** 构造函数，初始化编辑文本视图。** @param context 上下文对象* @param attrs   属性集*/public NoteEditText(Context context, AttributeSet attrs) {super(context, attrs, android.R.attr.editTextStyle);}/*** 构造函数，初始化编辑文本视图。** @param context  上下文对象* @param attrs    属性集* @param defStyle 样式*/public NoteEditText(Context context, AttributeSet attrs, int defStyle) {super(context, attrs, defStyle);}/*** 处理触摸事件，调整光标位置。*/@Overridepublic boolean onTouchEvent(MotionEvent event) {switch (event.getAction()) {case MotionEvent.ACTION_DOWN:// 计算触摸位置相对于文本的偏移量，并调整光标位置int x = (int) event.getX();int y = (int) event.getY();x -= getTotalPaddingLeft();y -= getTotalPaddingTop();x += getScrollX();y += getScrollY();Layout layout = getLayout();int line = layout.getLineForVertical(y);int off = layout.getOffsetForHorizontal(line, x);Selection.setSelection(getText(), off);break;}return super.onTouchEvent(event);}/*** 处理键盘按下事件。*/@Overridepublic boolean onKeyDown(int keyCode, KeyEvent event) {switch (keyCode) {case KeyEvent.KEYCODE_ENTER:// 处理回车键事件，准备新增文本视图if (mOnTextViewChangeListener != null) {return false;}break;case KeyEvent.KEYCODE_DEL:// 记录删除操作前的选择位置mSelectionStartBeforeDelete = getSelectionStart();break;default:break;}return super.onKeyDown(keyCode, event);}/*** 处理键盘弹起事件。*/@Overridepublic boolean onKeyUp(int keyCode, KeyEvent event) {switch (keyCode) {case KeyEvent.KEYCODE_DEL:// 处理删除键事件，若为首个文本且非空，则删除当前文本if (mOnTextViewChangeListener != null) {if (0 == mSelectionStartBeforeDelete && mIndex != 0) {mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString());return true;}} else {Log.d(TAG, "OnTextViewChangeListener was not seted");}break;case KeyEvent.KEYCODE_ENTER:// 处理回车键事件，新增文本视图if (mOnTextViewChangeListener != null) {int selectionStart = getSelectionStart();String text = getText().subSequence(selectionStart, length()).toString();setText(getText().subSequence(0, selectionStart));mOnTextViewChangeListener.onEditTextEnter(mIndex + 1, text);} else {Log.d(TAG, "OnTextViewChangeListener was not seted");}break;default:break;}return super.onKeyUp(keyCode, event);}/*** 当焦点变化时，通知文本变化情况。*/@Overrideprotected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {if (mOnTextViewChangeListener != null) {if (!focused && TextUtils.isEmpty(getText())) {mOnTextViewChangeListener.onTextChange(mIndex, false);} else {mOnTextViewChangeListener.onTextChange(mIndex, true);}}super.onFocusChanged(focused, direction, previouslyFocusedRect);}/*** 创建上下文菜单，支持点击URL跳转。*/@Overrideprotected void onCreateContextMenu(ContextMenu menu) {if (getText() instanceof Spanned) {int selStart = getSelectionStart();int selEnd = getSelectionEnd();int min = Math.min(selStart, selEnd);int max = Math.max(selStart, selEnd);final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class);if (urls.length == 1) {int defaultResId = 0;for (String schema : sSchemaActionResMap.keySet()) {if (urls[0].getURL().indexOf(schema) >= 0) {defaultResId = sSchemaActionResMap.get(schema);break;}}if (defaultResId == 0) {defaultResId = R.string.note_link_other;}menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener(new OnMenuItemClickListener() {public boolean onMenuItemClick(MenuItem item) {// 跳转到URL指向的页面urls[0].onClick(NoteEditText.this);return true;}});}}super.onCreateContextMenu(menu);}
}

12 NotesListAdapter

包声明：package net.micode.notes.ui; 声明了该类所在的包。
导入语句：导入了一系列Java和Android相关的类，包括上下文、游标、日志输出、视图操作、游标适配器、集合操作等。
类声明：public class NotesListAdapter extends CursorAdapter { 声明了一个名为 NotesListAdapter 的公共类，继承自 CursorAdapter。
常量声明：private static final String TAG = "NotesListAdapter"; 声明了一个私有静态最终的字符串 TAG，用于日志输出。
成员变量：
private Context mContext; 声明了一个私有上下文对象 mContext。
private HashMap<Integer, Boolean> mSelectedIndex; 声明了一个私有哈希映射 mSelectedIndex，用于存储选中项的索引和状态。
private int mNotesCount; 声明了一个私有整数 mNotesCount，用于存储笔记总数。
private boolean mChoiceMode; 声明了一个私有布尔值 mChoiceMode，用于存储选择模式标志。
内部类声明：public static class AppWidgetAttribute { ... } 声明了一个公共静态内部类 AppWidgetAttribute，用于存储与小部件相关的数据。
构造函数：public NotesListAdapter(Context context) { ... } 声明了类的构造函数，接受上下文对象作为参数，并初始化成员变量。
方法：
@Override public View newView(Context context, Cursor cursor, ViewGroup parent) { ... } 重写了 newView 方法，用于创建新的列表项视图。
@Override public void bindView(View view, Context context, Cursor cursor) { ... } 重写了 bindView 方法，用于绑定数据到视图。
public void setCheckedItem(final int position, final boolean checked) { ... } 声明了一个公共方法 setCheckedItem，用于设置指定位置的项为选中或未选中状态。
public boolean isInChoiceMode() { ... } 声明了一个公共方法 isInChoiceMode，用于获取当前是否处于选择模式。
public void setChoiceMode(boolean mode) { ... } 声明了一个公共方法 setChoiceMode，用于设置选择模式。
public void selectAll(boolean checked) { ... } 声明了一个公共方法 selectAll，用于全选或全不选。
public HashSet<Long> getSelectedItemIds() { ... } 声明了一个公共方法 getSelectedItemIds，用于获取所有选中项的ID集合。
public HashSet<AppWidgetAttribute> getSelectedWidget() { ... } 声明了一个公共方法 getSelectedWidget，用于获取所有选中小部件的属性集合。
public int getSelectedCount() { ... } 声明了一个公共方法 getSelectedCount，用于获取选中项的数量。
public boolean isAllSelected() { ... } 声明了一个公共方法 isAllSelected，用于判断是否全部选中。
public boolean isSelectedItem(final int position) { ... } 声明了一个公共方法 isSelectedItem，用于检查指定位置的项是否被选中。
@Override protected void onContentChanged() { ... } 重写了 onContentChanged 方法，用于当内容改变时调用，更新笔记数量。
@Override public void changeCursor(Cursor cursor) { ... } 重写了 changeCursor 方法，用于当游标改变时调用，更新笔记数量。
private void calcNotesCount() { ... } 声明了一个私有方法 calcNotesCount，用于计算并更新笔记总数。

package net.micode.notes.ui; // 定义包名import android.content.Context; // 导入Context类，用于获取上下文
import android.database.Cursor; // 导入Cursor类，用于数据源游标
import android.util.Log; // 导入Log类，用于日志输出
import android.view.View; // 导入View类，用于视图操作
import android.view.ViewGroup; // 导入ViewGroup类，用于视图组操作
import android.widget.CursorAdapter; // 导入CursorAdapter类，用于游标适配器import net.micode.notes.data.Notes; // 导入Notes类，用于笔记数据操作import java.util.Collection; // 导入Collection类，用于集合操作
import java.util.HashMap; // 导入HashMap类，用于哈希映射
import java.util.HashSet; // 导入HashSet类，用于哈希集合
import java.util.Iterator; // 导入Iterator类，用于迭代器/*** 用于管理笔记列表的适配器，继承自CursorAdapter。*/
public class NotesListAdapter extends CursorAdapter { // 定义NotesListAdapter类，继承自CursorAdapterprivate static final String TAG = "NotesListAdapter"; // 定义日志标签private Context mContext; // 上下文对象// 用于存储选中项的索引和状态private HashMap<Integer, Boolean> mSelectedIndex; // 选中项索引和状态的哈希映射private int mNotesCount; // 笔记总数private boolean mChoiceMode; // 选择模式标志/*** AppWidget属性容器，用于存储与小部件相关的数据。*/public static class AppWidgetAttribute { // 定义AppWidgetAttribute类public int widgetId; // 小部件IDpublic int widgetType; // 小部件类型}/*** 构造函数。** @param context 上下文对象*/public NotesListAdapter(Context context) { // 构造函数super(context, null); // 调用父类构造函数mSelectedIndex = new HashMap<Integer, Boolean>(); // 初始化选中项索引和状态的哈希映射mContext = context; // 赋值上下文对象mNotesCount = 0; // 初始化笔记总数}/*** 创建新的列表项视图。** @param context 上下文对象* @param cursor  数据游标* @param parent  父视图* @return 新的列表项视图*/@Overridepublic View newView(Context context, Cursor cursor, ViewGroup parent) { // 重写newView方法return new NotesListItem(context); // 返回新的列表项视图}/*** 绑定数据到视图。** @param view    列表项视图* @param context 上下文对象* @param cursor  数据游标*/@Overridepublic void bindView(View view, Context context, Cursor cursor) { // 重写bindView方法if (view instanceof NotesListItem) { // 判断视图是否为NotesListItem类型NoteItemData itemData = new NoteItemData(context, cursor); // 创建NoteItemData对象((NotesListItem) view).bind(context, itemData, mChoiceMode,isSelectedItem(cursor.getPosition())); // 绑定数据到视图}}/*** 设置指定位置的项为选中或未选中状态。** @param position 项的位置* @param checked  选中状态*/public void setCheckedItem(final int position, final boolean checked) { // 设置选中项方法mSelectedIndex.put(position, checked); // 更新选中项索引和状态notifyDataSetChanged(); // 通知数据集改变}/*** 获取当前是否处于选择模式。** @return 选择模式状态*/public boolean isInChoiceMode() { // 获取选择模式方法return mChoiceMode; // 返回选择模式状态}/*** 设置选择模式。** @param mode 选择模式状态*/public void setChoiceMode(boolean mode) { // 设置选择模式方法mSelectedIndex.clear(); // 清空选中项索引和状态mChoiceMode = mode; // 更新选择模式状态}/*** 全选或全不选。** @param checked 选中状态*/public void selectAll(boolean checked) { // 全选或全不选方法Cursor cursor = getCursor(); // 获取游标for (int i = 0; i < getCount(); i++) { // 遍历所有项if (cursor.moveToPosition(i)) { // 移动到指定位置if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) { // 判断是否为笔记类型setCheckedItem(i, checked); // 设置选中状态}}}}/*** 获取所有选中项的ID集合。** @return 选中项ID的HashSet*/public HashSet<Long> getSelectedItemIds() { // 获取选中项ID集合方法HashSet<Long> itemSet = new HashSet<Long>(); // 创建哈希集合for (Integer position : mSelectedIndex.keySet()) { // 遍历选中项索引if (mSelectedIndex.get(position) == true) { // 判断是否为选中状态Long id = getItemId(position); // 获取项IDif (id == Notes.ID_ROOT_FOLDER) { // 判断是否为根文件夹Log.d(TAG, "Wrong item id, should not happen"); // 输出日志} else {itemSet.add(id); // 添加到哈希集合}}}return itemSet; // 返回哈希集合}/*** 获取所有选中小部件的属性集合。** @return 选中小部件属性的HashSet*/public HashSet<AppWidgetAttribute> getSelectedWidget() { // 获取选中小部件属性集合方法HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>(); // 创建哈希集合for (Integer position : mSelectedIndex.keySet()) { // 遍历选中项索引if (mSelectedIndex.get(position) == true) { // 判断是否为选中状态Cursor c = (Cursor) getItem(position); // 获取游标if (c != null) { // 判断游标是否为空AppWidgetAttribute widget = new AppWidgetAttribute(); // 创建AppWidgetAttribute对象NoteItemData item = new NoteItemData(mContext, c); // 创建NoteItemData对象widget.widgetId = item.getWidgetId(); // 获取小部件IDwidget.widgetType = item.getWidgetType(); // 获取小部件类型itemSet.add(widget); // 添加到哈希集合} else {Log.e(TAG, "Invalid cursor"); // 输出日志return null; // 返回空}}}return itemSet; // 返回哈希集合}/*** 获取选中项的数量。** @return 选中项数量*/public int getSelectedCount() { // 获取选中项数量方法Collection<Boolean> values = mSelectedIndex.values(); // 获取选中项状态集合if (null == values) { // 判断集合是否为空return 0; // 返回0}Iterator<Boolean> iter = values.iterator(); // 获取迭代器int count = 0; // 初始化计数器while (iter.hasNext()) { // 遍历集合if (true == iter.next()) { // 判断是否为选中状态count++; // 计数器加1}}return count; // 返回计数器}/*** 判断是否全部选中。** @return 全部选中的状态*/public boolean isAllSelected() { // 判断是否全部选中方法int checkedCount = getSelectedCount(); // 获取选中项数量return (checkedCount != 0 && checkedCount == mNotesCount); // 判断是否全部选中}/*** 检查指定位置的项是否被选中。** @param position 项的位置* @return 选中状态*/public boolean isSelectedItem(final int position) { // 检查选中项方法if (null == mSelectedIndex.get(position)) { // 判断是否为空return false; // 返回未选中状态}return mSelectedIndex.get(position); // 返回选中状态}/*** 当内容改变时调用，更新笔记数量。*/@Overrideprotected void onContentChanged() { // 重写onContentChanged方法super.onContentChanged(); // 调用父类方法calcNotesCount(); // 计算笔记数量}/*** 当游标改变时调用，更新笔记数量。** @param cursor 新的游标*/@Overridepublic void changeCursor(Cursor cursor) { // 重写changeCursor方法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++; // 笔记总数加1}} else {Log.e(TAG, "Invalid cursor"); // 输出日志return; // 返回}}}
}

13 NotesListltem

包声明：package net.micode.notes.ui; 声明了该类所在的包。
导入语句：导入了一系列Java和Android相关的类，包括上下文、日期格式化、视图操作、复选框、图像显示、线性布局、文本显示等。
类声明：public class NotesListItem extends LinearLayout { 声明了一个名为 NotesListItem 的公共类，继承自 LinearLayout。
成员变量：
private ImageView mAlert; 声明了一个私有 ImageView 对象 mAlert，用于显示提醒图标。
private TextView mTitle; 声明了一个私有 TextView 对象 mTitle，用于显示笔记标题。
private TextView mTime; 声明了一个私有 TextView 对象 mTime，用于显示修改时间。
private TextView mCallName; 声明了一个私有 TextView 对象 mCallName，用于在通话记录笔记中显示通话名称。
private NoteItemData mItemData; 声明了一个私有 NoteItemData 对象 mItemData，用于绑定笔记数据。
private CheckBox mCheckBox; 声明了一个私有 CheckBox 对象 mCheckBox，用于多选模式。
构造函数：public NotesListItem(Context context) { ... } 声明了类的构造函数，接受上下文对象作为参数，并初始化视图组件。
方法：
public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) { ... } 声明了一个公共方法 bind，用于绑定数据到视图，根据数据设置视图状态。
private void setBackground(NoteItemData data) { ... } 声明了一个私有方法 setBackground，用于根据笔记数据设置列表项的背景资源。
public NoteItemData getItemData() { ... } 声明了一个公共方法 getItemData，用于获取绑定的笔记数据。


package net.micode.notes.ui; // 定义包名import android.content.Context; // 导入Context类，用于获取上下文
import android.text.format.DateUtils; // 导入DateUtils类，用于日期格式化
import android.view.View; // 导入View类，用于视图操作
import android.widget.CheckBox; // 导入CheckBox类，用于复选框
import android.widget.ImageView; // 导入ImageView类，用于图像显示
import android.widget.LinearLayout; // 导入LinearLayout类，用于线性布局
import android.widget.TextView; // 导入TextView类，用于文本显示import net.micode.notes.R; // 导入R类，用于资源引用
import net.micode.notes.data.Notes; // 导入Notes类，用于笔记数据操作
import net.micode.notes.tool.DataUtils; // 导入DataUtils类，用于数据处理
import net.micode.notes.tool.ResourceParser.NoteItemBgResources; // 导入NoteItemBgResources类，用于背景资源解析/** 该类表示一个笔记列表项，继承自LinearLayout，并包含了显示笔记各种信息的组件。* 它用于在UI中展示一个笔记或文件夹的条目。*/public class NotesListItem extends LinearLayout { // 定义NotesListItem类，继承自LinearLayoutprivate ImageView mAlert; // 用于显示提醒图标private TextView mTitle; // 显示笔记标题private TextView mTime; // 显示修改时间private TextView mCallName; // 在通话记录笔记中显示通话名称private NoteItemData mItemData; // 绑定的笔记数据private CheckBox mCheckBox; // 选择框，用于多选模式/** 构造函数，初始化视图组件。*/public NotesListItem(Context context) { // 构造函数super(context); // 调用父类构造函数inflate(context, R.layout.note_item, this); // 填充布局// 初始化视图组件mAlert = (ImageView) findViewById(R.id.iv_alert_icon); // 初始化提醒图标mTitle = (TextView) findViewById(R.id.tv_title); // 初始化标题mTime = (TextView) findViewById(R.id.tv_time); // 初始化时间mCallName = (TextView) findViewById(R.id.tv_name); // 初始化通话名称mCheckBox = (CheckBox) findViewById(android.R.id.checkbox); // 初始化复选框}/** 绑定数据到视图，根据数据设置视图状态。** @param context 上下文* @param data 要绑定的笔记数据* @param choiceMode 是否为选择模式* @param checked 是否选中*/public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) { // 绑定数据方法// 根据是否为选择模式和笔记类型，控制复选框的可见性和选中状态if (choiceMode && data.getType() == Notes.TYPE_NOTE) { // 判断是否为选择模式且为笔记类型mCheckBox.setVisibility(View.VISIBLE); // 显示复选框mCheckBox.setChecked(checked); // 设置复选框选中状态} else {mCheckBox.setVisibility(View.GONE); // 隐藏复选框}mItemData = data; // 赋值笔记数据// 根据笔记类型和状态，设置标题、提醒图标和背景if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) { // 判断是否为通话记录文件夹// 通话记录文件夹mCallName.setVisibility(View.GONE); // 隐藏通话名称mAlert.setVisibility(View.VISIBLE); // 显示提醒图标mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem); // 设置标题样式mTitle.setText(context.getString(R.string.call_record_folder_name)+ context.getString(R.string.format_folder_files_count, data.getNotesCount())); // 设置标题文本mAlert.setImageResource(R.drawable.call_record); // 设置提醒图标} else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) { // 判断是否为通话记录笔记// 通话记录笔记mCallName.setVisibility(View.VISIBLE); // 显示通话名称mCallName.setText(data.getCallName()); // 设置通话名称mTitle.setTextAppearance(context, R.style.TextAppearanceSecondaryItem); // 设置标题样式mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet())); // 设置标题文本if (data.hasAlert()) { // 判断是否有提醒mAlert.setImageResource(R.drawable.clock); // 设置提醒图标mAlert.setVisibility(View.VISIBLE); // 显示提醒图标} else {mAlert.setVisibility(View.GONE); // 隐藏提醒图标}} else {// 其他类型的笔记或文件夹mCallName.setVisibility(View.GONE); // 隐藏通话名称mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem); // 设置标题样式if (data.getType() == Notes.TYPE_FOLDER) { // 判断是否为文件夹mTitle.setText(data.getSnippet()+ context.getString(R.string.format_folder_files_count,data.getNotesCount())); // 设置标题文本mAlert.setVisibility(View.GONE); // 隐藏提醒图标} else {mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet())); // 设置标题文本if (data.hasAlert()) { // 判断是否有提醒mAlert.setImageResource(R.drawable.clock); // 设置提醒图标mAlert.setVisibility(View.VISIBLE); // 显示提醒图标} else {mAlert.setVisibility(View.GONE); // 隐藏提醒图标}}}// 设置时间显示mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate())); // 设置时间文本// 设置背景资源setBackground(data); // 设置背景}/** 根据笔记数据设置列表项的背景资源。*/private void setBackground(NoteItemData data) { // 设置背景方法int id = data.getBgColorId(); // 获取背景颜色IDif (data.getType() == Notes.TYPE_NOTE) { // 判断是否为笔记类型// 根据笔记的状态设置不同的背景资源if (data.isSingle() || data.isOneFollowingFolder()) { // 判断是否为单个笔记或紧跟文件夹的笔记setBackgroundResource(NoteItemBgResources.getNoteBgSingleRes(id)); // 设置单个笔记背景} else if (data.isLast()) { // 判断是否为最后一个笔记setBackgroundResource(NoteItemBgResources.getNoteBgLastRes(id)); // 设置最后一个笔记背景} else if (data.isFirst() || data.isMultiFollowingFolder()) { // 判断是否为第一个笔记或多个紧跟文件夹的笔记setBackgroundResource(NoteItemBgResources.getNoteBgFirstRes(id)); // 设置第一个笔记背景} else {setBackgroundResource(NoteItemBgResources.getNoteBgNormalRes(id)); // 设置普通笔记背景}} else {// 文件夹背景资源setBackgroundResource(NoteItemBgResources.getFolderBgRes()); // 设置文件夹背景}}/** 获取绑定的笔记数据。** @return 绑定的NoteItemData对象*/public NoteItemData getItemData() { // 获取笔记数据方法return mItemData; // 返回笔记数据}
}

14 NotesPreferenceActivity

/** 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.accounts.Account;
import android.accounts.AccountManager;
import android.app.ActionBar;
import android.app.AlertDialog;
import android.content.BroadcastReceiver;
import android.content.ContentValues;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.preference.Preference;
import android.preference.Preference.OnPreferenceClickListener;
import android.preference.PreferenceActivity;
import android.preference.PreferenceCategory;
import android.text.TextUtils;
import android.text.format.DateFormat;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;import net.micode.notes.R;
import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.gtask.remote.GTaskSyncService;public class NotesPreferenceActivity extends PreferenceActivity {// 常量定义部分：主要用于设置和同步相关的偏好设置键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_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 AUTHORITIES_FILTER_KEY = "authorities"; // 权限过滤键// 类成员变量定义部分：主要用于账户同步和UI更新private PreferenceCategory mAccountCategory; // 账户分类偏好项private GTaskReceiver mReceiver; // 接收同步任务的广播接收器private Account[] mOriAccounts; // 原始账户数组private boolean mHasAddedAccount; // 标记是否已添加新账户/*** 当设置Activity创建时调用。* 主要进行界面初始化和设置账户同步。** @param icicle 保存Activity状态的Bundle，用于恢复状态。*/@Overrideprotected void onCreate(Bundle icicle) {super.onCreate(icicle);// 设置返回按钮getActionBar().setDisplayHomeAsUpEnabled(true);// 从XML加载偏好设置addPreferencesFromResource(R.xml.preferences);mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);mReceiver = new GTaskReceiver();IntentFilter filter = new IntentFilter();filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME);registerReceiver(mReceiver, filter); // 注册广播接收器以监听同步服务mOriAccounts = null;// 添加设置头部视图View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null);getListView().addHeaderView(header, null, true);}/*** 当设置Activity恢复到前台时调用。* 主要用于检查并自动设置新添加的账户进行同步。*/@Overrideprotected void onResume() {super.onResume();// 自动设置新添加的账户进行同步if (mHasAddedAccount) {Account[] accounts = getGoogleAccounts();if (mOriAccounts != null && accounts.length > mOriAccounts.length) {for (Account accountNew : accounts) {boolean found = false;for (Account accountOld : mOriAccounts) {if (TextUtils.equals(accountOld.name, accountNew.name)) {found = true;break;}}if (!found) {setSyncAccount(accountNew.name); // 设置新账户进行同步break;}}}}// 刷新UIrefreshUI();}/*** 当Activity即将被销毁时调用，用于注销广播接收器。*/@Overrideprotected void onDestroy() {if (mReceiver != null) {unregisterReceiver(mReceiver); // 注销广播接收器，避免内存泄漏}super.onDestroy();}/*** 加载账户偏好设置，展示当前同步账户信息及操作。*/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)) {// 如果尚未设置账户，则展示选择账户对话框showSelectAccountAlertDialog();} else {// 如果已经设置账户，则展示更改账户确认对话框showChangeAccountConfirmAlertDialog();}} else {// 如果正在同步中，则展示无法更改账户的提示Toast.makeText(NotesPreferenceActivity.this,R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT).show();}return true;}});mAccountCategory.addPreference(accountPref); // 将账户偏好项添加到账户分类下}/*** 加载同步按钮，并根据同步状态设置其文本和点击事件。*/private void loadSyncButton() {Button syncButton = (Button) findViewById(R.id.preference_sync_button); // 获取同步按钮TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview); // 获取上次同步时间视图// 根据同步状态设置按钮文本和点击事件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() {public void onClick(View v) {GTaskSyncService.startSync(NotesPreferenceActivity.this); // 设置点击事件为开始同步}});}syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this))); // 只有在设置了同步账户时才使能同步按钮// 根据同步状态设置上次同步时间的显示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); // 如果未同步过，则隐藏上次同步时间视图}}}/*** 刷新用户界面，加载账户偏好设置和同步按钮。*/private void refreshUI() {loadAccountPreference(); // 加载账户偏好设置loadSyncButton(); // 加载同步按钮}/*** 显示选择账户的对话框。* 该对话框列出了已连接的Google账户，并允许用户选择一个账户用于同步。* 如果没有账户，对话框将提供添加账户的选项。*/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); // 移除默认的确定按钮// 获取当前设备上的Google账户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; // 记录默认选中的账户int index = 0;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;Intent intent = new Intent("android.settings.ADD_ACCOUNT_SETTINGS");intent.putExtra(AUTHORITIES_FILTER_KEY, new String[]{"gmail-ls"});startActivityForResult(intent, -1);dialog.dismiss();}});}/*** 显示更改账户确认对话框。* 提供用户更改当前同步账户或取消更改的选择。*/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() {public void onClick(DialogInterface dialog, int which) {if (which == 0) {// 选择更改账户，显示账户选择对话框showSelectAccountAlertDialog();} else if (which == 1) {// 选择移除账户，执行移除操作并刷新UIremoveSyncAccount();refreshUI();}}});dialogBuilder.show();}/*** 获取设备上的Google账户列表。** @return Account[] 返回设备上所有类型为“com.google”的账户数组。*/private Account[] getGoogleAccounts() {AccountManager accountManager = AccountManager.get(this);return accountManager.getAccountsByType("com.google");}/*** 设置同步账户信息。* 如果当前账户与传入账户不一致，则更新SharedPreferences中的账户信息，并清理本地相关的gtask信息。** @param account 需要设置的账户名*/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();// 清理上次同步时间setLastSyncTime(this, 0);// 清理本地相关的gtask信息new Thread(new Runnable() {public void run() {ContentValues values = new ContentValues();values.put(NoteColumns.GTASK_ID, "");values.put(NoteColumns.SYNC_ID, 0);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();}}/*** 移除同步账户信息。* 清除SharedPreferences中的账户信息和上次同步时间，并清理本地相关的gtask信息。*/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();// 清理本地相关的gtask信息new Thread(new Runnable() {public void run() {ContentValues values = new ContentValues();values.put(NoteColumns.GTASK_ID, "");values.put(NoteColumns.SYNC_ID, 0);getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);}}).start();}/*** 获取当前同步账户名。* 从SharedPreferences中获取存储的账户名，默认为空字符串。** @param context 上下文* @return 同步账户名*/public static String getSyncAccountName(Context context) {SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,Context.MODE_PRIVATE);return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, "");}/*** 设置上次同步的时间。* 将指定的时间保存到SharedPreferences中。** @param context 上下文* @param time    上次同步的时间戳*/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();}/*** 获取上次同步的时间。* 从SharedPreferences中获取上次同步的时间戳，默认为0。** @param context 上下文* @return 上次同步的时间戳*/public static long getLastSyncTime(Context context) {SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,Context.MODE_PRIVATE);return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);}/*** 广播接收器类，用于接收gtask同步相关的广播消息，并据此刷新UI。*/private class GTaskReceiver extends BroadcastReceiver {@Overridepublic void onReceive(Context context, Intent intent) {refreshUI();// 如果广播消息表明正在同步，则更新UI显示的同步状态信息if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview);syncStatus.setText(intent.getStringExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_PROGRESS_MSG));}}}/*** 处理选项菜单项的选择事件。** @param item 选中的菜单项* @return 如果事件已处理，则返回true；否则返回false。*/public boolean onOptionsItemSelected(MenuItem item) {switch (item.getItemId()) {case android.R.id.home:// 当选择返回按钮时，启动NotesListActivity并清除当前活动栈顶以上的所有活动Intent intent = new Intent(this, NotesListActivity.class);intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);startActivity(intent);return true;default:return false;}}
}

http://www.mrgr.cn/news/4542.html

相关文章：

Unity3D URP 后处理如何作用于 UI 控件 Image 的详解

大型语言模型（LLM）——直接偏好优化完整指南

【Python爬虫】教你追剧看电影不求人！python爬虫代码教你爬取各平台视频，小白也能学会！附源码

【Electron】桌面应用开发快速入门到打包Windows应用程序

hostapd生成beacon_ie

C语言破墙镐对称飞迷宫

索引的数据结构

《Cloud Native Data Center Networking》（云原生数据中心网络设计）读书笔记 -- 07数据中心的边缘

XSS game复现(DOM型)

Golang | Leetcode Golang题解之第354题俄罗斯套娃信封问题

黑神话：悟空游戏用的什么服务器？

构建艺术：Ruby中RESTful API的精粹实践

【数据分析】时间滞后相干性分析

SSE请求多种实现方式总结

EmguCV学习笔记 C# 第5章图像变换

k8s安装Metabase开源报表系统

P5594 【XR-4】模拟赛

【C++】深度解析：用 C++ 模拟实现 priority_queue类，探索其底层实现细节(仿函数、容器适配器)

GDB的基本使用（1）

STM32——I2C通信外设