From f7704b28ace9eaedf1cf55a28c90690e91799a22 Mon Sep 17 00:00:00 2001 From: gaoxiaorui <3502644298@qq.com> Date: Wed, 9 Oct 2024 22:26:42 +0800 Subject: [PATCH 01/10] =?UTF-8?q?=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- test123.txt | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 test123.txt diff --git a/test123.txt b/test123.txt new file mode 100644 index 0000000..e69de29 -- 2.34.1 From 0f977e37173a12bdf82e7b0d35c06580198cbed6 Mon Sep 17 00:00:00 2001 From: gaoxiaorui <3502644298@qq.com> Date: Wed, 9 Oct 2024 23:16:53 +0800 Subject: [PATCH 02/10] =?UTF-8?q?=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- AlarmAlertActivity.java | 197 ++++++++++++++++++++++++++++++++++++++++ AlarmInitReceiver.java | 81 +++++++++++++++++ AlarmReceiver.java | 36 ++++++++ 3 files changed, 314 insertions(+) create mode 100644 AlarmAlertActivity.java create mode 100644 AlarmInitReceiver.java create mode 100644 AlarmReceiver.java diff --git a/AlarmAlertActivity.java b/AlarmAlertActivity.java new file mode 100644 index 0000000..a79b0fa --- /dev/null +++ b/AlarmAlertActivity.java @@ -0,0 +1,197 @@ +/* + * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package net.micode.notes.ui; + +import android.app.Activity;// 活动的基类 +import android.app.AlertDialog;// 用于创建警告对话框 +import android.content.Context; // 提供访问应用程序特定资源的上下文 +import android.content.DialogInterface; // 对话框交互接口 +import android.content.Intent; // 创建启动新活动的意图 +import android.media.AudioManager; // 管理音频设置 +import android.media.MediaPlayer; // 播放音频文件 +import android.media.RingtoneManager; // 访问系统铃声 +import android.net.Uri; // 表示URI +import android.os.Bundle;// 在活动之间传递数据 +import android.os.PowerManager; // 管理电源状态 +import android.provider.Settings; // 系统设置 +import android.view.Window; // 窗口管理 +import android.view.WindowManager;// 管理窗口 + +import net.micode.notes.R; // 导入资源引用 +import net.micode.notes.data.Notes; // 导入笔记数据模型 +import net.micode.notes.tool.DataUtils; // 数据操作的工具函数 + +import java.io.IOException; // 处理IO异常 + + +public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener { + private long mNoteId; + // 笔记的唯一标识 + private String mSnippet; + // 笔记的内容片段 + private static final int SNIPPET_PREW_MAX_LEN = 60; + // 内容片段的最大长度 + MediaPlayer mPlayer; + // 媒体播放器，用于播放警报音 + + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + 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 { + // 从意图中提取笔记ID + mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1)); + // 根据笔记ID获取内容片段 + mSnippet = 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(); // 初始化媒体播放器 + // 检查笔记是否在数据库中可见 + 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 + Uri url = RingtoneManager.getActualDefaultRingtoneUri(this, RingtoneManager.TYPE_ALARM); + + // 获取影响静音模式的流类型 + int 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 { + // 设置数据源为铃声URI + 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) { + switch (which) { + case DialogInterface.BUTTON_NEGATIVE: + // 点击取消按钮时，启动编辑笔记活动 + Intent intent = new Intent(this, NoteEditActivity.class); + intent.setAction(Intent.ACTION_VIEW); + intent.putExtra(Intent.EXTRA_UID, mNoteId); + // 传递笔记ID + startActivity(intent); + // 启动活动 + break; + default: + break; // 默认情况不处理 + } +} + +public void onDismiss(DialogInterface dialog) { + stopAlarmSound(); + // 停止播放警报声音 + finish(); + // 结束当前活动 +} + +private void stopAlarmSound() { + if (mPlayer != null) { + mPlayer.stop(); + // 停止播放 + mPlayer.release(); + // 释放媒体播放器资源 + mPlayer = null; + // 清空播放器引用 + } +} diff --git a/AlarmInitReceiver.java b/AlarmInitReceiver.java new file mode 100644 index 0000000..5b6d083 --- /dev/null +++ b/AlarmInitReceiver.java @@ -0,0 +1,81 @@ +/* + * 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; + +// 导入所需的Android类 +import android.app.AlarmManager; // 用于管理闹钟服务 +import android.app.PendingIntent; // 用于延迟执行的意图 +import android.content.BroadcastReceiver; // 广播接收器基类 +import android.content.ContentUris; // 用于处理内容URI +import android.content.Context; // 上下文类 +import android.content.Intent; // 意图类 +import android.database.Cursor; // 数据库结果集游标 + +// 导入笔记相关的数据类 +import net.micode.notes.data.Notes; // 笔记数据类 +import net.micode.notes.data.Notes.NoteColumns; // 笔记列定义类 + + +public class AlarmInitReceiver extends BroadcastReceiver { + + // 定义要查询的列 + private static final String [] PROJECTION = new String [] { + NoteColumns.ID, + // 笔记ID + NoteColumns.ALERTED_DATE + // 警报日期 + }; + + // 列索引 + private static final int COLUMN_ID = 0; + // ID列索引 + private static final int COLUMN_ALERTED_DATE = 1; + // 警报日期列索引 + + @Override + public void onReceive(Context context, Intent intent) { + long currentDate = System.currentTimeMillis(); // 获取当前时间戳 + // 查询提醒日期大于当前时间的笔记 + Cursor c = context.getContentResolver().query(Notes.CONTENT_NOTE_URI, + PROJECTION, + NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE, + new String[] { String.valueOf(currentDate) }, + null); + + if (c != null) { + // 如果结果集不为空 + if (c.moveToFirst()) { + do { + long alertDate = c.getLong(COLUMN_ALERTED_DATE); + // 获取警报日期 + Intent sender = new Intent(context, AlarmReceiver.class); // 创建意图，用于发送警报 + // 设置数据为对应的笔记URI + sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(COLUMN_ID))); + // 创建PendingIntent，注册广播接收器 + PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, 0); + // 获取AlarmManager服务 + AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE); + // 设置闹钟 + alarmManager.set(AlarmManager.RTC_WAKEUP, alertDate, pendingIntent); + } while (c.moveToNext()); + // 遍历结果集 + } + c.close(); + // 关闭Cursor + } + } +} \ No newline at end of file diff --git a/AlarmReceiver.java b/AlarmReceiver.java new file mode 100644 index 0000000..76fb574 --- /dev/null +++ b/AlarmReceiver.java @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package net.micode.notes.ui; +// 指定当前类所在的包名 + +import android.content.BroadcastReceiver; // 导入广播接收器基类 +import android.content.Context; // 导入上下文类 +import android.content.Intent; // 导入意图类 + +// 定义AlarmReceiver类，继承自BroadcastReceiver +public class AlarmReceiver extends BroadcastReceiver { + @Override + // 当接收到广播时调用的方法 + public void onReceive(Context context, Intent intent) { + // 设置要启动的活动为AlarmAlertActivity + intent.setClass(context, AlarmAlertActivity.class); + // 添加标志，使新的活动在新的任务中启动 + intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + // 启动AlarmAlertActivity + context.startActivity(intent); + } +} -- 2.34.1 From e1848391433268c8e3d7566f1dcbe9d324646eda Mon Sep 17 00:00:00 2001 From: gaoxiaorui <3502644298@qq.com> Date: Thu, 10 Oct 2024 17:00:44 +0800 Subject: [PATCH 03/10] =?UTF-8?q?=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- DateTimePicker.java | 599 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 599 insertions(+) create mode 100644 DateTimePicker.java diff --git a/DateTimePicker.java b/DateTimePicker.java new file mode 100644 index 0000000..c328fd9 --- /dev/null +++ b/DateTimePicker.java @@ -0,0 +1,599 @@ +/* + * 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 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 { + // 定义DateTimePicker类，继承自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; + // 日期选择器的最大值 + 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; + // 24小时制小时选择器的最大值 + 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; + // 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; + // 标识是否为上午 + + private boolean mIs24HourView; + // 标识是否为24小时制视图 + + private boolean mIsEnabled = DEFAULT_ENABLE_STATE; + // 控件是否启用 + + private boolean mInitialising; + // 控件是否正在初始化 + + private OnDateTimeChangedListener mOnDateTimeChangedListener; + // 日期时间改变监听器 + + // 日期变化监听器 + private NumberPicker.OnValueChangeListener mOnDateChangedListener = new NumberPicker.OnValueChangeListener() { + @Override + public 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() { + @Override + public void onValueChange(NumberPicker picker, int oldVal, int newVal) { + boolean isDateChanged = false; // 标识日期是否改变 + Calendar cal = Calendar.getInstance(); // 获取当前日历实例 + + // 如果不是24小时制 + if (!mIs24HourView) { + // 如果从 PM 切换到 AM，日期需要加一天 + 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; // 日期改变标识为真 + } + // 如果从 AM 切换到 PM，日期需要减一天 + 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; // 日期改变标识为真 + } + // 切换 AM/PM 标识 + 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(); // 更新 AM/PM 控件 + } + } 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)); + } + } +}; + +private NumberPicker.OnValueChangeListener mOnMinuteChangedListener = new NumberPicker.OnValueChangeListener() { + @Override + public void onValueChange(NumberPicker picker, int oldVal, int newVal) { + int minValue = mMinuteSpinner.getMinValue(); // 获取分钟选择器的最小值 + int maxValue = mMinuteSpinner.getMaxValue(); // 获取分钟选择器的最大值 + int offset = 0; // 偏移量初始化为0 + + // 判断是否从最大值切换到最小值 + if (oldVal == maxValue && newVal == minValue) { + offset += 1; // 增加偏移量 + } + // 判断是否从最小值切换到最大值 + else if (oldVal == minValue && newVal == maxValue) { + offset -= 1; // 减少偏移量 + } + + // 如果有偏移量，更新小时 + if (offset != 0) { + mDate.add(Calendar.HOUR_OF_DAY, offset); // 更新日期对象中的小时 + mHourSpinner.setValue(getCurrentHour()); // 更新小时选择器的值 + updateDateControl(); // 更新日期控件 + + // 根据当前小时判断 AM/PM 状态 + int newHour = getCurrentHourOfDay(); + if (newHour >= HOURS_IN_HALF_DAY) { + mIsAm = false; // 设置为下午 + updateAmPmControl(); // 更新 AM/PM 控件 + } else { + mIsAm = true; // 设置为上午 + updateAmPmControl(); // 更新 AM/PM 控件 + } + } + mDate.set(Calendar.MINUTE, newVal); // 更新日期对象中的分钟 + onDateTimeChanged(); // 通知日期时间已改变 + } +}; + +private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() { + @Override + public void onValueChange(NumberPicker picker, int oldVal, int newVal) { + mIsAm = !mIsAm; // 切换 AM/PM 状态 + // 根据 AM/PM 状态调整小时 + if (mIsAm) { + mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY); + // 设置为上午，减去12小时 + } else { + mDate.add(Calendar.HOUR_OF_DAY, HOURS_IN_HALF_DAY); + // 设置为下午，加上12小时 + } + updateAmPmControl(); // 更新 AM/PM 控件 + onDateTimeChanged(); // 通知日期时间已改变 + } +}; + + // 定义一个接口，用于日期时间变化的监听 +public interface OnDateTimeChangedListener { + void onDateTimeChanged(DateTimePicker view, int year, int month, + int dayOfMonth, int hourOfDay, int minute); +} + +// DateTimePicker 类的构造函数 +public DateTimePicker(Context context) { + // 默认调用带有当前时间的构造函数 + this(context, System.currentTimeMillis()); +} + +// 带有日期参数的构造函数 +public DateTimePicker(Context context, long date) { + // 调用带有日期和24小时制标志的构造函数 + 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); // 加载自定义布局 + + // 日期选择器的初始化 + 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); // 设置分钟变化监听器 + + // AM/PM 选择器的初始化 + String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings(); // 获取 AM/PM 字符串 + mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm); + mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL); // 设置最小值 + mAmPmSpinner.setMaxValue(AMPM_SPINNER_MAX_VAL); // 设置最大值 + mAmPmSpinner.setDisplayedValues(stringsForAmPm); // 显示 AM/PM 值 + mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener); // 设置 AM/PM 变化监听器 +} + + + // update controls to initial state + updateDateControl(); // 更新日期控件 + updateHourControl(); // 更新小时控件 + updateAmPmControl(); // 更新 AM/PM 控件 + + set24HourView(is24HourView); // 设置为24小时制或12小时制 + + + // set to current time + setCurrentDate(date);// 根据传入的日期设置当前日期 + + setEnabled(isEnabled());// 根据是否启用状态设置控件 + + + // set the content descriptions + mInitialising = false;// 初始化完成标志设为false + } + + @Override + public void setEnabled(boolean enabled) { + if (mIsEnabled == enabled) { // 如果当前状态与目标状态相同，则不做任何操作 + return; + } + super.setEnabled(enabled); // 调用父类的设置启用状态方法 + mDateSpinner.setEnabled(enabled); // 设置日期选择器的启用状态 + mMinuteSpinner.setEnabled(enabled); // 设置分钟选择器的启用状态 + mHourSpinner.setEnabled(enabled); // 设置小时选择器的启用状态 + mAmPmSpinner.setEnabled(enabled); // 设置 AM/PM 选择器的启用状态 + mIsEnabled = enabled; // 更新当前启用状态 +} + + @Override + public boolean isEnabled() { + return mIsEnabled;// 返回当前启用状态 + } + + /** + * Get the current date in millis + * + * @return the current date in millis + */ + public long getCurrentDateInTimeMillis() { + return mDate.getTimeInMillis();// 返回日期对象的毫秒值 + } + + /** + * Set the current date + * + * @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)); +} + + /** + * Set the current date + * + * @param year The current year + * @param month The current month + * @param dayOfMonth The current dayOfMonth + * @param hourOfDay The current hourOfDay + * @param minute The current minute + */ + public void setCurrentDate(int year, int month,int dayOfMonth, int hourOfDay, int minute) { + // 设置当前年份 + setCurrentYear(year); + + // 设置当前月份 + setCurrentMonth(month); + + // 设置当前日期 + setCurrentDay(dayOfMonth); + + // 设置当前小时 + setCurrentHour(hourOfDay); + + // 设置当前分钟 + setCurrentMinute(minute); +} + + + /** + * Get current year + * + * @return The current year + */ + public int getCurrentYear() { // 返回当前日期对象中的年份 + return mDate.get(Calendar.YEAR); + } + + /** + * Set current year + * + * @param year The current year + */ + public void setCurrentYear(int year) { + // 如果不是初始化状态并且输入的年份与当前年份相同，则不做任何操作 + if (!mInitialising && year == getCurrentYear()) { + return; + } + // 设置当前年份 + mDate.set(Calendar.YEAR, year); + // 更新日期控件 + updateDateControl(); + // 通知日期和时间已改变 + onDateTimeChanged(); + } + + /** + * Get current month in the year + * + * @return The current month in the year + */ + public int getCurrentMonth() { + return mDate.get(Calendar.MONTH); + } + + /** + * Set current month in the year + * + * @param month The month in the year + */ + public void setCurrentMonth(int month) { + // 如果不是初始化状态并且输入的月份与当前月份相同，则不做任何操作 + if (!mInitialising && month == getCurrentMonth()) { + return; + } + // 设置当前月份 + mDate.set(Calendar.MONTH, month); + // 更新日期控件 + updateDateControl(); + // 通知日期和时间已改变 + onDateTimeChanged(); + } + + /** + * Get current day of the month + * + * @return The day of the month + */ + public int getCurrentDay() { + return mDate.get(Calendar.DAY_OF_MONTH); + } + + /** + * Set current day of the month + * + * @param dayOfMonth The day of the month + */ + public void setCurrentDay(int dayOfMonth) { + // 如果不是初始化状态，并且输入的日期与当前日期相同，则不做任何操作 + if (!mInitialising && dayOfMonth == getCurrentDay()) { + return; + } + // 设置当前日期 + mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth); + // 更新日期控件 + updateDateControl(); + // 通知日期和时间已改变 + onDateTimeChanged(); +} + + /** + * Get current hour in 24 hour mode, in the range (0~23) + * @return The current hour in 24 hour mode + */ + public int getCurrentHourOfDay() { + return mDate.get(Calendar.HOUR_OF_DAY); + } + +private int getCurrentHour() { + if (mIs24HourView) { + // 如果是24小时制，直接返回当前小时 + return getCurrentHourOfDay(); + } else { + // 如果是12小时制 + int hour = getCurrentHourOfDay(); + if (hour > HOURS_IN_HALF_DAY) { + // 如果小时大于12，则转换为12小时制 + return hour - HOURS_IN_HALF_DAY; + } else { + // 如果小时为0，返回12，否则返回当前小时 + return hour == 0 ? HOURS_IN_HALF_DAY : hour; + } + } +} + + /** + * Set current hour in 24 hour mode, in the range (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) { + // 设置为PM + mIsAm = false; + if (hourOfDay > HOURS_IN_HALF_DAY) { + // 转换为12小时制 + hourOfDay -= HOURS_IN_HALF_DAY; + } + } else { + // 设置为AM + mIsAm = true; + if (hourOfDay == 0) { + // 0点转换为12点 + hourOfDay = HOURS_IN_HALF_DAY; + } + } + // 更新AM/PM控件 + updateAmPmControl(); + } + // 更新小时选择器的值 + mHourSpinner.setValue(hourOfDay); + // 通知时间已改变 + onDateTimeChanged(); + } + + /** + * Get currentMinute + * + * @return The Current Minute + */ + public int getCurrentMinute() { + return mDate.get(Calendar.MINUTE); + } + + /** + * Set current minute + */ + public void setCurrentMinute(int minute) { + // 如果不是初始化状态，并且输入的分钟与当前分钟相同，则不做任何操作 + if (!mInitialising && minute == getCurrentMinute()) { + return; + } + // 更新分钟选择器的值 + mMinuteSpinner.setValue(minute); + // 设置当前分钟 + mDate.set(Calendar.MINUTE, minute); + // 通知时间已改变 + onDateTimeChanged(); + } + + /** + * @return true if this is in 24 hour view else false. + */ + public boolean is24HourView () { + return mIs24HourView; + } + + /** + * Set whether in 24 hour or AM/PM mode. + * + * @param is24HourView True for 24 hour mode. False for AM/PM mode. + */ + public void set24HourView(boolean is24HourView) { + // 如果当前状态与传入参数相同，则不做任何操作 + if (mIs24HourView == is24HourView) { + return; + } + // 更新24小时制标志 + mIs24HourView = is24HourView; + // 根据24小时制的选择，设置AM/PM选择器的可见性 + mAmPmSpinner.setVisibility(is24HourView ? View.GONE : View.VISIBLE); + // 获取当前小时，并更新控件 + int hour = getCurrentHourOfDay(); + updateHourControl(); // 更新小时选择器的设置 + setCurrentHour(hour); // 设置当前小时 + updateAmPmControl(); // 更新AM/PM控件的显示 + } +/** + * 更新日期选择器的显示值 + */ + 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();// 刷新日期选择器 + } +/** + * 更新AM/PM控制 + */ + private void updateAmPmControl() { + // 如果是24小时制，则隐藏AM/PM选择器 + if (mIs24HourView) { + mAmPmSpinner.setVisibility(View.GONE); + } else { + // 否则，根据当前时间选择AM或PM + int index = mIsAm ? Calendar.AM : Calendar.PM; + mAmPmSpinner.setValue(index);// 设置AM/PM选择器的值 + mAmPmSpinner.setVisibility(View.VISIBLE);// 显示选择器 + } + } +/** + * 更新小时控制 + */ + private void updateHourControl() { + // 根据是否为24小时制更新小时选择器的最小和最大值 + if (mIs24HourView) { + mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW); + // 设置24小时制的最小值 + mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW); + // 设置24小时制的最大值 + } else { + mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW); + // 设置12小时制的最小值 + mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW); + // 设置12小时制的最大值 + } + } + + /** + * Set the callback that indicates the 'Set' button has been pressed. + * @param callback the callback, if null will do nothing + */ + // 设置日期时间变化监听器 + public void setOnDateTimeChangedListener(OnDateTimeChangedListener callback) { + mOnDateTimeChangedListener = callback;// 将回调对象赋值给成员变量 + } + +// 当日期时间发生变化时调用 + private void onDateTimeChanged() { + // 检查监听器是否不为空 + if (mOnDateTimeChangedListener != null) { + // 调用监听器的方法，并传递当前的年、月、日、小时和分钟 + mOnDateTimeChangedListener.onDateTimeChanged(this, getCurrentYear(), + getCurrentMonth(), getCurrentDay(), getCurrentHourOfDay(), getCurrentMinute()); + } + // 当前年份、 当前月份、当前日期、当前小时、当前分钟 + } + -- 2.34.1 From 8f480402cae6d370109dfeac4b40b426c80c871b Mon Sep 17 00:00:00 2001 From: gaoxiaorui <3502644298@qq.com> Date: Thu, 10 Oct 2024 18:06:09 +0800 Subject: [PATCH 04/10] =?UTF-8?q?=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- DateTimePickerDialog.java | 118 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 118 insertions(+) create mode 100644 DateTimePickerDialog.java diff --git a/DateTimePickerDialog.java b/DateTimePickerDialog.java new file mode 100644 index 0000000..b77dfce --- /dev/null +++ b/DateTimePickerDialog.java @@ -0,0 +1,118 @@ +/* + * 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 java.util.Calendar; // 导入日历类，用于日期和时间的管理 + +import net.micode.notes.R; // 导入资源类，用于访问字符串资源等 +import net.micode.notes.ui.DateTimePicker; // 导入自定义的日期时间选择器类 +import net.micode.notes.ui.DateTimePicker.OnDateTimeChangedListener; // 导入日期时间变化监听器接口 + +import android.app.AlertDialog; // 导入对话框类，用于创建对话框 +import android.content.Context; // 导入上下文类，用于获取应用环境信息 +import android.content.DialogInterface; // 导入对话框接口类，用于处理对话框事件 +import android.content.DialogInterface.OnClickListener; // 导入对话框点击事件监听器接口 +import android.text.format.DateFormat; // 导入日期格式化类，用于格式化日期和时间 +import android.text.format.DateUtils; // 导入日期工具类，提供日期格式化和显示功能 + +// 自定义日期时间选择对话框类 +public class DateTimePickerDialog extends AlertDialog implements OnClickListener { + + private Calendar mDate = Calendar.getInstance(); + // 用于存储当前选中的日期和时间 + private boolean mIs24HourView; + // 标识是否使用24小时制 + private OnDateTimeSetListener mOnDateTimeSetListener; + // 日期时间设置的监听器 + private DateTimePicker mDateTimePicker; + // 日期时间选择器实例 + + // 日期时间设置监听器接口 + public interface OnDateTimeSetListener { + void OnDateTimeSet(AlertDialog dialog, long date); + // 设置日期时间的回调方法 + } + + // 构造函数，初始化对话框并设置初始日期 + public DateTimePickerDialog(Context context, long date) { + super(context); // 调用父类构造函数 + mDateTimePicker = new DateTimePicker(context); + // 创建日期时间选择器 + setView(mDateTimePicker); + // 将选择器设置为对话框的视图 + + // 设置日期时间变化的监听器 + mDateTimePicker.setOnDateTimeChangedListener(new OnDateTimeChangedListener() { + public void onDateTimeChanged(DateTimePicker view, int year, int month, + int dayOfMonth, int hourOfDay, int minute) { + // 更新日历对象中的年、月、日、小时和分钟 + 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); // 将秒数设为0 + mDateTimePicker.setCurrentDate(mDate.getTimeInMillis()); + // 设置选择器的当前日期时间 + setButton(context.getString(R.string.datetime_dialog_ok), this); + // 设置“确定”按钮 + setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener)null); + // 设置“取消”按钮 + set24HourView(DateFormat.is24HourFormat(this.getContext())); + // 根据系统设置决定是否使用24小时制 + updateTitle(mDate.getTimeInMillis()); + // 初始化对话框标题 + } + + // 设置是否使用24小时制 + public void set24HourView(boolean is24HourView) { + mIs24HourView = is24HourView; // 更新24小时制标识 + } + + // 设置日期时间设置的监听器 + public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) { + mOnDateTimeSetListener = callBack; // 保存监听器 + } + + // 更新对话框的标题，显示当前选中的日期和时间 + private void updateTitle(long date) { + // 设置显示格式，包括年份、日期和时间 + int flag = + DateUtils.FORMAT_SHOW_YEAR | // 显示年份 + DateUtils.FORMAT_SHOW_DATE | // 显示日期 + DateUtils.FORMAT_SHOW_TIME; // 显示时间 + flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_12HOUR; + // 根据设置选择小时制 + setTitle(DateUtils.formatDateTime(this.getContext(), date, flag)); + // 格式化日期时间并设置为对话框标题 + } + + // 点击事件处理 + public void onClick(DialogInterface arg0, int arg1) { + // 如果设置了监听器，则调用其方法并传递当前时间戳 + if (mOnDateTimeSetListener != null) { + mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis()); + } + } +} \ No newline at end of file -- 2.34.1 From ca6348c62850bb6e240a1fd09e8fa6da29946aaa Mon Sep 17 00:00:00 2001 From: gaoxiaorui <3502644298@qq.com> Date: Sat, 16 Nov 2024 20:09:00 +0800 Subject: [PATCH 05/10] =?UTF-8?q?=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- DropdownMenu.java | 90 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 90 insertions(+) create mode 100644 DropdownMenu.java diff --git a/DropdownMenu.java b/DropdownMenu.java new file mode 100644 index 0000000..c969c70 --- /dev/null +++ b/DropdownMenu.java @@ -0,0 +1,90 @@ +/* + * 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; + // 引入 Context 类，提供访问应用环境的功能，如启动活动、获取系统服务、访问资源等。 +import android.view.Menu; +// 引入 Menu 类，定义菜单的结构，通常用于上下文菜单、选项菜单等。 +import android.view.MenuItem; + // 引入 MenuItem 类，代表菜单中的一项，可以设置标题、图标等属性并绑定点击事件。 +import android.view.View; +// 引入 View 类，所有 UI 控件的基类，处理控件的显示和用户交互（如点击、拖动等）。 +import android.view.View.OnClickListener; +// 引入 OnClickListener 接口，用于处理视图（如按钮）的点击事件。 +import android.widget.Button; +// 引入 Button 类，用于在界面中创建按钮控件，用户点击按钮时可以触发某个操作。 +import android.widget.PopupMenu; +// 引入 PopupMenu 类，表示一个弹出式菜单，通常用于显示上下文菜单或按钮点击后的菜单。 +import android.widget.PopupMenu.OnMenuItemClickListener; +// 引入 OnMenuItemClickListener 接口，用于处理 PopupMenu 中菜单项的点击事件。 +import net.micode.notes.R; +// 引入 R 类，自动生成的资源类，用于访问应用的资源文件（如布局、字符串、ID 等）。 + + +// DropdownMenu 类用于显示一个下拉菜单 +public class DropdownMenu { + + // 成员变量 + private Button mButton; // 按钮，用于触发下拉菜单显示 + private PopupMenu mPopupMenu; // 弹出菜单 + private Menu mMenu; // 菜单对象，用于管理菜单项 + + // 构造函数，初始化按钮和菜单 + public DropdownMenu(Context context, Button button, int menuId) { + // 将传入的按钮实例赋值给 mButton + mButton = button; + + // 设置按钮的背景资源（这里使用的是一个下拉图标） + mButton.setBackgroundResource(R.drawable.dropdown_icon); + + // 初始化 PopupMenu 对象，关联按钮 + mPopupMenu = new PopupMenu(context, mButton); + + // 获取菜单对象 + mMenu = mPopupMenu.getMenu(); + + // 使用菜单 ID（通过菜单资源 XML 文件）填充菜单项 + mPopupMenu.getMenuInflater().inflate(menuId, mMenu); + + // 设置按钮的点击事件监听器，当按钮被点击时显示弹出菜单 + mButton.setOnClickListener(new OnClickListener() { + public void onClick(View v) { + // 显示弹出菜单 + mPopupMenu.show(); + } + }); + } + + // 设置菜单项点击事件监听器 + public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) { + // 如果 mPopupMenu 已经初始化，则设置菜单项点击事件监听器 + if (mPopupMenu != null) { + mPopupMenu.setOnMenuItemClickListener(listener); + } + } + + // 根据 ID 查找菜单项 + public MenuItem findItem(int id) { + return mMenu.findItem(id); + } + + // 设置按钮的文本（通常用于显示当前菜单的标题或提示） + public void setTitle(CharSequence title) { + mButton.setText(title); + } +} -- 2.34.1 From 58f5d8a5cb4010466d6849d276c1c184221a4ecf Mon Sep 17 00:00:00 2001 From: gaoxiaorui <3502644298@qq.com> Date: Sat, 16 Nov 2024 20:59:13 +0800 Subject: [PATCH 06/10] =?UTF-8?q?=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- FoldersListAdapter.java | 109 ++++ NoteEditActivity.java | 1149 +++++++++++++++++++++++++++++++++++++++ NoteEditText.java | 276 ++++++++++ 3 files changed, 1534 insertions(+) create mode 100644 FoldersListAdapter.java create mode 100644 NoteEditActivity.java create mode 100644 NoteEditText.java diff --git a/FoldersListAdapter.java b/FoldersListAdapter.java new file mode 100644 index 0000000..74015de --- /dev/null +++ b/FoldersListAdapter.java @@ -0,0 +1,109 @@ +/* + * 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; +// 引入 Context 类，用于访问应用的环境、资源、启动活动等。 +import android.database.Cursor; +// 引入 Cursor 类，表示查询结果集，通常用于访问数据库中的记录。 +import android.view.View; +// 引入 View 类，所有 UI 控件的基类。 +import android.view.ViewGroup; +// 引入 ViewGroup 类，表示可以包含其他视图的容器类。 +import android.widget.CursorAdapter; + // 引入 CursorAdapter 类，用于绑定数据库查询结果与 UI 元素。 +import android.widget.LinearLayout; +// 引入 LinearLayout 类，线性布局容器，用于按顺序排列视图。 +import android.widget.TextView; +// 引入 TextView 类，用于显示文本。 + +import net.micode.notes.R; +// 引入 R 类，自动生成的资源类，访问应用的资源（如字符串、布局、ID 等）。 +import net.micode.notes.data.Notes; + // 引入 Notes 类，表示笔记相关的数据模型。 +import net.micode.notes.data.Notes.NoteColumns; + // 引入 NoteColumns 类，表示与笔记相关的数据库字段。 + +// FoldersListAdapter 类是一个自定义的 CursorAdapter，用于展示文件夹列表。 +public class FoldersListAdapter extends 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; // 文件夹名称列索引 + + // 构造函数，接收 Context 和 Cursor，传递给父类的构造函数。 + public FoldersListAdapter(Context context, Cursor c) { + super(context, c); // 调用父类 CursorAdapter 的构造函数 + } + + // newView 方法负责创建新的视图（即每一行的数据项）。 + @Override + public View newView(Context context, Cursor cursor, ViewGroup parent) { + return new FolderListItem(context); + // 返回一个新的 FolderListItem 视图（表示文件夹项）。 + } + + // bindView 方法负责绑定数据到视图上，通常是处理显示和数据的绑定。 + @Override + public void bindView(View view, Context context, Cursor cursor) { + if (view instanceof FolderListItem) { + // 确保视图是 FolderListItem 类型 + // 获取文件夹的名称。如果是根文件夹，则显示特定的名称（菜单中的 "父文件夹"），否则显示文件夹名称。 + String folderName = (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) + ? context.getString(R.string.menu_move_parent_folder) + : cursor.getString(NAME_COLUMN); + + // 将获取的名称绑定到 FolderListItem 中 + ((FolderListItem) view).bind(folderName); + } + } + + // getFolderName 方法用于根据位置获取文件夹名称。 + public String getFolderName(Context context, int position) { + Cursor cursor = (Cursor) getItem(position); + // 获取指定位置的 Cursor 数据 + // 根据文件夹的 ID 返回对应的名称 + return (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) + ? context.getString(R.string.menu_move_parent_folder) + : cursor.getString(NAME_COLUMN); + } + + // FolderListItem 类表示文件夹列表项的视图，它是一个 LinearLayout。 + private class FolderListItem extends LinearLayout { + private TextView mName; + // 用于显示文件夹名称的 TextView 控件。 + + // FolderListItem 的构造函数，初始化视图和控件。 + public FolderListItem(Context context) { + super(context); + inflate(context, R.layout.folder_list_item, this); + // 加载 folder_list_item 布局文件 + mName = (TextView) findViewById(R.id.tv_folder_name); + // 获取文件夹名称显示控件 + } + + // bind 方法用于将文件夹名称绑定到 TextView 上。 + public void bind(String name) { + mName.setText(name); // 设置文件夹名称 + } + } +} diff --git a/NoteEditActivity.java b/NoteEditActivity.java new file mode 100644 index 0000000..fd9848b --- /dev/null +++ b/NoteEditActivity.java @@ -0,0 +1,1149 @@ +/* + * 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; + +// 导入 Android 标准库中的类 + +import android.app.Activity; // Activity 类，是所有 Android 应用的基本组件，表示单一屏幕的界面。 +import android.app.AlarmManager; // AlarmManager 类，用于设置定时事件或闹钟。 +import android.app.AlertDialog; // AlertDialog 类，用于显示对话框。 +import android.app.PendingIntent; // PendingIntent 类，表示一个未来的 Intent 操作。 +import android.app.SearchManager; // SearchManager 类，用于实现搜索功能。 +import android.appwidget.AppWidgetManager; // AppWidgetManager 类，用于操作应用小部件。 +import android.content.ContentUris; // ContentUris 类，用于构建和解析内容提供者的 URI。 +import android.content.Context; // Context 类，提供应用环境信息，常用于访问系统服务。 +import android.content.DialogInterface; // DialogInterface 类，处理对话框的交互事件。 +import android.content.Intent; // Intent 类，用于启动活动或发送广播。 +import android.content.SharedPreferences; // SharedPreferences 类，用于存储应用的首选项（键值对数据）。 +import android.graphics.Paint; // Paint 类，用于设置文本或图形的样式和颜色。 +import android.os.Bundle; // Bundle 类，用于在活动之间传递数据。 +import android.preference.PreferenceManager; // PreferenceManager 类，用于访问 SharedPreferences。 +import android.text.Spannable; // Spannable 接口，允许动态改变文本的格式。 +import android.text.SpannableString; // SpannableString 类，实现了 Spannable 接口，用于设置可变的文本。 +import android.text.TextUtils; // TextUtils 类，提供文本处理的工具方法。 +import android.text.format.DateUtils; // DateUtils 类，提供格式化日期和时间的方法。 +import android.text.style.BackgroundColorSpan; // BackgroundColorSpan 类，用于设置文本的背景颜色。 +import android.util.Log; // Log 类，用于输出日志。 +import android.view.LayoutInflater; // LayoutInflater 类，用于加载布局文件。 +import android.view.Menu; // Menu 类，用于创建和处理应用菜单。 +import android.view.MenuItem; // MenuItem 类，用于表示菜单项。 +import android.view.MotionEvent; // MotionEvent 类，用于处理触摸事件。 +import android.view.View; // View 类，所有 UI 组件的基类。 +import android.view.View.OnClickListener; // OnClickListener 接口，用于处理点击事件。 +import android.view.WindowManager; // WindowManager 类，用于管理窗口和显示。 +import android.widget.CheckBox; // CheckBox 类，表示复选框。 +import android.widget.CompoundButton; // CompoundButton 类，是一个开关类的父类，如 CheckBox 和 Switch。 +import android.widget.CompoundButton.OnCheckedChangeListener; // OnCheckedChangeListener 接口，用于处理复选框状态变化事件。 +import android.widget.EditText; // EditText 类，表示一个文本输入框。 +import android.widget.ImageView; // ImageView 类，表示显示图片的控件。 +import android.widget.LinearLayout; // LinearLayout 类，一种常用的布局管理器。 +import android.widget.TextView; // TextView 类，用于显示文本。 +import android.widget.Toast; // Toast 类，用于显示短暂的提示信息。 + +// 导入应用程序自定义的类 + +import net.micode.notes.R; // 应用资源类，用于访问应用中的资源文件。 +import net.micode.notes.data.Notes; // Notes 类，可能用于表示笔记数据。 +import net.micode.notes.data.Notes.TextNote; // TextNote 类，表示文本类型的笔记。 +import net.micode.notes.model.WorkingNote; // WorkingNote 类，处理正在编辑的笔记的数据。 +import net.micode.notes.model.WorkingNote.NoteSettingChangedListener; // NoteSettingChangedListener 接口，用于监听笔记设置的变化。 +import net.micode.notes.tool.DataUtils; // DataUtils 类，提供与数据相关的工具方法。 +import net.micode.notes.tool.ResourceParser; // ResourceParser 类，用于解析资源。 +import net.micode.notes.tool.ResourceParser.TextAppearanceResources; // TextAppearanceResources 类，用于处理文本外观资源。 +import net.micode.notes.ui.DateTimePickerDialog.OnDateTimeSetListener; // DateTimePickerDialog.OnDateTimeSetListener 接口，用于监听日期时间选择器的设置事件。 +import net.micode.notes.ui.NoteEditText.OnTextViewChangeListener; // OnTextViewChangeListener 接口，用于监听文本框内容变化的事件。 +import net.micode.notes.widget.NoteWidgetProvider_2x; // NoteWidgetProvider_2x 类，表示2x大小的笔记小部件。 +import net.micode.notes.widget.NoteWidgetProvider_4x; // NoteWidgetProvider_4x 类，表示4x大小的笔记小部件。 + +// 导入 Java 标准库中的类 + +import java.util.HashMap; // HashMap 类，用于存储键值对。 +import java.util.HashSet; // HashSet 类，用于存储唯一元素的集合。 +import java.util.Map; // Map 接口，表示键值对映射。 +import java.util.regex.Matcher; // Matcher 类，用于处理正则表达式的匹配。 +import java.util.regex.Pattern; // Pattern 类，用于定义正则表达式模式。 + + +// 定义 NoteEditActivity 类，继承自 Activity 类，且实现了三个接口 +public class NoteEditActivity extends Activity implements OnClickListener, + NoteSettingChangedListener, OnTextViewChangeListener { + + // 内部类：HeadViewHolder，用于存放活动页面中头部视图的组件（如修改时间、提醒图标等） + private class HeadViewHolder { + public TextView tvModified; // 显示修改时间的 TextView + public ImageView ivAlertIcon; // 显示提醒图标的 ImageView + public TextView tvAlertDate; // 显示提醒日期的 TextView + public ImageView ibSetBgColor; // 设置背景颜色的 ImageView + } + + // 静态常量：存储背景颜色选择按钮与颜色资源之间的映射关系 + private static final Map sBgSelectorBtnsMap = new HashMap(); + static { + // 映射按钮 ID 到颜色资源（如黄色背景对应黄色资源） + 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); + } + + // 静态常量：存储颜色资源与对应选中状态按钮 ID 之间的映射关系 + private static final Map sBgSelectorSelectionMap = new HashMap(); + static { + // 映射颜色资源到选中按钮 ID（如黄色背景选中时，显示黄色选中图标） + 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 sFontSizeBtnsMap = new HashMap(); + static { + // 映射字体大小选择按钮 ID 到字体大小资源（如大号字体对应大号字体资源） + 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); + } + + // 静态常量：存储字体大小资源与对应选中状态按钮 ID 之间的映射关系 + private static final Map sFontSelectorSelectionMap = new HashMap(); + static { + // 映射字体大小资源到选中按钮 ID（如大号字体选中时，显示大号选中图标） + 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); + } + + + + // 定义 TAG 常量，用于日志调试时标记当前 Activity +private static final String TAG = "NoteEditActivity"; + +// 定义一个变量用于存储头部视图的引用 +private HeadViewHolder mNoteHeaderHolder; + +// 定义一个视图变量，用于存储头部视图面板（例如，包含背景色选择和字体大小选择的区域） +private View mHeadViewPanel; + +// 定义一个视图变量，用于存储背景颜色选择器 +private View mNoteBgColorSelector; + +// 定义一个视图变量，用于存储字体大小选择器 +private View mFontSizeSelector; + +// 定义一个 EditText 变量，用于存储笔记编辑器的引用，用户输入文本的地方 +private EditText mNoteEditor; + +// 定义一个视图变量，用于存储编辑器面板（通常是 EditText 的外部容器） +private View mNoteEditorPanel; + +// 定义一个 WorkingNote 变量，用于存储当前正在编辑的笔记对象 +private WorkingNote mWorkingNote; + +// 定义 SharedPreferences 变量，用于存储和获取用户设置的首选项 +private SharedPreferences mSharedPrefs; + +// 存储当前字体大小 ID，通常是表示字体大小的标识符 +private int mFontSizeId; + +// 定义一个常量，用于存储字体大小设置的偏好键 +private static final String PREFERENCE_FONT_SIZE = "pref_font_size"; + +// 定义常量：最大标题长度限制，用于快捷方式图标的标题 +private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10; + +// 定义常量：表示复选框选中的符号 +public static final String TAG_CHECKED = String.valueOf('\u221A'); + +// 定义常量：表示复选框未选中的符号 +public static final String TAG_UNCHECKED = String.valueOf('\u25A1'); + +// 定义一个 LinearLayout 变量，用于存储编辑框列表的布局引用 +private LinearLayout mEditTextList; + +// 定义一个 String 变量，用于存储用户的查询文本 +private String mUserQuery; + +// 定义一个 Pattern 变量，用于存储正则表达式模式，用于匹配用户查询中的内容 +private Pattern mPattern; + +@Override +protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + // 设置当前 Activity 的布局 + this.setContentView(R.layout.note_edit); + + // 如果没有保存状态且初始化活动状态失败，则结束当前 Activity + if (savedInstanceState == null && !initActivityState(getIntent())) { + finish(); + return; + } + // 初始化相关资源（如字体大小、背景色等） + initResources(); +} + + + /** + * Current activity may be killed when the memory is low. Once it is killed, for another time + * user load this activity, we should restore the former state + */ + @Override +protected void onRestoreInstanceState(Bundle savedInstanceState) { + super.onRestoreInstanceState(savedInstanceState); // 调用父类的 onRestoreInstanceState 方法 + if (savedInstanceState != null && savedInstanceState.containsKey(Intent.EXTRA_UID)) { + // 如果 savedInstanceState 不为空且包含 EXTRA_UID 键 + Intent intent = new Intent(Intent.ACTION_VIEW); // 创建一个 ACTION_VIEW 的 Intent 对象 + intent.putExtra(Intent.EXTRA_UID, savedInstanceState.getLong(Intent.EXTRA_UID)); // 将 EXTRA_UID 从 Bundle 中取出并放入 Intent 中 + if (!initActivityState(intent)) { // 使用 intent 初始化活动的状态 + finish(); // 如果初始化失败，结束当前 Activity + return; // 退出方法 + } + Log.d(TAG, "Restoring from killed activity"); // 日志输出，表示从被杀死的 Activity 中恢复 + } +} + + + private boolean initActivityState(Intent intent) { + /** + * If the user specified the {@link Intent#ACTION_VIEW} but not provided with id, + * then jump to the NotesListActivity + */ + mWorkingNote = null; + if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) { + // 获取笔记ID，如果没有提供ID则默认为0 + long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0); + mUserQuery = "";// 用户的查询字符串 + + /** + * Starting from the searched result + */ + if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) { + noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY)); + mUserQuery = intent.getStringExtra(SearchManager.USER_QUERY); + // 获取用户的查询字符串 + } + + // 检查笔记是否存在于数据库中 + if (!DataUtils.visibleInNoteDatabase(getContentResolver(), noteId, Notes.TYPE_NOTE)) { + // 如果笔记不存在，跳转到NotesListActivity（笔记列表页面） + Intent jump = new Intent(this, NotesListActivity.class); + startActivity(jump); + showToast(R.string.error_note_not_exist); // 显示笔记不存在的提示 + finish(); // 关闭当前活动 + return false; // 返回false，表示初始化失败 + } else { + // 如果笔记存在，加载笔记 + mWorkingNote = WorkingNote.load(this, noteId); + if (mWorkingNote == null) { + Log.e(TAG, "load note failed with note id" + noteId); // 如果加载失败，记录错误日志 + finish(); // 关闭当前活动 + return false; // 返回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())) { + // 如果Intent的action是 ACTION_INSERT_OR_EDIT（插入或编辑） + // New note + long folderId = intent.getLongExtra(Notes.INTENT_EXTRA_FOLDER_ID, 0); + // 获取小部件ID + int widgetId = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_ID, + AppWidgetManager.INVALID_APPWIDGET_ID); + // 获取小部件类型 + int widgetType = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, + Notes.TYPE_WIDGET_INVALIDE); + // 获取背景资源ID + int bgResId = intent.getIntExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, + ResourceParser.getDefaultBgId(this)); + + // Parse call-record note + String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER); + long callDate = intent.getLongExtra(Notes.INTENT_EXTRA_CALL_DATE, 0); + if (callDate != 0 && phoneNumber != null) { + if (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; // 返回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的action不在预期的类型中，记录错误并关闭活动 + Log.e(TAG, "Intent not specified action, should not support"); + finish(); // 关闭当前活动 + return false; // 返回false，表示初始化失败 + } + + // 设置工作笔记的状态监听器 + mWorkingNote.setOnSettingStatusChangedListener(this); + + // 返回true，表示初始化成功 + return true; +} + +@Override +protected void onResume() { + super.onResume(); + // 在活动恢复时初始化笔记屏幕 + initNoteScreen(); +} + + + private void initNoteScreen() { + // 设置编辑器字体的样式，字体大小由 mFontSizeId 决定 + mNoteEditor.setTextAppearance(this, TextAppearanceResources + .getTexAppearanceResource(mFontSizeId)); + + // 检查当前笔记是否是待办事项模式（CheckList 模式） + if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) { + // 如果是待办事项模式，切换到列表模式 + switchToListMode(mWorkingNote.getContent()); + } else { + // 否则，将笔记内容中的查询结果进行高亮处理并显示 + mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery)); + // 设置光标定位到文本的末尾 + mNoteEditor.setSelection(mNoteEditor.getText().length()); + } + + // 隐藏所有背景选择器的视图 + for (Integer id : sBgSelectorSelectionMap.keySet()) { + findViewById(sBgSelectorSelectionMap.get(id)).setVisibility(View.GONE); + } + + // 设置标题背景资源 + mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId()); + // 设置笔记内容背景资源 + mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId()); + + // 格式化并显示最后修改时间 + mNoteHeaderHolder.tvModified.setText(DateUtils.formatDateTime(this, + mWorkingNote.getModifiedDate(), DateUtils.FORMAT_SHOW_DATE + | DateUtils.FORMAT_NUMERIC_DATE | DateUtils.FORMAT_SHOW_TIME + | DateUtils.FORMAT_SHOW_YEAR)); + /** + * TODO: Add the menu for setting alert. Currently disable it because the DateTimePicker + * is not ready + */ + showAlertHeader(); + } + + // 显示提醒信息的头部内容 +private void showAlertHeader() { + // 检查工作笔记是否有设定提醒 + if (mWorkingNote.hasClockAlert()) { + // 获取当前系统时间 + long time = System.currentTimeMillis(); + // 如果当前时间已经超过设定的提醒时间，则显示“提醒已过期” + if (time > mWorkingNote.getAlertDate()) { + mNoteHeaderHolder.tvAlertDate.setText(R.string.note_alert_expired); + } else { + // 否则显示相对时间（例如：1分钟之前，3小时之前等） + mNoteHeaderHolder.tvAlertDate.setText(DateUtils.getRelativeTimeSpanString( + mWorkingNote.getAlertDate(), time, DateUtils.MINUTE_IN_MILLIS)); + } + // 显示提醒日期文本和图标 + mNoteHeaderHolder.tvAlertDate.setVisibility(View.VISIBLE); + mNoteHeaderHolder.ivAlertIcon.setVisibility(View.VISIBLE); + } else { + // 如果没有设定提醒，隐藏提醒日期文本和图标 + mNoteHeaderHolder.tvAlertDate.setVisibility(View.GONE); + mNoteHeaderHolder.ivAlertIcon.setVisibility(View.GONE); + } +}; + +// 当新 Intent 被传递进来时，重新初始化活动状态 +@Override +protected void onNewIntent(Intent intent) { + super.onNewIntent(intent); + // 初始化活动的状态 + initActivityState(intent); +} + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + /** + * For new note without note id, we should firstly save it to + * generate a id. If the editing note is not worth saving, there + * is no id which is equivalent to create new note + */ + if (!mWorkingNote.existInDatabase()) { + saveNote(); + } + outState.putLong(Intent.EXTRA_UID, mWorkingNote.getNoteId()); + Log.d(TAG, "Save working note id: " + mWorkingNote.getNoteId() + " onSaveInstanceState"); + } + + @Override +public boolean dispatchTouchEvent(MotionEvent ev) { + // 判断笔记背景色选择器（mNoteBgColorSelector）是否可见，并且触摸事件是否发生在其区域外 + if (mNoteBgColorSelector.getVisibility() == View.VISIBLE + && !inRangeOfView(mNoteBgColorSelector, ev)) { + // 如果触摸事件发生在背景色选择器的区域外，则将其隐藏 + mNoteBgColorSelector.setVisibility(View.GONE); + return true; // 返回true，表示该事件已经被处理，不再向下传递 + } + + // 判断字体大小选择器（mFontSizeSelector）是否可见，并且触摸事件是否发生在其区域外 + if (mFontSizeSelector.getVisibility() == View.VISIBLE + && !inRangeOfView(mFontSizeSelector, ev)) { + // 如果触摸事件发生在字体大小选择器的区域外，则将其隐藏 + mFontSizeSelector.setVisibility(View.GONE); + return true; // 返回true，表示该事件已经被处理，不再向下传递 + } + + // 如果上述两个条件都不满足，则交由父类处理触摸事件 + return super.dispatchTouchEvent(ev); +} + +/** + * 判断触摸事件是否发生在指定视图（view）区域内 + * @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; // 触摸点在视图外部，返回false + } + return true; // 触摸点在视图内部，返回true +} + +private void initResources() { + // 查找并初始化笔记标题视图 + mHeadViewPanel = findViewById(R.id.note_title); + mNoteHeaderHolder = new HeadViewHolder(); + + // 初始化并绑定各个视图控件 + mNoteHeaderHolder.tvModified = (TextView) findViewById(R.id.tv_modified_date); // 显示修改日期的TextView + mNoteHeaderHolder.ivAlertIcon = (ImageView) findViewById(R.id.iv_alert_icon); // 显示提醒图标的ImageView + mNoteHeaderHolder.tvAlertDate = (TextView) findViewById(R.id.tv_alert_date); // 显示提醒日期的TextView + mNoteHeaderHolder.ibSetBgColor = (ImageView) findViewById(R.id.btn_set_bg_color); // 设置背景色的按钮（ImageView） + + // 为设置背景色的按钮设置点击监听器 + mNoteHeaderHolder.ibSetBgColor.setOnClickListener(this); + + // 初始化笔记编辑区域的控件 + mNoteEditor = (EditText) findViewById(R.id.note_edit_view); // 编辑笔记内容的EditText + mNoteEditorPanel = findViewById(R.id.sv_note_edit); // 包含笔记编辑区域的滚动视图 + + // 初始化背景色选择器视图 + mNoteBgColorSelector = findViewById(R.id.note_bg_color_selector); + + // 遍历背景色选择按钮并为每个按钮设置点击事件监听器 + for (int id : sBgSelectorBtnsMap.keySet()) { + ImageView iv = (ImageView) findViewById(id); + iv.setOnClickListener(this); + } + + // 初始化字体大小选择器视图 + mFontSizeSelector = findViewById(R.id.font_size_selector); + + // 遍历字体大小选择按钮并为每个按钮设置点击事件监听器 + for (int id : sFontSizeBtnsMap.keySet()) { + View view = findViewById(id); + view.setOnClickListener(this); + } + + // 获取默认共享偏好设置 + mSharedPrefs = PreferenceManager.getDefaultSharedPreferences(this); + + // 获取用户设置的字体大小ID，如果没有设置则使用默认值 + mFontSizeId = mSharedPrefs.getInt(PREFERENCE_FONT_SIZE, ResourceParser.BG_DEFAULT_FONT_SIZE); + + /** + * HACKME: Fix bug of store the resource id in shared preference. + * The id may larger than the length of resources, in this case, + * return the {@link ResourceParser#BG_DEFAULT_FONT_SIZE} + */ + if (mFontSizeId >= TextAppearanceResources.getResourcesSize()) { + mFontSizeId = ResourceParser.BG_DEFAULT_FONT_SIZE; // 如果字体ID不合法，则使用默认字体大小 + } + + // 初始化笔记编辑列表视图 + mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list); +} + + // 重写 onPause 方法，在活动暂停时保存笔记并清除设置状态 +@Override +protected void onPause() { + super.onPause(); + // 调用 saveNote() 方法保存笔记内容，若保存成功，输出日志 + if(saveNote()) { + Log.d(TAG, "Note data was saved with length:" + mWorkingNote.getContent().length()); + } + // 清除设置状态（例如背景色选择器和字体大小选择器等） + clearSettingState(); +} + +// 更新小部件的显示内容 +private void updateWidget() { + // 创建一个 Intent 用于通知 AppWidgetManager 更新小部件 + Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE); + + // 根据当前笔记的 widget 类型，选择相应的小部件提供者类 + 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 { + // 如果遇到不支持的 widget 类型，输出错误日志并返回 + Log.e(TAG, "Unspported widget type"); + return; + } + + // 将当前小部件的 ID 传递给小部件更新的 Intent + intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] { + mWorkingNote.getWidgetId() + }); + + // 发送广播通知更新小部件 + sendBroadcast(intent); + // 设置结果为 RESULT_OK + setResult(RESULT_OK, intent); +} + +// 处理点击事件，根据不同的按钮 ID 执行不同操作 +public void onClick(View v) { + int id = v.getId(); + + // 当点击设置背景色按钮时，显示颜色选择器 + if (id == R.id.btn_set_bg_color) { + mNoteBgColorSelector.setVisibility(View.VISIBLE); + // 显示当前背景色的选择框 + findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(View.VISIBLE); + + // 如果点击的是背景色选择按钮，更新背景色 + } 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); + // 保存字体大小设置到 SharedPreferences 中 + mSharedPrefs.edit().putInt(PREFERENCE_FONT_SIZE, mFontSizeId).commit(); + // 显示当前字体大小的选择框 + findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE); + + // 如果当前是待办清单模式，切换到清单模式 + if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) { + getWorkingText(); + switchToListMode(mWorkingNote.getContent()); + } else { + // 否则更新笔记的字体样式 + mNoteEditor.setTextAppearance(this, + TextAppearanceResources.getTexAppearanceResource(mFontSizeId)); + } + // 隐藏字体大小选择器 + mFontSizeSelector.setVisibility(View.GONE); + } +} + +// 重写 onBackPressed 方法，返回之前保存笔记或清除设置 +@Override +public void onBackPressed() { + // 如果清除设置状态成功，则直接返回 + if(clearSettingState()) { + return; + } + + // 保存笔记数据 + saveNote(); + // 调用父类的 onBackPressed 方法 + super.onBackPressed(); +} + +// 清除设置状态的方法，关闭背景色选择器或字体大小选择器 +private boolean clearSettingState() { + // 如果背景色选择器可见，隐藏它并返回 true + if (mNoteBgColorSelector.getVisibility() == View.VISIBLE) { + mNoteBgColorSelector.setVisibility(View.GONE); + return true; + // 如果字体大小选择器可见，隐藏它并返回 true + } else if (mFontSizeSelector.getVisibility() == View.VISIBLE) { + mFontSizeSelector.setVisibility(View.GONE); + return true; + } + // 如果都不可见，返回 false + return false; +} + +// 当背景色发生变化时，更新界面 +public void onBackgroundColorChanged() { + // 显示当前选中的背景色选择框 + findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(View.VISIBLE); + // 更新笔记编辑面板的背景色 + mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId()); + // 更新标题面板的背景色 + mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId()); +} + + + @Override +public boolean onPrepareOptionsMenu(Menu menu) { + if (isFinishing()) { + return true; // 如果 Activity 正在销毁，直接返回不做任何操作 + } + + clearSettingState(); // 清除设置状态（这个方法实现的细节不在代码中） + + menu.clear(); // 清空当前菜单项 + + // 根据当前笔记的文件夹 ID 加载不同的菜单 + if (mWorkingNote.getFolderId() == Notes.ID_CALL_RECORD_FOLDER) { + getMenuInflater().inflate(R.menu.call_note_edit, menu); // 如果是通话记录文件夹，加载 call_note_edit 菜单 + } 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; // 返回 true，表示菜单准备完毕 +} + + + @Override +public 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(); // 结束当前 Activity + } + }); + 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; // 返回 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(); // 显示日期时间选择器对话框 +} + + + /** + * Share note to apps that support {@link Intent#ACTION_SEND} action + * and {@text/plain} type + */ + 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); + } + + private void sendTo(Context context, String info) { + // 创建一个新的 Intent，动作为发送数据 (ACTION_SEND) + Intent intent = new Intent(Intent.ACTION_SEND); + + // 将要发送的文本信息放入 Intent 中 + intent.putExtra(Intent.EXTRA_TEXT, info); + + // 设置发送的数据类型为纯文本 + intent.setType("text/plain"); + + // 启动一个新的活动，允许用户选择一个可以处理该 Intent 的应用（例如邮件、短信或社交媒体应用等） + context.startActivity(intent); +} + + // Method to delete the current note from the database or move it to trash if in sync mode +private void deleteCurrentNote() { + // Check if the current note exists in the database + if (mWorkingNote.existInDatabase()) { + HashSet ids = new HashSet(); + long id = mWorkingNote.getNoteId(); + + // Check if the note ID is not the root folder ID + if (id != Notes.ID_ROOT_FOLDER) { + ids.add(id); // Add the note ID to the set for deletion + } else { + Log.d(TAG, "Wrong note id, should not happen"); + } + + // If not in sync mode, delete the note from the database + if (!isSyncMode()) { + if (!DataUtils.batchDeleteNotes(getContentResolver(), ids)) { + Log.e(TAG, "Delete Note error"); + } + } else { + // If in sync mode, move the note to the trash folder instead of deleting it + if (!DataUtils.batchMoveToFolder(getContentResolver(), ids, Notes.ID_TRASH_FOLER)) { + Log.e(TAG, "Move notes to trash folder error, should not happens"); + } + } + } + + // Mark the note as deleted (whether actually deleted or moved to trash) + mWorkingNote.markDeleted(true); +} + +// Method to check if the app is in sync mode by checking the sync account name +private boolean isSyncMode() { + return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0; +} + +// Method to handle changes to the clock alert for a note +public void onClockAlertChanged(long date, boolean set) { + // If the note doesn't exist in the database, save it before setting the clock alert + if (!mWorkingNote.existInDatabase()) { + saveNote(); + } + + // Ensure the note has a valid ID before setting the clock alert + if (mWorkingNote.getNoteId() > 0) { + Intent intent = new Intent(this, AlarmReceiver.class); + // Set the URI with the note ID to uniquely identify the note + intent.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mWorkingNote.getNoteId())); + + // Create a PendingIntent to trigger the alarm when it's time + PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, intent, 0); + AlarmManager alarmManager = ((AlarmManager) getSystemService(ALARM_SERVICE)); + showAlertHeader(); + + // If 'set' is true, schedule the alarm; otherwise, cancel the alarm + if (!set) { + alarmManager.cancel(pendingIntent); + } else { + alarmManager.set(AlarmManager.RTC_WAKEUP, date, pendingIntent); + } + } else { + // If the note doesn't have an ID, display an error since the user has not input any content + Log.e(TAG, "Clock alert setting error"); + showToast(R.string.error_note_empty_for_clock); + } +} + +// Method to handle changes made to the widget, requiring a widget update +public void onWidgetChanged() { + updateWidget(); +} + +// Method to handle the deletion of text from the edit text +public void onEditTextDelete(int index, String text) { + int childCount = mEditTextList.getChildCount(); + + // If there is only one child, no need to delete anything + if (childCount == 1) { + return; + } + + // Loop through the remaining child views to adjust their indices + for (int i = index + 1; i < childCount; i++) { + // Adjust the index of the text views after the deleted item + ((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text)) + .setIndex(i - 1); + } + + // Remove the view at the specified index + mEditTextList.removeViewAt(index); + + // Get the reference to the edit text after deletion + 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); + } + + // Append the text to the new edit text and set the cursor position + int length = edit.length(); + edit.append(text); + edit.requestFocus(); + edit.setSelection(length); +} + + + public void onEditTextEnter(int index, String text) { + /** + * Should not happen, check for debug + */ + if(index > mEditTextList.getChildCount()) { + Log.e(TAG, "Index out of mEditTextList boundary, should not happen"); + } + + /** + * 根据输入的文本和索引，获取一个新的视图项 + * getListItem() 方法应该根据索引和文本内容返回一个合适的视图（通常是一个EditText组件） + */ + View view = getListItem(text, index); + + /** + * 将新创建的视图添加到 mEditTextList 中，指定其位置为 index + */ + mEditTextList.addView(view, index); + + /** + * 获取视图中的 EditText 控件（假设它的 ID 是 et_edit_text） + * 然后请求焦点，使其成为当前活动的输入框 + */ + NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text); + edit.requestFocus(); + + /** + * 设置新获取的 EditText 控件的光标位置为 0（即文本框的最前面） + */ + edit.setSelection(0); + + /** + * 遍历当前列表中，索引值大于当前插入位置的所有 EditText 控件 + * 并将它们的索引值更新，确保它们在列表中的顺序正确 + */ + for (int i = index + 1; i < mEditTextList.getChildCount(); i++) { + ((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text)) + .setIndex(i); + } +} + + // 切换到列表模式的函数 +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); +} + +// 获取高亮显示查询结果的函数 +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; +} + +// 获取列表项视图的函数 +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; +} + + // 当文本内容变化时，更新相应的复选框的可见性 +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); + } +} + +// 处理检查列表模式的变化 +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); // 显示编辑器视图 + } +} + +// 获取当前工作文本，检查是否有选中的项，并构建工作文本 +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; // 返回是否有选中的项 +} + + private boolean saveNote() { + getWorkingText(); + boolean saved = mWorkingNote.saveNote(); + if (saved) { + /** + * There are two modes from List view to edit view, open one note, + * create/edit a node. Opening node requires to the original + * position in the list when back from edit view, while creating a + * new node requires to the top of the list. This code + * {@link #RESULT_OK} is used to identify the create/edit state + */ + setResult(RESULT_OK); + } + return saved; + } + + private void sendToDesktop() { + /** + * 在发送消息到桌面之前，我们需要确保当前正在编辑的笔记已存在于数据库中。 + * 对于新笔记，首先需要保存它。 + */ + if (!mWorkingNote.existInDatabase()) { + saveNote(); // 如果笔记不存在于数据库中，先保存笔记 + } + + // 确保笔记ID有效 + if (mWorkingNote.getNoteId() > 0) { + Intent sender = new Intent(); // 创建一个Intent对象用于发送广播 + Intent shortcutIntent = new Intent(this, NoteEditActivity.class); // 创建指向NoteEditActivity的Intent + shortcutIntent.setAction(Intent.ACTION_VIEW); // 设置Intent的动作为查看 + shortcutIntent.putExtra(Intent.EXTRA_UID, mWorkingNote.getNoteId()); // 将当前笔记的ID传递给Intent + sender.putExtra(Intent.EXTRA_SHORTCUT_INTENT, shortcutIntent); // 将shortcutIntent作为快捷方式的Intent + 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"); // 设置广播的action为安装快捷方式 + showToast(R.string.info_note_enter_desktop); // 显示快捷方式添加到桌面的提示 + sendBroadcast(sender); // 发送广播，通知系统添加快捷方式 + } else { + /** + * 如果笔记为空，即用户没有输入任何内容，无法生成有效的笔记ID，提醒用户 + * 输入有效的内容以便创建快捷方式。 + */ + Log.e(TAG, "Send to desktop error"); // 输出日志，说明发送快捷方式失败 + showToast(R.string.error_note_empty_for_send_to_desktop); // 显示错误信息 + } +} + +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; +} + +private void showToast(int resId) { + showToast(resId, Toast.LENGTH_SHORT); // 简化的showToast调用，使用短时间显示 +} + +private void showToast(int resId, int duration) { + Toast.makeText(this, resId, duration).show(); // 显示指定资源ID的Toast消息 +} +} diff --git a/NoteEditText.java b/NoteEditText.java new file mode 100644 index 0000000..edbddb3 --- /dev/null +++ b/NoteEditText.java @@ -0,0 +1,276 @@ +/* + * 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; + +// 引入相关的 Android 和 Java 库 +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; // 用于处理文本中的 URL 链接 +import android.util.AttributeSet; // 用于解析 XML 布局文件中的自定义属性 +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; // Android 中的编辑文本控件 + +// 引入项目中的资源文件 +import net.micode.notes.R; // 自定义的资源文件，可能是图片、字符串或布局 + +// 引入 HashMap 和 Map，用于存储一些键值对数据 +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; + + // 定义常量，表示不同的 URL scheme + private static final String SCHEME_TEL = "tel:"; // 电话链接 + private static final String SCHEME_HTTP = "http:"; // HTTP链接 + private static final String SCHEME_EMAIL = "mailto:"; // 邮件链接 + + // 创建一个映射，存储不同链接的处理方式 + private static final Map sSchemaActionResMap = new HashMap(); + + // 静态初始化块，将不同的 URL scheme 与对应的字符串资源 ID 关联 + static { + sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel); // 电话链接的处理方式 + sSchemaActionResMap.put(SCHEME_HTTP, R.string.note_link_web); // HTTP链接的处理方式 + sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email); // 邮件链接的处理方式 + } + + /** + * Call by the {@link NoteEditActivity} to delete or add edit text + */ + public interface OnTextViewChangeListener { + /** + * Delete current edit text when {@link KeyEvent#KEYCODE_DEL} happens + * and the text is null + */ + void onEditTextDelete(int index, String text); + + /** + * Add edit text after current edit text when {@link KeyEvent#KEYCODE_ENTER} + * happen + */ + void onEditTextEnter(int index, String text); + + /** + * Hide or show item option when text change + */ + void onTextChange(int index, boolean hasText); + } + + private OnTextViewChangeListener mOnTextViewChangeListener; + + public class NoteEditText extends EditText { + private int mIndex; // 用于存储索引 + private int mSelectionStartBeforeDelete; // 记录删除前的光标位置 + private OnTextViewChangeListener mOnTextViewChangeListener; // 用于监听文本变动的接口 + private static final String TAG = "NoteEditText"; // 日志标签 + + // 构造函数1：仅接受上下文作为参数 + public NoteEditText(Context context) { + super(context, null); + mIndex = 0; // 默认索引为0 + } + + // 构造函数2：接受上下文和属性集作为参数 + public NoteEditText(Context context, AttributeSet attrs) { + super(context, attrs, android.R.attr.editTextStyle); + } + + // 构造函数3：接受上下文、属性集和样式作为参数 + public NoteEditText(Context context, AttributeSet attrs, int defStyle) { + super(context, attrs, defStyle); + // 可以根据需要添加初始化代码 + } + + // 设置索引值的方法 + public void setIndex(int index) { + mIndex = index; + } + + // 设置监听器的方法 + public void setOnTextViewChangeListener(OnTextViewChangeListener listener) { + mOnTextViewChangeListener = listener; + } + + // 处理触摸事件，主要是设置光标位置 + @Override + public boolean onTouchEvent(MotionEvent event) { + switch (event.getAction()) { + case MotionEvent.ACTION_DOWN: + // 获取触摸位置 + int x = (int) event.getX(); + int y = (int) event.getY(); + + // 计算相对位置，考虑了内边距和滚动偏移 + x -= getTotalPaddingLeft(); + y -= getTotalPaddingTop(); + x += getScrollX(); + y += getScrollY(); + + // 获取文本布局对象 + Layout layout = getLayout(); + // 获取触摸点所在的行 + int line = layout.getLineForVertical(y); + // 获取该行中触摸点对应的字符偏移位置 + int off = layout.getOffsetForHorizontal(line, x); + // 设置光标到指定位置 + Selection.setSelection(getText(), off); + break; + } + + return super.onTouchEvent(event); // 默认处理 + } + + // 处理按键事件 + @Override + public boolean onKeyDown(int keyCode, KeyEvent event) { + switch (keyCode) { + case KeyEvent.KEYCODE_ENTER: + // 如果设置了监听器，按下回车键时返回 + if (mOnTextViewChangeListener != null) { + return false; // 返回false表示继续处理事件 + } + break; + case KeyEvent.KEYCODE_DEL: + // 记录删除前的光标位置 + mSelectionStartBeforeDelete = getSelectionStart(); + break; + default: + break; + } + return super.onKeyDown(keyCode, event); // 默认处理 + } + + // 处理按键抬起事件 + @Override + public boolean onKeyUp(int keyCode, KeyEvent event) { + switch(keyCode) { + case KeyEvent.KEYCODE_DEL: + // 删除键处理 + if (mOnTextViewChangeListener != null) { + // 如果删除前光标位置为0并且索引不为0，调用删除监听器 + if (0 == mSelectionStartBeforeDelete && mIndex != 0) { + mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString()); + return true; // 返回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(); + // 截取光标前的文本并设置回TextView + 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); // 默认处理 + } +} + + @Override +protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) { + // 检查是否有外部设置的文本改变监听器 + if (mOnTextViewChangeListener != null) { + // 如果文本框失去焦点并且文本为空 + if (!focused && TextUtils.isEmpty(getText())) { + // 调用文本改变监听器，传入索引和一个布尔值 'false' 表示文本为空 + mOnTextViewChangeListener.onTextChange(mIndex, false); + } else { + // 否则，调用监听器，传入 'true' 表示文本不为空 + mOnTextViewChangeListener.onTextChange(mIndex, true); + } + } + // 调用父类的 onFocusChanged 方法，以确保焦点改变时的默认行为（例如更新视觉效果）得到执行 + super.onFocusChanged(focused, direction, previouslyFocusedRect); +} + +@Override +protected void onCreateContextMenu(ContextMenu menu) { + // 检查当前文本是否是 Spanned 类型，Spanned 是一个支持富文本的接口（例如超链接） + if (getText() instanceof Spanned) { + // 获取选中的文本范围 + int selStart = getSelectionStart(); + int selEnd = getSelectionEnd(); + + // 确定选中的最小和最大位置（防止选区反向） + int min = Math.min(selStart, selEnd); + int max = Math.max(selStart, selEnd); + + // 获取选中的文本中所有的 URLSpan（超链接） + final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class); + // 如果选中的区域包含一个 URLSpan（即只有一个超链接） + if (urls.length == 1) { + // 默认的资源 ID + int defaultResId = 0; + // 遍历所有已知的 URL schema 类型（如 http://, https:// 等），匹配 URL + for(String schema: sSchemaActionResMap.keySet()) { + // 如果 URL 中包含某个 schema 类型 + if(urls[0].getURL().indexOf(schema) >= 0) { + // 根据匹配的 schema 获取对应的资源 ID + defaultResId = sSchemaActionResMap.get(schema); + break; + } + } + + // 如果没有找到匹配的 schema，使用一个默认的字符串资源 ID + if (defaultResId == 0) { + defaultResId = R.string.note_link_other; + } + + // 向上下文菜单中添加一个菜单项，默认文本为链接的类型描述 + menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener( + new OnMenuItemClickListener() { + public boolean onMenuItemClick(MenuItem item) { + // 在菜单项点击时触发超链接的点击事件 + urls[0].onClick(NoteEditText.this); + return true; + } + }); + } + } + // 调用父类的 onCreateContextMenu 方法，以确保默认的上下文菜单行为 + super.onCreateContextMenu(menu); +} +} -- 2.34.1 From 218be1687f46a39d3fe71cb53db58b242ab62594 Mon Sep 17 00:00:00 2001 From: gaoxiaorui <3502644298@qq.com> Date: Sat, 16 Nov 2024 21:24:29 +0800 Subject: [PATCH 07/10] =?UTF-8?q?=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- NotesListActivity.java | 1219 ++++++++++++++++++++++++++++++++++++++++ NotesListAdapter.java | 215 +++++++ 2 files changed, 1434 insertions(+) create mode 100644 NotesListActivity.java create mode 100644 NotesListAdapter.java diff --git a/NotesListActivity.java b/NotesListActivity.java new file mode 100644 index 0000000..1db68d0 --- /dev/null +++ b/NotesListActivity.java @@ -0,0 +1,1219 @@ +/* + * 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; + +// 导入Android框架中的各种类 +import android.app.Activity; // 用于创建和管理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; // 用于存储Activity的状态 +import android.preference.PreferenceManager; // 管理SharedPreferences的工具类 +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; // 用于适配器视图（如ListView）的操作 +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; // 用于显示短暂消息的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; // 用于Google任务同步服务 +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; // 用于App Widget的适配器 +import net.micode.notes.widget.NoteWidgetProvider_2x; // 用于提供2x大小的笔记小部件 +import net.micode.notes.widget.NoteWidgetProvider_4x; // 用于提供4x大小的笔记小部件 + +import java.io.BufferedReader; // 用于缓冲读取文本数据 +import java.io.IOException; // 用于处理I/O异常 +import java.io.InputStream; // 用于输入流操作 +import java.io.InputStreamReader; // 用于将输入流转换为字符流 +import java.util.HashSet; // 用于存储唯一元素的集合 + +// 在代码中添加详细注释，解释每个功能模块的作用和实现细节。 +// 比如上面引入了很多Android类和自定义类，接下来代码会用到这些类来实现应用程序的具体功能。 + +public class NotesListActivity extends Activity implements OnClickListener, OnItemLongClickListener { + + // 定义了两个常量用于标识查询操作的 token + 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; + + // 处理后台查询操作的 Handler + private BackgroundQueryHandler mBackgroundQueryHandler; + + // 用于显示笔记列表的适配器 + private NotesListAdapter mNotesListAdapter; + + // 用于显示笔记列表的 ListView 控件 + private ListView mNotesListView; + + // 新建笔记的按钮 + private Button mAddNewNote; + + // 是否正在调度某些操作的标识 + private boolean mDispatch; + + // 记录初始的 Y 坐标位置 + private int mOriginY; + + // 记录当前调度的 Y 坐标位置 + private int mDispatchY; + + // 标题栏文本 + private TextView mTitleBar; + + // 当前文件夹的 ID + private long mCurrentFolderId; + + // 内容解析器，用于与内容提供者交互 + private ContentResolver mContentResolver; + + // 模式回调，用于响应 UI 操作 + private ModeCallback mModeCallBack; + + // 日志标签 + private static final String TAG = "NotesListActivity"; + + // 设置滚动速率 + public static final int NOTES_LISTVIEW_SCROLL_RATE = 30; + + // 当前聚焦的笔记数据项 + private NoteItemData mFocusNoteDataItem; + + // 用于查询的正常选择条件：父目录 ID + 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; + + @Override +protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + // 设置当前活动的布局文件 + setContentView(R.layout.note_list); + + // 初始化资源，可能包括数据库、界面元素等 + initResources(); + + /** + * Insert an introduction when user firstly use this application + */ + setAppInfoFromRawRes(); +} + +@Override +protected void onActivityResult(int requestCode, int resultCode, Intent data) { + // 处理返回结果，主要是针对打开或新建笔记的操作 + if (resultCode == RESULT_OK + && (requestCode == REQUEST_CODE_OPEN_NODE || requestCode == REQUEST_CODE_NEW_NODE)) { + // 如果是打开或新建笔记成功，更新列表适配器，清空数据（重新加载） + mNotesListAdapter.changeCursor(null); + } else { + // 否则，调用父类的 onActivityResult 处理 + super.onActivityResult(requestCode, resultCode, data); + } +} + +private void setAppInfoFromRawRes() { + // 获取应用的 SharedPreferences，用于存储应用的设置 + SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this); + + // 判断是否已经添加过介绍内容，如果添加过则不再执行 + if (!sp.getBoolean(PREFERENCE_ADD_INTRODUCTION, false)) { + // 创建一个 StringBuilder 来存储介绍内容 + StringBuilder sb = new StringBuilder(); + InputStream in = null; + + try { + // 打开 raw 资源文件，获取介绍内容 + in = getResources().openRawResource(R.raw.introduction); + + // 如果文件成功读取 + if (in != null) { + InputStreamReader isr = new InputStreamReader(in); + BufferedReader br = new BufferedReader(isr); + char[] buf = new char[1024]; + int len = 0; + + // 逐行读取文件内容并追加到 StringBuilder 中 + 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 { + // 关闭输入流，确保资源被释放 + 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()); + + // 保存介绍笔记，并在 SharedPreferences 中标记已添加介绍内容 + if (note.saveNote()) { + sp.edit().putBoolean(PREFERENCE_ADD_INTRODUCTION, true).commit(); + } else { + // 如果保存笔记失败，输出错误日志 + Log.e(TAG, "Save introduction note error"); + return; + } + } +} + + + @Override + protected void onStart() { + super.onStart(); + startAsyncNotesListQuery(); + } + + private void initResources() { + mContentResolver = this.getContentResolver(); + mBackgroundQueryHandler = new BackgroundQueryHandler(this.getContentResolver()); + mCurrentFolderId = Notes.ID_ROOT_FOLDER; + 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(); + } + + // ModeCallback 类实现了 MultiChoiceModeListener 和 OnMenuItemClickListener +// 用于支持 ListView 的多选模式以及自定义菜单的行为 +private class ModeCallback implements ListView.MultiChoiceModeListener, OnMenuItemClickListener { + private DropdownMenu mDropDownMenu; // 定义下拉菜单 + private ActionMode mActionMode; // 当前的 ActionMode + private MenuItem mMoveMenu; // 移动菜单项 + + // 当启动 ActionMode 时触发 + 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); + } + + // 设置 ActionMode 实例 + mActionMode = mode; + + // 设置 ListView 为多选模式 + mNotesListAdapter.setChoiceMode(true); + + // 禁止长按列表项时触发点击事件 + mNotesListView.setLongClickable(false); + + // 隐藏“新建笔记”按钮 + mAddNewNote.setVisibility(View.GONE); + + // 加载自定义视图到 ActionMode 中 + 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; + } + }); + + // 返回 true 表示成功创建了 ActionMode + 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); + } + } + } + + + public boolean onPrepareActionMode(ActionMode mode, Menu menu) { + // TODO Auto-generated method stub + return false; + } + + public boolean onActionItemClicked(ActionMode mode, MenuItem item) { + // TODO Auto-generated method stub + return false; + } + + public void onDestroyActionMode(ActionMode mode) { + // 退出 ActionMode 时，禁用选择模式，并恢复原有状态。 + mNotesListAdapter.setChoiceMode(false); // 禁用适配器中的选择模式（即禁用多选） + mNotesListView.setLongClickable(true); // 使 ListView 恢复长按事件的响应 + mAddNewNote.setVisibility(View.VISIBLE); // 恢复显示“添加新笔记”按钮 +} + +public void finishActionMode() { + // 结束当前的 ActionMode，通常是在完成操作后调用 + mActionMode.finish(); // 调用 ActionMode 的 finish 方法来结束当前操作模式 +} + +public void onItemCheckedStateChanged(ActionMode mode, int position, long id, + boolean checked) { + // 在用户选中或取消选择某项时调用 + mNotesListAdapter.setCheckedItem(position, checked); // 更新适配器中选项的选中状态 + updateMenu(); // 更新菜单项（例如更新删除或移动按钮的状态） +} + +public boolean onMenuItemClick(MenuItem item) { + // 当用户点击 ActionMode 菜单中的某项时调用 + if (mNotesListAdapter.getSelectedCount() == 0) { + // 如果没有任何项被选中，显示提示消息 + Toast.makeText(NotesListActivity.this, getString(R.string.menu_select_none), + Toast.LENGTH_SHORT).show(); + return true; // 消费该事件 + } + + // 处理菜单项点击事件 + switch (item.getItemId()) { + case R.id.delete: + // 用户选择删除 + AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this); + builder.setTitle(getString(R.string.alert_title_delete)) // 设置对话框标题 + .setIcon(android.R.drawable.ic_dialog_alert) // 设置对话框图标 + .setMessage(getString(R.string.alert_message_delete_notes, + mNotesListAdapter.getSelectedCount())) // 设置删除提示信息，显示选中项的数量 + .setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int which) { + batchDelete(); // 执行批量删除操作 + } + }) + .setNegativeButton(android.R.string.cancel, null) // 取消按钮 + .show(); // 显示对话框 + break; + case R.id.move: + // 用户选择移动 + startQueryDestinationFolders(); // 启动查询目标文件夹的操作 + break; + default: + return false; // 其他菜单项，返回 false，不处理 + } + return true; // 表示该事件已被处理 + } +} + private class NewNoteOnTouchListener implements OnTouchListener { + + 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(); + /** + * Minus TitleBar's height + */ + if (mState == ListEditState.SUB_FOLDER) { + eventY -= mTitleBar.getHeight(); + start -= mTitleBar.getHeight(); + } + /** + * HACKME:When click the transparent part of "New Note" button, dispatch + * the event to the list view behind this button. The transparent part of + * "New Note" button could be expressed by formula y=-0.12x+94（Unit:pixel） + * and the line top of the button. The coordinate based on left of the "New + * Note" button. The 94 represents maximum height of the transparent part. + * Notice that, if the background of the button changes, the formula should + * also change. This is very bad, just for the UI designer's strong requirement. + */ + 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; + } + } + return false; + } + + }; + + // 启动异步查询，查询当前文件夹的笔记列表 +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) // 当前文件夹ID作为查询参数 + }, + NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC"); // 按类型和修改日期降序排序 +} + +// 定义异步查询处理类，继承自 AsyncQueryHandler +private final class BackgroundQueryHandler extends AsyncQueryHandler { + + // 构造方法，传入ContentResolver + public BackgroundQueryHandler(ContentResolver contentResolver) { + super(contentResolver); + } + + // 查询完成后的回调方法 + @Override + protected void onQueryComplete(int token, Object cookie, Cursor cursor) { + switch (token) { + // 如果查询的是笔记列表 + case FOLDER_NOTE_LIST_QUERY_TOKEN: + // 将查询结果的Cursor设置到适配器中 + 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; + } + } +} + +// 显示文件夹列表的弹出菜单 +private void showFolderListMenu(Cursor cursor) { + // 创建AlertDialog.Builder来构建对话框 + AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this); + builder.setTitle(R.string.menu_title_select_folder); // 设置对话框标题 + + // 创建一个自定义的Adapter来显示文件夹列表 + final FoldersListAdapter adapter = new FoldersListAdapter(this, cursor); + + // 设置对话框的Adapter和点击事件 + builder.setAdapter(adapter, new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int which) { + // 执行批量移动笔记到所选文件夹 + DataUtils.batchMoveToFolder(mContentResolver, + mNotesListAdapter.getSelectedItemIds(), adapter.getItemId(which)); + + // 显示提示Toast，告知用户笔记已成功移动 + Toast.makeText( + NotesListActivity.this, + getString(R.string.format_move_notes_to_folder, + mNotesListAdapter.getSelectedCount(), + adapter.getFolderName(NotesListActivity.this, which)), + Toast.LENGTH_SHORT).show(); + + // 结束Action Mode，取消选择模式 + mModeCallBack.finishActionMode(); + } + }); + + // 显示对话框 + builder.show(); +} + +// 创建新的笔记 +private void createNewNote() { + // 创建一个Intent，跳转到NoteEditActivity来编辑或插入新笔记 + Intent intent = new Intent(this, NoteEditActivity.class); + intent.setAction(Intent.ACTION_INSERT_OR_EDIT); // 设置操作类型为插入或编辑 + intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mCurrentFolderId); // 传递当前文件夹ID + this.startActivityForResult(intent, REQUEST_CODE_NEW_NODE); // 启动活动并等待结果 +} + + + private void batchDelete() { + new AsyncTask>() { + // 后台线程任务，执行批量删除操作 + protected HashSet doInBackground(Void... unused) { + // 获取用户选中的小部件 + HashSet 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"); + } + } + // 返回小部件的集合，以便在UI线程更新 + return widgets; + } + + // 在后台任务执行完后更新UI + @Override + protected void onPostExecute(HashSet widgets) { + // 如果有小部件信息，更新相关的小部件 + if (widgets != null) { + for (AppWidgetAttribute widget : widgets) { + // 如果小部件ID有效且类型不是无效类型，则更新小部件 + if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID + && widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) { + updateWidget(widget.widgetId, widget.widgetType); + } + } + } + // 执行完成后，结束操作模式 + mModeCallBack.finishActionMode(); + } + }.execute(); +} +private void deleteFolder(long folderId) { + // 检查文件夹ID是否是根文件夹的ID，根文件夹不能被删除 + if (folderId == Notes.ID_ROOT_FOLDER) { + Log.e(TAG, "Wrong folder id, should not happen " + folderId); // 打印错误日志 + return; // 如果是根文件夹，返回不做任何操作 + } + + // 创建一个HashSet来保存要删除的文件夹ID + HashSet ids = new HashSet(); + ids.add(folderId); + + // 获取与该文件夹相关的所有小部件（AppWidget），可能有些文件夹有附加的小部件 + HashSet 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) { + // 如果小部件ID有效且小部件类型不是无效类型，则更新小部件 + if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID + && widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) { + // 更新小部件（例如：刷新其显示或者移除等操作） + updateWidget(widget.widgetId, widget.widgetType); + } + } + } +} + + // 打开一个特定的NoteItem (笔记项)并启动NoteEditActivity +private void openNode(NoteItemData data) { + // 创建一个Intent，指定目标Activity为NoteEditActivity + Intent intent = new Intent(this, NoteEditActivity.class); + + // 设置Intent的Action为查看 (ACTION_VIEW) + intent.setAction(Intent.ACTION_VIEW); + + // 将NoteItem的ID作为额外数据传递到NoteEditActivity + intent.putExtra(Intent.EXTRA_UID, data.getId()); + + // 启动NoteEditActivity，并等待返回结果 + this.startActivityForResult(intent, REQUEST_CODE_OPEN_NODE); +} + +// 打开一个文件夹，更新当前文件夹ID并查询相关笔记 +private void openFolder(NoteItemData data) { + // 更新当前文件夹ID + mCurrentFolderId = data.getId(); + + // 启动异步笔记列表查询 + startAsyncNotesListQuery(); + + // 如果当前是“通话记录”文件夹，设置不同的状态和UI + if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) { + mState = ListEditState.CALL_RECORD_FOLDER; + mAddNewNote.setVisibility(View.GONE); // 隐藏新建笔记按钮 + } else { + mState = ListEditState.SUB_FOLDER; + } + + // 根据文件夹的ID设置标题栏文字 + 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); +} + +// 处理点击事件 +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); + } +} + +// 隐藏软键盘 +private void hideSoftInput(View view) { + // 获取输入法管理器服务 + InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); + + // 隐藏软键盘，传递当前视图的WindowToken + inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0); +} + + + private void showCreateOrModifyFolderDialog(final boolean create) { + // 创建一个AlertDialog.Builder对象，用于构建对话框 + final AlertDialog.Builder builder = new AlertDialog.Builder(this); + + // 加载自定义的布局（dialog_edit_text），并获取其中的EditText控件 + View view = LayoutInflater.from(this).inflate(R.layout.dialog_edit_text, null); + final EditText etName = (EditText) view.findViewById(R.id.et_foler_name); + + // 显示软键盘，准备输入 + showSoftInput(); + + // 如果不是创建文件夹（即是修改文件夹），设置EditText的文本为当前文件夹的名称 + 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"); // 如果没有选中的文件夹，记录错误日志 + return; + } + } else { + // 如果是创建文件夹，设置EditText为空 + 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); // 隐藏软键盘 + + // 获取EditText中的文件夹名称 + String name = etName.getText().toString(); + + // 检查文件夹名称是否已存在（DataUtils.checkVisibleFolderName方法进行检查） + 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()) // 使用选中的文件夹ID进行更新 + }); + } + } 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); + } + /** + * When the name edit text is null, disable the positive button + */ + etName.addTextChangedListener(new TextWatcher() { + public void beforeTextChanged(CharSequence s, int start, int count, int after) { + // TODO Auto-generated method stub + + } + + 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) { + // TODO Auto-generated method stub + + } + }); + } + + // 重写返回按钮的行为 +@Override +public 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; + } +} + +// 更新小部件的方法 +private void updateWidget(int appWidgetId, int appWidgetType) { + // 创建一个更新小部件的广播意图 + Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE); + + // 根据小部件类型设置对应的小部件提供者 + if (appWidgetType == Notes.TYPE_WIDGET_2X) { + intent.setClass(this, NoteWidgetProvider_2x.class); // 设置2x小部件提供者 + } else if (appWidgetType == Notes.TYPE_WIDGET_4X) { + intent.setClass(this, NoteWidgetProvider_4x.class); // 设置4x小部件提供者 + } else { + Log.e(TAG, "Unspported widget type"); // 如果小部件类型不支持，则记录错误日志 + return; + } + + // 添加小部件ID到意图中 + 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); + } + } +}; + +// 当上下文菜单关闭时，移除监听器并调用父类方法 +@Override +public void onContextMenuClosed(Menu menu) { + if (mNotesListView != null) { + mNotesListView.setOnCreateContextMenuListener(null); // 移除菜单监听器 + } + super.onContextMenuClosed(menu); // 调用父类方法 +} + +// 处理上下文菜单项被选中的事件 +@Override +public boolean onContextItemSelected(MenuItem item) { + // 如果当前没有选中笔记项，返回false + if (mFocusNoteDataItem == null) { + Log.e(TAG, "The long click data item is null"); // 记录错误日志 + return false; + } + + // 根据菜单项的ID处理不同的操作 + 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; +} + + @Override +public boolean onPrepareOptionsMenu(Menu menu) { + // 清空菜单中的所有项 + menu.clear(); + + // 根据当前状态（mState）设置不同的菜单 + if (mState == ListEditState.NOTE_LIST) { + // 如果当前状态是 NOTE_LIST，加载 note_list 菜单 + getMenuInflater().inflate(R.menu.note_list, menu); + + // 设置同步（sync）或者取消同步（sync_cancel）菜单项的标题 + menu.findItem(R.id.menu_sync).setTitle( + GTaskSyncService.isSyncing() ? R.string.menu_sync_cancel : R.string.menu_sync); + } else if (mState == ListEditState.SUB_FOLDER) { + // 如果当前状态是 SUB_FOLDER，加载 sub_folder 菜单 + getMenuInflater().inflate(R.menu.sub_folder, menu); + } else if (mState == ListEditState.CALL_RECORD_FOLDER) { + // 如果当前状态是 CALL_RECORD_FOLDER，加载 call_record_folder 菜单 + getMenuInflater().inflate(R.menu.call_record_folder, menu); + } else { + // 如果状态不符合任何已知类型，打印错误日志 + Log.e(TAG, "Wrong state:" + mState); + } + return true; +} + +@Override +public 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; +} + +@Override +public boolean onSearchRequested() { + // 启动应用内搜索界面 + startSearch(null, false, null /* appData */, false); + return true; +} + + // 导出笔记到文本文件的函数 +private void exportNoteToText() { + // 获取 BackupUtils 实例 + final BackupUtils backup = BackupUtils.getInstance(NotesListActivity.this); + + // 异步任务：导出笔记 + new AsyncTask() { + + // 在后台线程中执行的任务 + @Override + protected Integer doInBackground(Void... unused) { + // 执行备份操作并返回结果状态 + return backup.exportToText(); + } + + // 在主线程中处理任务完成后的结果 + @Override + protected void onPostExecute(Integer result) { + // 根据不同的返回状态弹出不同的提示框 + + // 如果 SD 卡未挂载 + if (result == BackupUtils.STATE_SD_CARD_UNMOUONTED) { + AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this); + builder.setTitle(NotesListActivity.this.getString(R.string.failed_sdcard_export)); // 设置标题 + builder.setMessage(NotesListActivity.this.getString(R.string.error_sdcard_unmounted)); // 设置消息内容 + builder.setPositiveButton(android.R.string.ok, null); // 设置确认按钮 + builder.show(); // 显示提示框 + } + // 如果导出成功 + else if (result == BackupUtils.STATE_SUCCESS) { + AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this); + builder.setTitle(NotesListActivity.this.getString(R.string.success_sdcard_export)); // 设置标题 + builder.setMessage(NotesListActivity.this.getString(R.string.format_exported_file_location, backup.getExportedTextFileName(), backup.getExportedTextFileDir())); // 设置消息内容，包含文件路径 + builder.setPositiveButton(android.R.string.ok, null); // 设置确认按钮 + builder.show(); // 显示提示框 + } + // 如果发生了系统错误 + else if (result == BackupUtils.STATE_SYSTEM_ERROR) { + AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this); + builder.setTitle(NotesListActivity.this.getString(R.string.failed_sdcard_export)); // 设置标题 + builder.setMessage(NotesListActivity.this.getString(R.string.error_sdcard_export)); // 设置错误信息 + builder.setPositiveButton(android.R.string.ok, null); // 设置确认按钮 + builder.show(); // 显示提示框 + } + } + + }.execute(); // 执行异步任务 +} + +// 判断是否处于同步模式 +private boolean isSyncMode() { + // 如果同步账户名称不为空，表示处于同步模式 + return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0; +} + +// 启动设置活动页面 +private void startPreferenceActivity() { + // 获取当前活动的父活动，如果没有父活动，则使用当前活动 + Activity from = getParent() != null ? getParent() : this; + // 创建 Intent，启动设置界面 + 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) { + + // 确保点击的视图是 NotesListItem 类型 + if (view instanceof NotesListItem) { + NoteItemData item = ((NotesListItem) view).getItemData(); // 获取点击项的 NoteItemData + + // 如果处于多选模式 + if (mNotesListAdapter.isInChoiceMode()) { + // 如果项的类型是 Note 类型 + 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); + } + // 如果项是 Note 类型，打开笔记 + 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: + // 如果项是 Note 类型，打开笔记 + if (item.getType() == Notes.TYPE_NOTE) { + openNode(item); + } else { + Log.e(TAG, "Wrong note type in SUB_FOLDER"); // 如果项类型不正确，输出错误日志 + } + break; + default: + break; // 默认情况下不做任何事情 + } + } + } +} + + + // 开始查询目标文件夹 +private void startQueryDestinationFolders() { + // 设置查询条件：文件类型是文件夹且父文件夹ID不等于给定的ID，ID不等于给定的ID + String selection = NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>? AND " + NoteColumns.ID + "<>?"; + + // 根据当前状态决定是否需要添加额外的条件 + // 如果当前状态是NOTE_LIST，则使用原始查询条件；否则，添加一个OR条件，查询ID为根文件夹的项 + selection = (mState == ListEditState.NOTE_LIST) ? selection : + "(" + selection + ") OR (" + NoteColumns.ID + "=" + Notes.ID_ROOT_FOLDER + ")"; + + // 启动后台查询，使用FOLDER_LIST_QUERY_TOKEN标识该查询 + mBackgroundQueryHandler.startQuery(FOLDER_LIST_QUERY_TOKEN, + null, // 不需要指定查询的特定ID + Notes.CONTENT_NOTE_URI, // 数据源URI + FoldersListAdapter.PROJECTION, // 查询的列 + selection, // 查询条件 + new String[] { + String.valueOf(Notes.TYPE_FOLDER), // 查询文件夹类型 + String.valueOf(Notes.ID_TRASH_FOLER), // 查询垃圾桶文件夹 + String.valueOf(mCurrentFolderId) // 当前文件夹ID + }, + NoteColumns.MODIFIED_DATE + " DESC"); // 根据修改日期降序排列 +} + +// 处理列表项的长按事件 +public boolean onItemLongClick(AdapterView parent, View view, int position, long id) { + // 确保视图是NotesListItem类型 + if (view instanceof NotesListItem) { + mFocusNoteDataItem = ((NotesListItem) view).getItemData(); // 获取长按项的数据 + + // 判断长按的项是否为笔记类型且没有进入选择模式 + if (mFocusNoteDataItem.getType() == Notes.TYPE_NOTE && !mNotesListAdapter.isInChoiceMode()) { + // 启动操作模式（ActionMode），该模式用于管理选中的项 + if (mNotesListView.startActionMode(mModeCallBack) != null) { + // 在选择模式中选择当前项 + mModeCallBack.onItemCheckedStateChanged(null, position, id, true); + + // 反馈给用户，表示长按事件发生 + mNotesListView.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS); + } else { + // 如果启动ActionMode失败，打印错误日志 + Log.e(TAG, "startActionMode fails"); + } + } + // 判断长按的项是否为文件夹类型 + else if (mFocusNoteDataItem.getType() == Notes.TYPE_FOLDER) { + // 设置文件夹的上下文菜单监听器 + mNotesListView.setOnCreateContextMenuListener(mFolderOnCreateContextMenuListener); + } + } + // 返回false表示该事件没有完全处理，交由其他事件处理器继续处理 + return false; +} +} \ No newline at end of file diff --git a/NotesListAdapter.java b/NotesListAdapter.java new file mode 100644 index 0000000..5492a85 --- /dev/null +++ b/NotesListAdapter.java @@ -0,0 +1,215 @@ +/* + * 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; + +// 导入Android相关的库，用于处理数据库查询和视图的适配 +import android.content.Context; // 用于处理应用程序上下文 +import android.database.Cursor; // 用于数据库查询的游标 +import android.util.Log; // 用于记录日志 +import android.view.View; // 用于视图组件 +import android.view.ViewGroup; // 用于视图容器 +import android.widget.CursorAdapter; // 用于适配器，绑定数据库游标到视图 + +// 导入与笔记相关的类 +import net.micode.notes.data.Notes; // 用于操作笔记数据 + +// 导入集合类，用于数据存储和处理 +import java.util.Collection; // 用于操作一组对象 +import java.util.HashMap; // 用于存储键值对 +import java.util.HashSet; // 用于存储唯一元素集合 +import java.util.Iterator; // 用于遍历集合元素 + + +// 自定义适配器，用于显示笔记列表 +public class NotesListAdapter extends CursorAdapter { + private static final String TAG = "NotesListAdapter"; // 日志标签 + private Context mContext; // 上下文对象，用于访问应用资源 + private HashMap mSelectedIndex; // 用于存储选中项的索引和状态 + private int mNotesCount; // 当前笔记数量 + private boolean mChoiceMode; // 是否处于选择模式 + + // 内部类，用于存储小部件相关的属性 + public static class AppWidgetAttribute { + public int widgetId; // 小部件的 ID + public int widgetType; // 小部件的类型 + }; + + // 构造函数，初始化适配器 + public NotesListAdapter(Context context) { + super(context, null); // 调用父类构造函数，传入上下文和空游标 + mSelectedIndex = new HashMap(); // 初始化存储选中项的 HashMap + mContext = context; // 设置上下文 + mNotesCount = 0; // 初始化笔记数量 + } + + // 创建新视图，当每一项数据被绑定时，调用此方法 + @Override + public View newView(Context context, Cursor cursor, ViewGroup parent) { + return new NotesListItem(context); // 返回一个新的 NotesListItem 视图 + } + + // 绑定数据到视图上 + @Override + public void bindView(View view, Context context, Cursor cursor) { + if (view instanceof NotesListItem) { // 如果视图是 NotesListItem 类型 + // 从游标中提取数据，构建 NoteItemData 对象 + NoteItemData itemData = new NoteItemData(context, cursor); + // 将数据绑定到视图中，并考虑选择模式和选中状态 + ((NotesListItem) view).bind(context, itemData, mChoiceMode, + isSelectedItem(cursor.getPosition())); + } + } + + // 设置指定位置的选中状态 + public void setCheckedItem(final int position, final boolean checked) { + mSelectedIndex.put(position, checked); // 更新选中状态 + notifyDataSetChanged(); // 通知数据发生变化，刷新视图 + } + + // 判断是否处于选择模式 + public boolean isInChoiceMode() { + return mChoiceMode; + } + + // 设置是否进入选择模式 + public void setChoiceMode(boolean mode) { + mSelectedIndex.clear(); // 清除所有选中状态 + mChoiceMode = mode; // 设置选择模式 + } + + // 选择所有项目或取消选择 + 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集合 +public HashSet getSelectedItemIds() { + HashSet itemSet = new HashSet(); // 创建一个HashSet来存储选中的ID + // 遍历所有选中的项的索引 + for (Integer position : mSelectedIndex.keySet()) { + if (mSelectedIndex.get(position) == true) { // 判断该项是否被选中 + Long id = getItemId(position); // 获取该项的ID + if (id == Notes.ID_ROOT_FOLDER) { // 如果ID为根文件夹ID，记录日志并跳过该项 + Log.d(TAG, "Wrong item id, should not happen"); + } else { + itemSet.add(id); // 将ID添加到itemSet中 + } + } + } + return itemSet; // 返回所有选中项的ID集合 +} + +// 获取已选择的小部件（AppWidget）属性集合 +public HashSet getSelectedWidget() { + HashSet itemSet = new HashSet(); // 创建一个HashSet来存储选中的小部件属性 + // 遍历所有选中的项的索引 + for (Integer position : mSelectedIndex.keySet()) { + if (mSelectedIndex.get(position) == true) { // 判断该项是否被选中 + Cursor c = (Cursor) getItem(position); // 获取该项的Cursor对象 + if (c != null) { // 如果Cursor不为空，则处理该项 + AppWidgetAttribute widget = new AppWidgetAttribute(); // 创建一个AppWidgetAttribute对象 + NoteItemData item = new NoteItemData(mContext, c); // 使用Cursor对象初始化NoteItemData + widget.widgetId = item.getWidgetId(); // 获取小部件ID + widget.widgetType = item.getWidgetType(); // 获取小部件类型 + itemSet.add(widget); // 将小部件属性添加到itemSet中 + // 注意：不要在这里关闭Cursor，由适配器负责关闭 + } else { + Log.e(TAG, "Invalid cursor"); // 如果Cursor为空，记录错误日志并返回null + return null; + } + } + } + return itemSet; // 返回所有选中项的小部件属性集合 +} + +// 获取已选中项的数量 +public int getSelectedCount() { + Collection values = mSelectedIndex.values(); // 获取选中项的状态集合 + if (null == values) { + return 0; // 如果没有选中项，返回0 + } + Iterator iter = values.iterator(); + int count = 0; + // 遍历选中项状态，如果为true则计数 + while (iter.hasNext()) { + if (true == iter.next()) { + count++; + } + } + return count; // 返回选中项的数量 +} + +// 判断是否所有项都被选中 +public boolean isAllSelected() { + int checkedCount = getSelectedCount(); // 获取已选中项的数量 + return (checkedCount != 0 && checkedCount == mNotesCount); // 如果已选中项的数量等于总项数，则返回true +} + +// 判断某个位置的项是否被选中 +public boolean isSelectedItem(final int position) { + if (null == mSelectedIndex.get(position)) { + return false; // 如果该位置没有被选中，返回false + } + return mSelectedIndex.get(position); // 返回该位置的选中状态 + + + @Override +protected void onContentChanged() { + // 当内容发生变化时调用，通常用于刷新UI或更新数据 + super.onContentChanged(); + // 重新计算笔记的数量 + calcNotesCount(); +} + +@Override +public void changeCursor(Cursor cursor) { + // 当游标（Cursor）发生变化时调用，通常在数据更新时触发 + super.changeCursor(cursor); + // 重新计算笔记的数量 + calcNotesCount(); +} + +private void calcNotesCount() { + // 初始化笔记数量为0 + mNotesCount = 0; + // 遍历当前的数据项，假设这些数据项是通过Cursor获取的 + for (int i = 0; i < getCount(); i++) { + // 获取当前位置的Cursor对象 + Cursor c = (Cursor) getItem(i); + if (c != null) { + // 如果当前游标存在，检查数据项类型是否为笔记类型 + if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) { + // 如果是笔记类型，增加笔记数量 + mNotesCount++; + } + } else { + // 如果游标为null，打印错误日志并返回 + Log.e(TAG, "Invalid cursor"); + return; + } + } + } +} \ No newline at end of file -- 2.34.1 From 81edc80cdc3642cb92cd54288dd5e879c1e541aa Mon Sep 17 00:00:00 2001 From: gaoxiaorui <3502644298@qq.com> Date: Sat, 16 Nov 2024 21:25:06 +0800 Subject: [PATCH 08/10] =?UTF-8?q?=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- NoteItemData.java | 306 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 306 insertions(+) create mode 100644 NoteItemData.java diff --git a/NoteItemData.java b/NoteItemData.java new file mode 100644 index 0000000..1533e2f --- /dev/null +++ b/NoteItemData.java @@ -0,0 +1,306 @@ +/* + * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package net.micode.notes.ui; + +import android.content.Context; +import android.database.Cursor; +import android.text.TextUtils; + +import net.micode.notes.data.Contact; +import net.micode.notes.data.Notes; +import net.micode.notes.data.Notes.NoteColumns; +import net.micode.notes.tool.DataUtils; + + +// 这个类表示一个笔记项目的数据模型，用于存储与笔记项相关的信息 +public class NoteItemData { + + // 定义了一个查询投影（Projection），包括从数据库中获取笔记的相关字段 + static final String [] PROJECTION = new String [] { + NoteColumns.ID, // 笔记的唯一标识符 + NoteColumns.ALERTED_DATE, // 提醒日期 + NoteColumns.BG_COLOR_ID, // 背景颜色ID + NoteColumns.CREATED_DATE, // 创建日期 + NoteColumns.HAS_ATTACHMENT, // 是否包含附件 + NoteColumns.MODIFIED_DATE, // 修改日期 + NoteColumns.NOTES_COUNT, // 笔记数量 + NoteColumns.PARENT_ID, // 父项ID + NoteColumns.SNIPPET, // 笔记的摘要 + NoteColumns.TYPE, // 笔记的类型 + NoteColumns.WIDGET_ID, // 小部件ID + NoteColumns.WIDGET_TYPE, // 小部件类型 + }; + + // 定义常量，表示数据库查询结果的每一列索引位置 + 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; // 背景颜色列索引 + 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; // 笔记的ID + private long mAlertDate; // 提醒时间 + private int mBgColorId; // 背景颜色ID + private long mCreatedDate; // 创建时间 + private boolean mHasAttachment; // 是否有附件 + private long mModifiedDate; // 修改时间 + private int mNotesCount; // 笔记数量 + private long mParentId; // 父笔记ID + private String mSnippet; // 笔记摘要 + private int mType; // 笔记类型 + private int mWidgetId; // 小部件ID + private int mWidgetType; // 小部件类型 + private String mName; // 笔记项的名称 + private String mPhoneNumber; // 笔记项关联的电话号码 + + // 以下是用于标记笔记在显示列表中的状态的布尔值 + private boolean mIsLastItem; // 是否是最后一个笔记项 + private boolean mIsFirstItem; // 是否是第一个笔记项 + private boolean mIsOnlyOneItem; // 是否是唯一的一个笔记项 + private boolean mIsOneNoteFollowingFolder; // 是否是跟随文件夹的第一个笔记 + private boolean mIsMultiNotesFollowingFolder; // 是否是跟随文件夹的多个笔记 + + // 这里可以写上构造函数、getter和setter方法等，用于初始化和访问这些字段 + + // 构造函数，初始化 NoteItemData 对象，使用 Context 和 Cursor 作为输入参数 +public NoteItemData(Context context, Cursor cursor) { + // 从 Cursor 中获取 ID，存储到 mId + mId = cursor.getLong(ID_COLUMN); + + // 获取警告日期（ALERTED_DATE_COLUMN），并存储为 mAlertDate + mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN); + + // 获取背景颜色ID（BG_COLOR_ID_COLUMN），并存储为 mBgColorId + mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN); + + // 获取创建日期（CREATED_DATE_COLUMN），并存储为 mCreatedDate + mCreatedDate = cursor.getLong(CREATED_DATE_COLUMN); + + // 判断是否有附件（HAS_ATTACHMENT_COLUMN），存储为 mHasAttachment + mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0) ? true : false; + + // 获取修改日期（MODIFIED_DATE_COLUMN），并存储为 mModifiedDate + mModifiedDate = cursor.getLong(MODIFIED_DATE_COLUMN); + + // 获取笔记数量（NOTES_COUNT_COLUMN），并存储为 mNotesCount + mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN); + + // 获取父项 ID（PARENT_ID_COLUMN），并存储为 mParentId + mParentId = cursor.getLong(PARENT_ID_COLUMN); + + // 获取笔记的内容摘要（SNIPPET_COLUMN），并清除标记（如果存在） + mSnippet = cursor.getString(SNIPPET_COLUMN); + mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(NoteEditActivity.TAG_UNCHECKED, ""); + + // 获取笔记类型（TYPE_COLUMN），并存储为 mType + mType = cursor.getInt(TYPE_COLUMN); + + // 获取小部件 ID（WIDGET_ID_COLUMN），并存储为 mWidgetId + mWidgetId = cursor.getInt(WIDGET_ID_COLUMN); + + // 获取小部件类型（WIDGET_TYPE_COLUMN），并存储为 mWidgetType + mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN); + + // 默认初始化手机号为空字符串 + mPhoneNumber = ""; + + // 如果该笔记的父级 ID 是电话记录文件夹的 ID，获取电话记录的号码，并尝试获取联系人名称 + if (mParentId == Notes.ID_CALL_RECORD_FOLDER) { + // 获取与该笔记 ID 对应的电话记录号码 + mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId); + + // 如果手机号不为空，尝试获取联系人名称 + if (!TextUtils.isEmpty(mPhoneNumber)) { + mName = Contact.getContact(context, mPhoneNumber); + // 如果没有找到联系人，使用手机号作为名称 + if (mName == null) { + mName = mPhoneNumber; + } + } + } + + // 如果联系人名称为空，初始化为空字符串 + if (mName == null) { + mName = ""; + } + + // 调用 checkPostion 方法来判断该笔记在 Cursor 中的位置 + checkPostion(cursor); +} + +// 检查该笔记在 Cursor 中的位置 +private void checkPostion(Cursor cursor) { + // 判断是否是 Cursor 中的最后一项 + mIsLastItem = cursor.isLast() ? true : false; + + // 判断是否是 Cursor 中的第一项 + mIsFirstItem = cursor.isFirst() ? true : false; + + // 判断 Cursor 中是否只有一项 + mIsOnlyOneItem = (cursor.getCount() == 1); + + // 默认设置为 false，表示不是多个笔记跟随文件夹 + mIsMultiNotesFollowingFolder = false; + + // 默认设置为 false，表示不是一个笔记跟随文件夹 + mIsOneNoteFollowingFolder = false; + + // 如果当前笔记类型是普通笔记（TYPE_NOTE）并且不是第一项 + if (mType == Notes.TYPE_NOTE && !mIsFirstItem) { + int position = cursor.getPosition(); // 获取当前笔记在 Cursor 中的位置 + + // 尝试将 Cursor 移动到上一项 + 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; + } + } + // 如果无法移动到上一项，抛出异常 + if (!cursor.moveToNext()) { + throw new IllegalStateException("cursor move to previous but can't move back"); + } + } + } +} + + + // 判断是否是单个笔记文件夹 +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; // 返回是否是唯一一项的布尔值 +} + +// 获取笔记的ID +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; // 返回笔记的最后修改时间 +} + +// 获取笔记的背景颜色ID +public int getBgColorId() { + return mBgColorId; // 返回笔记的背景颜色ID +} + +// 获取父文件夹ID +public long getParentId() { + return mParentId; // 返回笔记的父文件夹ID +} + +// 获取笔记中的内容数量 +public int getNotesCount() { + return mNotesCount; // 返回笔记的内容数量 +} + +// 获取父文件夹的ID（重复调用了getParentId方法，功能与getParentId相同） +public long getFolderId () { + return mParentId; // 返回笔记的文件夹ID（等同于getParentId） +} + +// 获取笔记的类型 +public int getType() { + return mType; // 返回笔记的类型ID +} + +// 获取笔记的widget类型 +public int getWidgetType() { + return mWidgetType; // 返回笔记的widget类型ID +} + +// 获取笔记的widget ID +public int getWidgetId() { + return mWidgetId; // 返回笔记的widget ID +} + +// 获取笔记的摘要内容 +public String getSnippet() { + return mSnippet; // 返回笔记的摘要信息 +} + +// 判断笔记是否设置了提醒 +public boolean hasAlert() { + return (mAlertDate > 0); // 如果提醒日期大于0，说明有提醒 +} + +// 判断是否是通话记录 +public boolean isCallRecord() { + return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber)); + // 判断父文件夹ID是否为通话记录文件夹，且手机号码不为空 +} + +// 获取笔记类型，从数据库Cursor中提取笔记类型 +public static int getNoteType(Cursor cursor) { + return cursor.getInt(TYPE_COLUMN); // 从Cursor中获取笔记类型字段的值 +} +} -- 2.34.1 From bb3ff5478d7e129143a7b0e3a9c757d56d868398 Mon Sep 17 00:00:00 2001 From: gaoxiaorui <3502644298@qq.com> Date: Sat, 16 Nov 2024 21:38:39 +0800 Subject: [PATCH 09/10] =?UTF-8?q?=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- NotesListItem.java | 153 ++++++++++ NotesPreferenceActivity.java | 568 +++++++++++++++++++++++++++++++++++ 2 files changed, 721 insertions(+) create mode 100644 NotesListItem.java create mode 100644 NotesPreferenceActivity.java diff --git a/NotesListItem.java b/NotesListItem.java new file mode 100644 index 0000000..3c214eb --- /dev/null +++ b/NotesListItem.java @@ -0,0 +1,153 @@ +/* + * 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; + +// 引入Android库和自定义类、工具类 +import android.content.Context; // 用于访问应用的上下文 +import android.text.format.DateUtils; // 用于格式化日期时间 +import android.view.View; // 用于视图操作 +import android.widget.CheckBox; // 复选框控件 +import android.widget.ImageView; // 图像视图控件 +import android.widget.LinearLayout; // 线性布局控件 +import android.widget.TextView; // 文本视图控件 + +// 引入项目内的其他类 +import net.micode.notes.R; // 引用资源ID文件 +import net.micode.notes.data.Notes; // Notes类，表示笔记数据 +import net.micode.notes.tool.DataUtils; // 数据工具类，可能用于处理或转换数据 +import net.micode.notes.tool.ResourceParser.NoteItemBgResources; // 资源解析器，用于获取笔记项背景资源 + + +public class NotesListItem extends LinearLayout { + // 定义UI控件 + private ImageView mAlert; // 用于显示警告图标 + private TextView mTitle; // 用于显示标题 + private TextView mTime; // 用于显示时间 + private TextView mCallName; // 用于显示来电名称 + private NoteItemData mItemData; // 用于存储与该视图项相关的数据 + private CheckBox mCheckBox; // 用于显示复选框，支持选择模式 + + // 构造函数，初始化视图 + public NotesListItem(Context context) { + super(context); // 调用父类LinearLayout的构造函数 + inflate(context, R.layout.note_item, this); // 从布局文件加载视图 + mAlert = (ImageView) findViewById(R.id.iv_alert_icon); // 绑定警告图标 + mTitle = (TextView) findViewById(R.id.tv_title); // 绑定标题TextView + mTime = (TextView) findViewById(R.id.tv_time); // 绑定时间TextView + mCallName = (TextView) findViewById(R.id.tv_name); // 绑定来电名称TextView + mCheckBox = (CheckBox) findViewById(android.R.id.checkbox); // 绑定复选框 + } + + // 绑定数据到视图 + public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) { + // 如果处于选择模式且数据类型为笔记，则显示复选框并设置其选中状态 + if (choiceMode && data.getType() == Notes.TYPE_NOTE) { + mCheckBox.setVisibility(View.VISIBLE); // 显示复选框 + mCheckBox.setChecked(checked); // 设置复选框的选中状态 + } else { + mCheckBox.setVisibility(View.GONE); // 否则隐藏复选框 + } + + mItemData = data; // 存储绑定的数据 + // 如果数据ID为通话记录文件夹ID + if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) { + mCallName.setVisibility(View.GONE); // 隐藏来电名称TextView + 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); // 设置警告图标为通话记录图标 + } + // 如果数据的父ID是通话记录文件夹ID + else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) { + mCallName.setVisibility(View.VISIBLE); // 显示来电名称TextView + 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); // 隐藏来电名称TextView + 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) { + // 获取背景颜色的ID，根据 NoteItemData 对象的不同状态来设置不同的背景资源 + int id = data.getBgColorId(); + + // 判断数据类型，如果是普通笔记（TYPE_NOTE） + if (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()); + } +} + + + public NoteItemData getItemData() { + return mItemData; + } +} diff --git a/NotesPreferenceActivity.java b/NotesPreferenceActivity.java new file mode 100644 index 0000000..62da551 --- /dev/null +++ b/NotesPreferenceActivity.java @@ -0,0 +1,568 @@ +/* + * 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; + +// 导入用于操作 Android 应用中的 ActionBar（顶部导航栏）功能 +import android.app.ActionBar; + +// 导入用于显示和管理弹出对话框的类 +import android.app.AlertDialog; + +// 导入用于接收广播消息的类 +import android.content.BroadcastReceiver; + +// 导入用于在 ContentProvider 中存储和插入数据的类 +import android.content.ContentValues; + +// 导入 Android 应用的上下文类，用于访问全局应用信息和资源 +import android.content.Context; + +// 导入用于显示和管理对话框按钮点击事件的接口 +import android.content.DialogInterface; + +// 导入用于启动新活动或广播的 Intent 类 +import android.content.Intent; + +// 导入用于过滤广播消息的 IntentFilter 类 +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; + +// 导入常用的 UI 控件类，如按钮、文本视图和弹出提示框 +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; + +// 导入与 Google 任务同步服务相关的类，用于同步任务数据 +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"; + + // 存储账户相关设置的类别 + private PreferenceCategory mAccountCategory; + + // 用于接收同步服务广播的接收器 + private GTaskReceiver mReceiver; + + // 存储原始账户列表 + private Account[] mOriAccounts; + + // 标记是否添加了新账户 + private boolean mHasAddedAccount; + + @Override + protected void onCreate(Bundle icicle) { + super.onCreate(icicle); + + // 使用应用图标作为导航栏的“向上”按钮 + getActionBar().setDisplayHomeAsUpEnabled(true); + + // 加载偏好设置界面资源 + addPreferencesFromResource(R.xml.preferences); + + // 获取账户设置类别对象 + mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY); + + // 初始化 GTaskReceiver 接收器，用于接收同步相关广播 + mReceiver = new GTaskReceiver(); + + // 创建 IntentFilter，注册 GTaskSyncService 广播 + 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); + } + + @Override + protected void onResume() { + super.onResume(); + + // 如果添加了新账户，则尝试自动设置同步账户 + if (mHasAddedAccount) { + // 获取当前所有的 Google 账户 + 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; + } + } + } + } + refreshUI(); + } + +@Override +protected void onDestroy() { + // 如果 mReceiver 已初始化，则注销广播接收器，防止内存泄漏 + if (mReceiver != null) { + unregisterReceiver(mReceiver); + } + // 调用父类的 onDestroy，确保正确销毁 Activity + super.onDestroy(); +} + + + private void loadAccountPreference() { + // 清空当前账户类别中的所有项 + mAccountCategory.removeAll(); + + // 创建一个新的 Preference 用于账户设置 + 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(); +} + + + 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) { + // 选择账户后，设置同步账户，并刷新 UI + 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(); // 关闭当前对话框 + } + }); +} + + + 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 实例，用于构建弹出的确认对话框 + 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) { // 如果用户选择了 "删除账户" + removeSyncAccount(); // 删除当前同步的账户 + refreshUI(); // 刷新 UI，更新界面 + } + } + }); + + // 显示对话框 + dialogBuilder.show(); +} + + + // 获取所有Google账户 +private Account[] getGoogleAccounts() { + // 获取 AccountManager 实例，这个对象用来管理设备上的账户 + AccountManager accountManager = AccountManager.get(this); + + // 返回所有Google账户，"com.google" 表示Google账户类型 + return accountManager.getAccountsByType("com.google"); +} + +// 设置同步账户 +private void setSyncAccount(String account) { + // 如果新设置的账户与当前同步账户不同 + if (!getSyncAccountName(this).equals(account)) { + // 获取 SharedPreferences，用于保存同步账户的配置信息 + 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(); + + // 清除上次同步时间（将其设置为0） + setLastSyncTime(this, 0); + + // 清除与Google任务相关的本地信息 + new Thread(new Runnable() { + public void run() { + // 创建一个 ContentValues 对象来更新 Google 任务相关的字段 + ContentValues values = new ContentValues(); + values.put(NoteColumns.GTASK_ID, ""); // 清除任务ID + values.put(NoteColumns.SYNC_ID, 0); // 清除同步ID + + // 更新 Notes 内容提供者中的数据，清除与同步相关的信息 + 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(); + } +} + +// 删除同步账户 +private void removeSyncAccount() { + // 获取 SharedPreferences，删除同步账户设置 + 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(); + + // 清除与Google任务相关的本地信息 + new Thread(new Runnable() { + public void run() { + // 创建一个 ContentValues 对象来更新 Google 任务相关的字段 + ContentValues values = new ContentValues(); + values.put(NoteColumns.GTASK_ID, ""); // 清除任务ID + values.put(NoteColumns.SYNC_ID, 0); // 清除同步ID + + // 更新 Notes 内容提供者中的数据，清除与同步相关的信息 + getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null); + } + }).start(); +} + + + // 获取同步账户名称 +public static String getSyncAccountName(Context context) { + // 获取 SharedPreferences 实例，存储同步账户名称 + SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE); + // 返回同步账户名称，如果没有保存该名称，返回空字符串 + return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, ""); +} + +// 设置上次同步时间 +public static void setLastSyncTime(Context context, long time) { + // 获取 SharedPreferences 实例，存储同步信息 + SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE); + // 获取 SharedPreferences 的编辑器，用于修改存储的数据 + SharedPreferences.Editor editor = settings.edit(); + // 将时间值存储到 PREFERENCE_LAST_SYNC_TIME 键中 + editor.putLong(PREFERENCE_LAST_SYNC_TIME, time); + // 提交更改 + editor.commit(); +} + +// 获取上次同步时间 +public static long getLastSyncTime(Context context) { + // 获取 SharedPreferences 实例，读取同步信息 + SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE); + // 获取上次同步时间，如果没有保存则返回 0（表示没有同步） + return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0); +} + +// 广播接收器，用于接收来自 GTaskSyncService 的广播消息 +private class GTaskReceiver extends BroadcastReceiver { + + @Override + public void onReceive(Context context, Intent intent) { + // 刷新UI显示 + refreshUI(); + + // 检查是否正在同步 + if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) { + // 获取同步状态显示的 TextView + TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview); + // 更新同步状态信息（进度消息） + syncStatus.setText(intent.getStringExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_PROGRESS_MSG)); + } + } +} + +// 处理菜单项点击事件 +public boolean onOptionsItemSelected(MenuItem item) { + // 根据点击的菜单项进行相应的处理 + switch (item.getItemId()) { + // 点击返回按钮，返回到 NotesListActivity + case android.R.id.home: + // 创建返回 Intent，设置标志位清除栈顶活动 + Intent intent = new Intent(this, NotesListActivity.class); + intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); + // 启动 NotesListActivity + startActivity(intent); + return true; + default: + // 如果没有匹配的菜单项，返回 false + return false; + } + } +} \ No newline at end of file -- 2.34.1 From 5dac4c025269f165e208d9a6783e5265b117efd2 Mon Sep 17 00:00:00 2001 From: gaoxiaorui <3502644298@qq.com> Date: Sun, 22 Dec 2024 11:55:22 +0800 Subject: [PATCH 10/10] =?UTF-8?q?=E6=96=87=E6=A1=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- 小米便签开源代码的泛读报告.docx | Bin 0 -> 282613 bytes ...代码的质量分析报告 - 副本.docx | Bin 0 -> 16750 bytes 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 小米便签开源代码的泛读报告.docx create mode 100644 小米便签开源代码的质量分析报告 - 副本.docx diff --git a/小米便签开源代码的泛读报告.docx b/小米便签开源代码的泛读报告.docx new file mode 100644 index 0000000000000000000000000000000000000000..ab5ab0a45d9a368e6fc07491dbbb89530ba29201 GIT binary patch literal 282613 zcmZ^J1CS`qlJ3~HZ5wB7+qP}nwr%5#ZQHhO&zYHb{=2*H?cLbd5gpx;k=2!z`E^z1 zS0yh63<3r4&lM(n!2i$lzb?qXFUEF8@{V@)PW1AB)lmKlApWH`@wgVF3;ed;ihD5ka2!DDppyfk4RwTBXy)&vcvLKny^3tU$#|x6rsuvGH=+A;Nj~p zTLk4KnFHe&T(N9%nUMvn{~k@U7Roo#|5J{KUxwX4E7isrGs6;QGtn}!=~^I?Q2z7wEM(PtfA>3kUUV)cjm zCAGF>Gc6Q)HY0{v&QouN8q)2v_Rr-1T_Cf z0P(*^z{t+gp>CKek-Q!pM z*2+Yd6!eKdpIA(w^efJSi7UbtTbnO|id^VjceAOHZ!|K@iWCucjG ze>^{&q$BmnfHHcEf5#QPWhS%Wq9v-Op$FoDr(iF8Cn}j`nJ*)mC^H(QHx9o~&g@iG zeilOy(GGcn?WHj>g^JzTlu^$OjvdbJz)HSVRT=S59;ihsCG2^aB?}hYV8)KU$3y&vI9Nm!l^&SB=PEjk$+3<1->&#{%cbVwn@7Cq1)Z zo!?Is$u~7pNh^trn^ARaoNz^oLbFdB_^G6tzu`bGzboW!DB~65H|j_(TGcBJCXpZ_ zr0-T@zL^7XT`K7ht(+*&=xlPj8@qqvvMlX#78> zHvX`>dM{`I082Xn0Qmn>adP&sHgWnVxZOIFuA3dGIc_!Iz-gk_eemnCxLzXd)b~ZQ zR-HE~i(H}NV+XJjXNk$Er|7?~{GQ-H*suMb_WX+}B7#GNa%GXC;<^JK*8l_n{@g9T zay;l7XNFK=!iIi^0n3r~Kn)yuu)KXZH@^DrnY4=oAyx>-g4Ho$|9QH9?ftCp8hcn3 zH^l=WSr@sA18d~Y)5F0r{+1pg+EjDO=o_z)G)fqpeR?NAJ8vEKo>jZoKH4XV9{BUT zcXoH@EZgdk&29bbC@gpfaOfai8-%iL!kG@Cu3I>V9f*5VeIxfK5Z82&2QR6Y+_@^)M0z2AGP1gG?mB zp(f(si--?B{EZ1mU+iK^B@e>K3zNrgVD1S39K5oOh-Wux(jHd>0alqmg^O$IS242A zPIZguYp1p#XC#;HzJ?D=OIe|_Q7Cv9S)O}27{(7o#O_p2!UzC> zj#Nq*=m}p=OH5%2q)^D`q*3kzh?h?HQ{Z$-04`DU9HgLeEUFn~Xz$W|R$(~nXwVpx zmwdmRNV&7ZT@=GR8H~&$St?&W5JeK9{{&FR)gQt5s12E%brIc2{0M}#!ECDyu_pB2 zhs%eZHn=Ky(iNfKX}7RP44QrdB0IU@YQVhtL&e68@p`u^T}7DAOL~p613mf5`_=awhm4{#}U&^RnVJPm0rQv>60^w5=zqZoY%un6}hAc<{HVXLMNvp)mkQ&dg;!Ktdag~ zS6^kQ80|)X@>Rqq%CH|q8CmiOPo%8+Q&+QUBN@De?kVMS^Kh})zDj(BvWjVhZ z)t%+VuVrJ?uC3l+c$!(gLuF(8d!s?5YmGBv>Sg;(3mU+#$PC>tXr+sZQe@E)^^$c{ zVZ3!IFyFTF3q`Vxt3?HYWU&bWJ0m!VQLXwIc#RbI`fDB3zu4yZ#;i8c7rmM&FS&V0>aieOuIutLvHQJuSYsi zn)G{Nl9c9NE<=@2ad>q`6ttRppzVbB{RNc;3O&~*45;9`(V9(y=!&UG-cMrMzbg#(q@X4 zSxqxCXU}+x7?`wQMd>jj_COBlj&2RR*G?Iim5*9sjz}-{{LIB}f_bZHK6M1`0u>|e zMo_Ib8);=*z1h4>^o+HkGU9WA=Zp+!^Q3{(qN|dC$!|{c&WikowXVe#W%+gr8PJr; z_KJKY&M5YjF^#SY;h6&&Qb#m9qJ%7WB?;?F`SYz%ccpgg4S9#<;Venxq_D_xx*g%d z?J$W6*SI(C)B|3em^cX6!76*}Dp%hjIjR1O5}cK=Sdd4% zM_eufsMhu+>{nFx<^2GCTW5EVT-|E0l`e>PT7FNFH=`XO`a!L0F?}5knR!3hA1otG zFw2Tl>@q5kU7glkk2Q{@{%6n0_v2yVy4B&Dr~R<>fq_-SM&E8q zV(VkSz&eBHxIFX^YOu`dy8*I7dnuAKd7CbZOc2|KK%xOa_bXv{`@(nE#&4Wdtn3cf=BRQfm(pv#z1 zUY&UK2xtW_>Vad-WY&onb(oL$N{5@0;IDYcA!G20OCKw0z4p*xX_asGRT1V zf^Svd_JC*=_MKAJOStzlZ&qL_AV0BSrQxgr1tdxRqEBCM7i#w6s#a9-C!$@eP`p<=UC3 zTNz}^)n*2rJa!yga2Pes{OK%lXK+EEUFufHGkP>6CFAv-G_U4cYFwA#+>}IV1S;B5 zSw~53_OYthd;zN}_hRq1P$UL#UhnB<&97Y&4cTEYU>~Fvl4a75AV^GxKc8`Ts=JE?||=JVsDLLaVl!eje&Gv`;gB3$qIQ8&3WilK#FqS=HNtOEFj} z%p8vw%#d6#>1l1LiX52ZNg9$aFoFu9HJ6~VeXflc#{aMt6mT7S$b`0)8}?@FoFIm! zdDN|T{qIsIl#->^2_Zm-rCP&MJd;&~ff1Dv3AP`=Dn=cbwQM^!$HMD zZ|2MDX*)#yd27sNd>^}-c@}R<<4>;ZY`TmM?I=UT`3O76fcuNNgzDEliPf=4K;b;a zEJ+RT4T`xUG|g;*_7S^!RvZ8mc4e$Z>j&Wl0}C5^&_wh7In zhO#m3d590e^NL`Yq*x$fZwC2qGT@zSujwrK{C8pssi78Pl>TDvREdl%+4#lsHoO|U z-|w>HM870ng^?{YVuPuTR|yhTf%E!m>w{RxINUdZ)I$(`R_Ml>gn)Oli9G{SXBse4 zf+&@y$B@})Epme*jx%)5Y)>WV@mTi14byx58p&}xiOJ8darx@&^y+xFuv^+;>vzFJ zZPFRsdx(%4vFA8gZwd@JBR!{QOOn85{Zbp4?;?hNLGH)(9KcvdJ8jT@_e0BcG`@vY zxh{}o)TvfgO%5Mhjc2KN=+v^e-Y1XIQnQn8$xK$Rgz>dc7~hqdss~P4kdL?2CD}7U z0ue_bVAI5q+&z<4fn8cnYueG=MC`2TQ06@Qjv1ur@r z8zR294LpqpXZ7rmQHSJw3olij+!npGGJx?Zqv1oe^f&Yn8}%}b`P^rDvd1;Fr|r*-{|S{xr?DIj zQG$?Kii|?+6ki(--+zMf{QD}sb{wul3bWf1I5Hl-)9 zkL3NSU%72Qpcyg&oGu1$Op6{E2;hz6xA{i@y2jLcgSl$oN7ukX7?+|ny_FT0h!#e~ ziyB9f{dL3aT^;C}x+Vzy#@)m5bOkEQadmN}{@ad2RAX>kz#myW@dh)K)psjw9&tVJ zH@-N%;SgfVx5d^U=>PGf&q-f>{$*U8!2ke|{;ME2wX<`!wR8TDn!GuA(suJ7stfc3 z9_ST~bQBV*-w};b(O8Y;8hj4L1QC%FL?YvP*X^kZ8&eeTOqAYnW{YcS>f<}EvM8ut zHgHA)i<|^0Q;6`Hm%P`Hhps1K%%c=qH3*H96H4rcU9Y!VNEOH(R<{iTbHk+nE?apg zD_U`sx*$C&

QYnfD~0BDv%!5Ud_lhsrvOdxS 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

W;=G=o9)L{sKYq}Fl}+IfbG7e_s2`)d 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

K8HvN>JtL|s|zPe?J0h4vl%zIy61>afUD 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%0AR) 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 P;Ex4pD^vy`8tA_OJ6}m- literal 0 HcmV?d00001 diff --git a/小米便签开源代码的质量分析报告 - 副本.docx b/小米便签开源代码的质量分析报告 - 副本.docx new file mode 100644 index 0000000000000000000000000000000000000000..2c21d29c45125ee5f885e3244666cf6053a48c16 GIT binary patch literal 16750 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 IFTX$iKl_b8h5!Hn literal 0 HcmV?d00001 -- 2.34.1