From 00ebbafcd531ecf9894b2c0ec2ea635bd4499729 Mon Sep 17 00:00:00 2001 From: yhz <2678576348@qq.com> Date: Tue, 22 Oct 2024 23:36:31 +0800 Subject: [PATCH 1/4] 111 --- ...ework 源码的项目泛读阅读报告.docx | Bin 0 -> 24062 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 doc/华为 Framework 源码的项目泛读阅读报告.docx diff --git a/doc/华为 Framework 源码的项目泛读阅读报告.docx b/doc/华为 Framework 源码的项目泛读阅读报告.docx new file mode 100644 index 0000000000000000000000000000000000000000..d1c482294b22bda7f634b6ed1ef2d251d9c13658 GIT binary patch literal 24062 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 Gr~d(xx$#;6 literal 0 HcmV?d00001 From 2f33d8e0b5c610710a515abe1e4b733161173a07 Mon Sep 17 00:00:00 2001 From: yhz <2678576348@qq.com> Date: Mon, 16 Dec 2024 22:49:11 +0800 Subject: [PATCH 2/4] yhz --- .../Mate10_8_1_0/AlarmAlertActivity.java | 196 +++ .../Mate10_8_1_0/AlarmInitReceiver.java | 71 + .../Mate10_8_1_0/AlarmReceiver.java | 30 + .../Mate10_8_1_0/DateTimePicker.java | 583 ++++++++ .../Mate10_8_1_0/DateTimePickerDialog.java | 121 ++ .../Mate10_8_1_0/DropdownMenu.java | 73 + .../Mate10_8_1_0/FoldersListAdapter.java | 110 ++ .../Mate10_8_1_0/NoteEditActivity.java | 1141 ++++++++++++++ .../Mate10_8_1_0/NoteEditText.java | 267 ++++ .../Mate10_8_1_0/NoteItemData.java | 257 ++++ .../Mate10_8_1_0/NotesListActivity.java | 1305 +++++++++++++++++ .../Mate10_8_1_0/NotesListAdapter.java | 269 ++++ .../Mate10_8_1_0/NotesListItem.java | 157 ++ .../Mate10_8_1_0/NotesPreferenceActivity.java | 481 ++++++ 14 files changed, 5061 insertions(+) create mode 100644 src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/AlarmAlertActivity.java create mode 100644 src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/AlarmInitReceiver.java create mode 100644 src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/AlarmReceiver.java create mode 100644 src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/DateTimePicker.java create mode 100644 src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/DateTimePickerDialog.java create mode 100644 src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/DropdownMenu.java create mode 100644 src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/FoldersListAdapter.java create mode 100644 src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NoteEditActivity.java create mode 100644 src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NoteEditText.java create mode 100644 src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NoteItemData.java create mode 100644 src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NotesListActivity.java create mode 100644 src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NotesListAdapter.java create mode 100644 src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NotesListItem.java create mode 100644 src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NotesPreferenceActivity.java diff --git a/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/AlarmAlertActivity.java b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/AlarmAlertActivity.java new file mode 100644 index 0000000..3c77e81 --- /dev/null +++ b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/AlarmAlertActivity.java @@ -0,0 +1,196 @@ +/* + * 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.DialogInterface.OnClickListener; +import android.content.DialogInterface.OnDismissListener; +import android.content.Intent; +import android.media.AudioManager; +import android.media.MediaPlayer; +import android.media.RingtoneManager; +import android.net.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; + + +/* + * AlarmAlertActivity 类用于处理提醒通知的界面和声音播放。 + * 当一个笔记的提醒时间到达时，这个活动会被启动，显示提醒信息并播放提醒声音。 + */ +public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener { + // 笔记的ID + private long mNoteId; + // 笔记内容的简短预览 + private String mSnippet; + // 预览文本的最大长度 + private static final int SNIPPET_PREW_MAX_LEN = 60; + // 用于播放提醒声音的MediaPlayer对象 + MediaPlayer mPlayer; + + /* + * onCreate 方法初始化活动，设置窗口特性，根据传入的Intent获取笔记ID和简短内容， + * 并根据情况显示对话框和播放声音。 + */ + @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中获取笔记ID和简短内容 + Intent intent = getIntent(); + try { + mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1)); + 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(); + } + } + + /* + * 检查屏幕是否处于打开状态。 + * + * @return 如果屏幕已打开则返回true，否则返回false。 + */ + private boolean isScreenOn() { + PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE); + return pm.isScreenOn(); + } + + /* + * 播放提醒声音。 + * 根据系统设置选择合适的音频流类型，并尝试播放选定的报警声音。 + */ + private void playAlarmSound() { + 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 { + 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); + startActivity(intent); + break; + default: + // 关闭活动 + break; + } + } + + /* + * 对话框关闭时的处理。 + * 停止播放提醒声音，结束当前活动。 + */ + public void onDismiss(DialogInterface dialog) { + stopAlarmSound(); + finish(); + } + + /* + * 停止播放提醒声音。 + * 如果MediaPlayer对象不为空，则停止播放并释放资源。 + */ + private void stopAlarmSound() { + if (mPlayer != null) { + mPlayer.stop(); + mPlayer.release(); + mPlayer = null; + } + } +} diff --git a/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/AlarmInitReceiver.java b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/AlarmInitReceiver.java new file mode 100644 index 0000000..8da4ef8 --- /dev/null +++ b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/AlarmInitReceiver.java @@ -0,0 +1,71 @@ +/* + * 该类是广播接收器，用于在应用启动时初始化提醒设置。 + * 当系统启动时，它会检查数据库中所有设置了提醒的笔记，并为每个笔记设置相应的提醒。 + */ +package net.micode.notes.ui; + +import android.app.AlarmManager; +import android.app.PendingIntent; +import android.content.BroadcastReceiver; +import android.content.ContentUris; +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, + NoteColumns.ALERTED_DATE + }; + + // 列的索引 + private static final int COLUMN_ID = 0; + private static final int COLUMN_ALERTED_DATE = 1; + + /** + * 当接收到广播时执行的操作。主要用于设置所有已记录的提醒时间。 + * + * @param context 上下文，提供访问应用全局功能的入口。 + * @param intent 携带了触发该接收器的广播信息。 + */ + @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，用于在提醒时间触发AlarmReceiver + Intent sender = new Intent(context, AlarmReceiver.class); + sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(COLUMN_ID))); + // 创建PendingIntent，它是一个延迟的意图，可以在特定时间由系统触发 + PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, 0); + // 获取AlarmManager服务，用于设置提醒 + AlarmManager alermManager = (AlarmManager) context + .getSystemService(Context.ALARM_SERVICE); + // 设置提醒 + alermManager.set(AlarmManager.RTC_WAKEUP, alertDate, pendingIntent); + } while (c.moveToNext()); + } + // 关闭Cursor，释放资源 + c.close(); + } + } +} + diff --git a/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/AlarmReceiver.java b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/AlarmReceiver.java new file mode 100644 index 0000000..42d7313 --- /dev/null +++ b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/AlarmReceiver.java @@ -0,0 +1,30 @@ +/* + * AlarmReceiver类 - 用于处理闹钟广播接收 + * 当接收到闹钟相关的广播时，该类会启动一个指定的Activity + * + * extends BroadcastReceiver: 继承自Android的BroadcastReceiver类 + */ +package net.micode.notes.ui; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; + +public class AlarmReceiver extends BroadcastReceiver { + /* + * onReceive方法 - 系统调用的接收广播的方法 + * 当接收到广播时，该方法会被调用，然后启动AlarmAlertActivity + * + * @param context 上下文对象，提供了调用环境的信息 + * @param intent 包含广播的内容 + */ + @Override + public void onReceive(Context context, Intent intent) { + // 设置Intent的类，以便启动AlarmAlertActivity + intent.setClass(context, AlarmAlertActivity.class); + // 添加标志，表示在一个新的任务中启动Activity + intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + // 根据设置的Intent启动Activity + context.startActivity(intent); + } +} diff --git a/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/DateTimePicker.java b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/DateTimePicker.java new file mode 100644 index 0000000..aea9538 --- /dev/null +++ b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/DateTimePicker.java @@ -0,0 +1,583 @@ +/* + * 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 { + + // 默认启用状态 + private static final boolean DEFAULT_ENABLE_STATE = true; + + // 半天的小时数 + private static final int HOURS_IN_HALF_DAY = 12; + // 一整天的小时数 + private static final int HOURS_IN_ALL_DAY = 24; + // 一周的天数 + private static final int DAYS_IN_ALL_WEEK = 7; + // 日期选择器的最小值 + private static final int DATE_SPINNER_MIN_VAL = 0; + // 日期选择器的最大值 + private static final int DATE_SPINNER_MAX_VAL = DAYS_IN_ALL_WEEK - 1; + // 24小时制小时选择器的最小值 + private static final int HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW = 0; + // 24小时制小时选择器的最大值 + private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23; + // 12小时制小时选择器的最小值 + private static final int HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW = 1; + // 12小时制小时选择器的最大值 + private static final int HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW = 12; + // 分钟选择器的最小值 + private static final int MINUT_SPINNER_MIN_VAL = 0; + // 分钟选择器的最大值 + private static final int MINUT_SPINNER_MAX_VAL = 59; + // 上下午选择器的最小值 + private static final int AMPM_SPINNER_MIN_VAL = 0; + // 上下午选择器的最大值 + private static final int AMPM_SPINNER_MAX_VAL = 1; + + // 日期选择器 + private final NumberPicker mDateSpinner; + // 小时选择器 + private final NumberPicker mHourSpinner; + // 分钟选择器 + private final NumberPicker mMinuteSpinner; + // 上下午选择器 + private final NumberPicker mAmPmSpinner; + // 当前日期 + private Calendar mDate; + + // 用于显示日期的字符串数组 + private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK]; + + // 当前是否为上午 + private boolean mIsAm; + + // 当前是否为24小时制视图 + private boolean mIs24HourView; + + // 控件是否启用 + private boolean mIsEnabled = DEFAULT_ENABLE_STATE; + + // 是否正在初始化 + private boolean mInitialising; + + // 日期时间改变监听器 + private OnDateTimeChangedListener mOnDateTimeChangedListener; + + // 日期选择器的值改变监听器 + private NumberPicker.OnValueChangeListener mOnDateChangedListener = new NumberPicker.OnValueChangeListener() { + @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(); + if (!mIs24HourView) { + // 处理12小时制下的日期变化和上下午切换 + if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) { + cal.setTimeInMillis(mDate.getTimeInMillis()); + cal.add(Calendar.DAY_OF_YEAR, 1); + isDateChanged = true; + } else if (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) { + cal.setTimeInMillis(mDate.getTimeInMillis()); + cal.add(Calendar.DAY_OF_YEAR, -1); + isDateChanged = true; + } + if (oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY || + oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) { + mIsAm = !mIsAm; + updateAmPmControl(); + } + } else { + // 处理24小时制下的日期变化 + if (oldVal == HOURS_IN_ALL_DAY - 1 && newVal == 0) { + cal.setTimeInMillis(mDate.getTimeInMillis()); + cal.add(Calendar.DAY_OF_YEAR, 1); + isDateChanged = true; + } else if (oldVal == 0 && newVal == HOURS_IN_ALL_DAY - 1) { + cal.setTimeInMillis(mDate.getTimeInMillis()); + cal.add(Calendar.DAY_OF_YEAR, -1); + isDateChanged = true; + } + } + // 更新小时并触发日期时间改变事件 + int newHour = mHourSpinner.getValue() % HOURS_IN_HALF_DAY + (mIsAm ? 0 : HOURS_IN_HALF_DAY); + mDate.set(Calendar.HOUR_OF_DAY, newHour); + onDateTimeChanged(); + // 如果日期有变化，则更新年月日 + if (isDateChanged) { + setCurrentYear(cal.get(Calendar.YEAR)); + setCurrentMonth(cal.get(Calendar.MONTH)); + setCurrentDay(cal.get(Calendar.DAY_OF_MONTH)); + } + } + }; + + + // 分别为分钟和AM/PM选择器监听器设置匿名内部类，实现数值变化时的处理逻辑。 + private NumberPicker.OnValueChangeListener mOnMinuteChangedListener = new NumberPicker.OnValueChangeListener() { + @Override + public void onValueChange(NumberPicker picker, int oldVal, int newVal) { + // 计算小时的偏移量，当从最大值变为最小值或从最小值变为最大值时调整 + int minValue = mMinuteSpinner.getMinValue(); + int maxValue = mMinuteSpinner.getMaxValue(); + int offset = 0; + if (oldVal == maxValue && newVal == minValue) { + offset += 1; + } else if (oldVal == minValue && newVal == maxValue) { + offset -= 1; + } + // 根据偏移量更新日期和小时选择器，并检查是否需要切换AM/PM + if (offset != 0) { + mDate.add(Calendar.HOUR_OF_DAY, offset); + mHourSpinner.setValue(getCurrentHour()); + updateDateControl(); + int newHour = getCurrentHourOfDay(); + if (newHour >= HOURS_IN_HALF_DAY) { + mIsAm = false; + updateAmPmControl(); + } else { + mIsAm = true; + updateAmPmControl(); + } + } + // 更新分钟值并触发日期变化的回调 + mDate.set(Calendar.MINUTE, newVal); + onDateTimeChanged(); + } + }; + + private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() { + @Override + public void onValueChange(NumberPicker picker, int oldVal, int newVal) { + // 切换AM/PM状态，并更新日期和AM/PM选择器 + mIsAm = !mIsAm; + if (mIsAm) { + mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY); + } else { + mDate.add(Calendar.HOUR_OF_DAY, HOURS_IN_HALF_DAY); + } + updateAmPmControl(); + onDateTimeChanged(); + } + }; + + // 定义日期时间变化的回调接口 + public interface OnDateTimeChangedListener { + void onDateTimeChanged(DateTimePicker view, int year, int month, + int dayOfMonth, int hourOfDay, int minute); + } + + // 构造函数：初始化日期时间选择器 + public DateTimePicker(Context context) { + this(context, System.currentTimeMillis()); + } + + // 构造函数：指定初始日期时间 + public DateTimePicker(Context context, long date) { + this(context, date, DateFormat.is24HourFormat(context)); + } + + // 构造函数：指定是否使用24小时制视图 + public DateTimePicker(Context context, long date, boolean is24HourView) { + super(context); + mDate = Calendar.getInstance(); + mInitialising = true; + mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY; + inflate(context, R.layout.datetime_picker, this); + + // 初始化日期、小时、分钟和AM/PM选择器，并设置相应的监听器 + mDateSpinner = (NumberPicker) findViewById(R.id.date); + mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL); + mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL); + mDateSpinner.setOnValueChangedListener(mOnDateChangedListener); + + mHourSpinner = (NumberPicker) findViewById(R.id.hour); + mHourSpinner.setOnValueChangedListener(mOnHourChangedListener); + mMinuteSpinner = (NumberPicker) findViewById(R.id.minute); + mMinuteSpinner.setMinValue(MINUT_SPINNER_MIN_VAL); + mMinuteSpinner.setMaxValue(MINUT_SPINNER_MAX_VAL); + mMinuteSpinner.setOnLongPressUpdateInterval(100); + mMinuteSpinner.setOnValueChangedListener(mOnMinuteChangedListener); + + String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings(); + mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm); + mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL); + mAmPmSpinner.setMaxValue(AMPM_SPINNER_MAX_VAL); + mAmPmSpinner.setDisplayedValues(stringsForAmPm); + mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener); + + // 更新控件至初始状态 + updateDateControl(); + updateHourControl(); + updateAmPmControl(); + + set24HourView(is24HourView); + + // 设置为当前时间 + setCurrentDate(date); + + setEnabled(isEnabled()); + + // 设置内容描述 + mInitialising = false; + } + + + /** + * 设置控件的启用状态。 + * 如果当前状态与传入状态相同，则不进行任何操作。 + * 启用或禁用日期和时间选择器，并更新内部启用状态。 + * + * @param enabled 控件是否启用 + */ + @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); + mIsEnabled = enabled; + } + + /** + * 获取控件的启用状态。 + * + * @return 控件是否启用 + */ + @Override + public boolean isEnabled() { + return mIsEnabled; + } + + /** + * 获取当前日期的时间戳（毫秒）。 + * + * @return 当前日期的毫秒时间戳 + */ + public long getCurrentDateInTimeMillis() { + return mDate.getTimeInMillis(); + } + + /** + * 设置当前日期。 + * 根据传入的毫秒时间戳更新日期选择器的值。 + * + * @param date The current date in millis + */ + public void setCurrentDate(long date) { + Calendar cal = Calendar.getInstance(); + cal.setTimeInMillis(date); + // 通过日历实例的详细字段设置当前日期和时间 + setCurrentDate(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH), + cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE)); + } + + /** + * 设置当前日期和时间。 + * 分别设置年、月、日、时和分。 + * + * @param year 当前年份 + * @param month 当前月份 + * @param dayOfMonth 当前日 + * @param hourOfDay 当前小时 + * @param minute 当前分钟 + */ + public void setCurrentDate(int year, int month, + int dayOfMonth, int hourOfDay, int minute) { + // 分别设置年、月、日、时和分 + setCurrentYear(year); + setCurrentMonth(month); + setCurrentDay(dayOfMonth); + setCurrentHour(hourOfDay); + setCurrentMinute(minute); + } + + + /** + * 获取当前年份 + * + * @return 当前的年份 + */ + public int getCurrentYear() { + return mDate.get(Calendar.YEAR); + } + + /** + * 设置当前年份 + * + * @param year 当前的年份 + */ + public void setCurrentYear(int year) { + // 如果不是初始化状态并且设置的年份与当前年份相同，则直接返回 + if (!mInitialising && year == getCurrentYear()) { + return; + } + mDate.set(Calendar.YEAR, year); + updateDateControl(); // 更新日期控件 + onDateTimeChanged(); // 触发日期时间改变事件 + } + + /** + * 获取当前月份 + * + * @return 当前的月份（从0开始） + */ + public int getCurrentMonth() { + return mDate.get(Calendar.MONTH); + } + + /** + * 设置当前月份 + * + * @param month 当前的月份（从0开始） + */ + public void setCurrentMonth(int month) { + // 如果不是初始化状态并且设置的月份与当前月份相同，则直接返回 + if (!mInitialising && month == getCurrentMonth()) { + return; + } + mDate.set(Calendar.MONTH, month); + updateDateControl(); // 更新日期控件 + onDateTimeChanged(); // 触发日期时间改变事件 + } + + /** + * 获取当前日期（月中的天数） + * + * @return 当前的日期（月中的天数） + */ + public int getCurrentDay() { + return mDate.get(Calendar.DAY_OF_MONTH); + } + + /** + * 设置当前日期（月中的天数） + * + * @param dayOfMonth 当前的日期（月中的天数） + */ + public void setCurrentDay(int dayOfMonth) { + // 如果不是初始化状态并且设置的日期与当前日期相同，则直接返回 + if (!mInitialising && dayOfMonth == getCurrentDay()) { + return; + } + mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth); + updateDateControl(); // 更新日期控件 + onDateTimeChanged(); // 触发日期时间改变事件 + } + + /** + * 获取当前小时（24小时制），范围为(0~23) + * + * @return 当前的小时（24小时制） + */ + public int getCurrentHourOfDay() { + return mDate.get(Calendar.HOUR_OF_DAY); + } + + /** + * 获取当前小时，根据是否为24小时制返回不同的值。 + * 如果是24小时制，与{@link #getCurrentHourOfDay()}返回相同结果； + * 否则，将小时转换为12小时制，并考虑上午/下午。 + * + * @return 当前的小时（根据视图模式可能是12小时制） + */ + private int getCurrentHour() { + if (mIs24HourView) { + return getCurrentHourOfDay(); + } else { + int hour = getCurrentHourOfDay(); + // 转换为12小时制 + if (hour > HOURS_IN_HALF_DAY) { + return hour - HOURS_IN_HALF_DAY; + } else { + return hour == 0 ? HOURS_IN_HALF_DAY : hour; + } + } + } + + + /** + * 设置当前小时（24小时制），范围为(0~23) + * + * @param hourOfDay 当前小时数 + */ + public void setCurrentHour(int hourOfDay) { + // 如果在初始化中或者小时未改变，则直接返回 + if (!mInitialising && hourOfDay == getCurrentHourOfDay()) { + return; + } + mDate.set(Calendar.HOUR_OF_DAY, hourOfDay); + // 如果不是24小时视图，则调整小时数并更新AM/PM控制 + if (!mIs24HourView) { + if (hourOfDay >= HOURS_IN_HALF_DAY) { + mIsAm = false; + if (hourOfDay > HOURS_IN_HALF_DAY) { + hourOfDay -= HOURS_IN_HALF_DAY; + } + } else { + mIsAm = true; + if (hourOfDay == 0) { + hourOfDay = HOURS_IN_HALF_DAY; + } + } + updateAmPmControl(); + } + mHourSpinner.setValue(hourOfDay); + onDateTimeChanged(); + } + + /** + * 获取当前分钟数 + * + * @return 当前分钟数 + */ + public int getCurrentMinute() { + return mDate.get(Calendar.MINUTE); + } + + /** + * 设置当前分钟数 + * + * @param minute 当前分钟数值 + */ + public void setCurrentMinute(int minute) { + // 如果在初始化中或者分钟数未改变，则直接返回 + if (!mInitialising && minute == getCurrentMinute()) { + return; + } + mMinuteSpinner.setValue(minute); + mDate.set(Calendar.MINUTE, minute); + onDateTimeChanged(); + } + + /** + * 获取当前是否为24小时视图 + * + * @return 如果是24小时视图返回true，否则返回false + */ + public boolean is24HourView() { + return mIs24HourView; + } + + /** + * 设置当前视图为24小时制还是AM/PM制 + * + * @param is24HourView 如果为true表示24小时制，false表示AM/PM制 + */ + public void set24HourView(boolean is24HourView) { + // 如果视图模式未改变，则直接返回 + if (mIs24HourView == is24HourView) { + return; + } + mIs24HourView = is24HourView; + mAmPmSpinner.setVisibility(is24HourView ? View.GONE : View.VISIBLE); + int hour = getCurrentHourOfDay(); + updateHourControl(); + setCurrentHour(hour); + updateAmPmControl(); + } + + /** + * 更新日期控制组件，显示正确的日期选项 + */ + private void updateDateControl() { + Calendar cal = Calendar.getInstance(); + cal.setTimeInMillis(mDate.getTimeInMillis()); + cal.add(Calendar.DAY_OF_YEAR, -DAYS_IN_ALL_WEEK / 2 - 1); + mDateSpinner.setDisplayedValues(null); + // 循环设置一周内每一天的显示文本 + for (int i = 0; i < DAYS_IN_ALL_WEEK; ++i) { + cal.add(Calendar.DAY_OF_YEAR, 1); + mDateDisplayValues[i] = (String) DateFormat.format("MM.dd EEEE", cal); + } + mDateSpinner.setDisplayedValues(mDateDisplayValues); + mDateSpinner.setValue(DAYS_IN_ALL_WEEK / 2); + mDateSpinner.invalidate(); + } + + /** + * 根据当前是否为24小时视图来更新AM/PM控制组件的显示和值 + */ + private void updateAmPmControl() { + if (mIs24HourView) { + mAmPmSpinner.setVisibility(View.GONE); + } else { + int index = mIsAm ? Calendar.AM : Calendar.PM; + mAmPmSpinner.setValue(index); + mAmPmSpinner.setVisibility(View.VISIBLE); + } + } + + /** + * 根据当前是否为24小时视图来更新小时控制组件的最小值和最大值 + */ + private void updateHourControl() { + if (mIs24HourView) { + mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW); + mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW); + } else { + mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW); + mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW); + } + } + + /** + * 设置点击“设置”按钮时的回调接口 + * + * @param callback 回调接口实例，如果为null则不执行任何操作 + */ + public void setOnDateTimeChangedListener(OnDateTimeChangedListener callback) { + mOnDateTimeChangedListener = callback; + } + + /** + * 当日期时间被改变时调用此方法，如果设置了日期时间改变监听器，则触发监听器的回调方法 + */ + private void onDateTimeChanged() { + if (mOnDateTimeChangedListener != null) { + mOnDateTimeChangedListener.onDateTimeChanged(this, getCurrentYear(), + getCurrentMonth(), getCurrentDay(), getCurrentHourOfDay(), getCurrentMinute()); + } + } +} diff --git a/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/DateTimePickerDialog.java b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/DateTimePickerDialog.java new file mode 100644 index 0000000..2f9f8a9 --- /dev/null +++ b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/DateTimePickerDialog.java @@ -0,0 +1,121 @@ +/* + * DateTimePickerDialog类提供了一个日期和时间选择器对话框。 + * 用户可以选择一个日期和时间，然后通过监听器回调返回选择的值。 + */ +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(); + // 用于指示日期时间选择器是否使用24小时制 + private boolean mIs24HourView; + // 日期时间设置监听器，用于处理日期时间选择后的回调 + private OnDateTimeSetListener mOnDateTimeSetListener; + // 日期时间选择器视图 + private DateTimePicker mDateTimePicker; + + /** + * 日期时间设置监听器接口。 + * 实现此接口的类需要提供OnDateTimeSet方法来处理日期时间被设置的事件。 + */ + public interface OnDateTimeSetListener { + void OnDateTimeSet(AlertDialog dialog, long date); + } + + /** + * 构造函数初始化日期时间选择器对话框。 + * + * @param context 上下文对象，通常是指Activity。 + * @param date 初始显示的日期时间值。 + */ + public DateTimePickerDialog(Context context, long date) { + super(context); + mDateTimePicker = new DateTimePicker(context); + 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); + mDateTimePicker.setCurrentDate(mDate.getTimeInMillis()); + // 设置对话框的确认和取消按钮 + setButton(context.getString(R.string.datetime_dialog_ok), this); + setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener) null); + // 根据系统设置决定是否使用24小时制 + set24HourView(DateFormat.is24HourFormat(this.getContext())); + // 更新标题以显示当前选择的日期和时间 + updateTitle(mDate.getTimeInMillis()); + } + + /** + * 设置日期时间选择器是否使用24小时制。 + * + * @param is24HourView 是否使用24小时制。 + */ + public void set24HourView(boolean is24HourView) { + mIs24HourView = is24HourView; + } + + /** + * 设置日期时间被设置时的监听器。 + * + * @param callBack 日期时间设置监听器对象。 + */ + public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) { + mOnDateTimeSetListener = callBack; + } + + /** + * 更新对话框标题以显示当前选择的日期和时间。 + * + * @param date 当前选择的日期时间值。 + */ + private void updateTitle(long date) { + // 根据是否使用24小时制来格式化日期时间显示 + int flag = + DateUtils.FORMAT_SHOW_YEAR | + DateUtils.FORMAT_SHOW_DATE | + DateUtils.FORMAT_SHOW_TIME; + flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_24HOUR; + setTitle(DateUtils.formatDateTime(this.getContext(), date, flag)); + } + + /** + * 点击按钮时的处理逻辑。 + * 如果设置了日期时间设置监听器，则调用其OnDateTimeSet方法，传入当前选择的日期时间值。 + * + * @param arg0 对话框对象。 + * @param arg1 按钮标识。 + */ + public void onClick(DialogInterface arg0, int arg1) { + if (mOnDateTimeSetListener != null) { + mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis()); + } + } + +} diff --git a/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/DropdownMenu.java b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/DropdownMenu.java new file mode 100644 index 0000000..8330499 --- /dev/null +++ b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/DropdownMenu.java @@ -0,0 +1,73 @@ +/* + * DropdownMenu类用于创建和管理一个下拉菜单。 + * 该类封装了一个Button和一个PopupMenu，通过点击Button来显示下拉菜单。 + */ +package net.micode.notes.ui; + +import android.content.Context; +import android.view.Menu; +import android.view.MenuItem; +import android.view.View; +import android.view.View.OnClickListener; +import android.widget.Button; +import android.widget.PopupMenu; +import android.widget.PopupMenu.OnMenuItemClickListener; + +import net.micode.notes.R; + +public class DropdownMenu { + private Button mButton; // 弹出下拉菜单的按钮 + private PopupMenu mPopupMenu; // 弹出的下拉菜单 + private Menu mMenu; // 下拉菜单的项目集合 + + /** + * DropdownMenu的构造函数。 + * + * @param context 上下文对象，通常是指Activity。 + * @param button 用于触发下拉菜单显示的按钮。 + * @param menuId 菜单资源ID，用于加载下拉菜单的项目。 + */ + public DropdownMenu(Context context, Button button, int menuId) { + mButton = button; + mButton.setBackgroundResource(R.drawable.dropdown_icon); // 设置按钮背景为下拉图标 + mPopupMenu = new PopupMenu(context, mButton); // 创建PopupMenu实例 + mMenu = mPopupMenu.getMenu(); // 获取菜单项的集合 + mPopupMenu.getMenuInflater().inflate(menuId, mMenu); // 加载菜单项 + // 设置按钮点击事件，点击后显示下拉菜单 + mButton.setOnClickListener(new OnClickListener() { + public void onClick(View v) { + mPopupMenu.show(); + } + }); + } + + /** + * 设置下拉菜单项的点击事件监听器。 + * + * @param listener PopupMenu的OnMenuItemClickListener，用于监听菜单项的点击事件。 + */ + public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) { + if (mPopupMenu != null) { + mPopupMenu.setOnMenuItemClickListener(listener); + } + } + + /** + * 根据ID查找菜单项。 + * + * @param id 菜单项的ID。 + * @return 返回找到的MenuItem对象，如果未找到则返回null。 + */ + public MenuItem findItem(int id) { + return mMenu.findItem(id); + } + + /** + * 设置按钮的标题。 + * + * @param title 按钮要显示的标题。 + */ + public void setTitle(CharSequence title) { + mButton.setText(title); + } +} diff --git a/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/FoldersListAdapter.java b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/FoldersListAdapter.java new file mode 100644 index 0000000..2f461ca --- /dev/null +++ b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/FoldersListAdapter.java @@ -0,0 +1,110 @@ +/* + * FoldersListAdapter 类 + * 用于管理和适配文件夹列表的适配器，继承自 CursorAdapter。 + */ + +package net.micode.notes.ui; + +// 导入相关类 + +import android.content.Context; +import android.database.Cursor; +import android.view.View; +import android.view.ViewGroup; +import android.widget.CursorAdapter; +import android.widget.LinearLayout; +import android.widget.TextView; + +import net.micode.notes.R; +import net.micode.notes.data.Notes; +import net.micode.notes.data.Notes.NoteColumns; + + +public class FoldersListAdapter extends CursorAdapter { + // 查询时使用的列名数组 + public static final String[] PROJECTION = { + NoteColumns.ID, + NoteColumns.SNIPPET + }; + + // 列名数组中的索引常量 + public static final int ID_COLUMN = 0; + public static final int NAME_COLUMN = 1; + + /* + * 构造函数 + * @param context 上下文对象，通常指Activity或Application对象。 + * @param c 数据源游标Cursor。 + */ + public FoldersListAdapter(Context context, Cursor c) { + super(context, c); + } + + /* + * 创建新的列表项View + * @param context 上下文对象。 + * @param cursor 当前数据项的游标。 + * @param parent 视图的父容器。 + * @return 返回新创建的列表项View。 + */ + @Override + public View newView(Context context, Cursor cursor, ViewGroup parent) { + return new FolderListItem(context); + } + + /* + * 绑定数据到已有的View上 + * @param view 要绑定数据的视图。 + * @param context 上下文对象。 + * @param cursor 当前数据项的游标。 + */ + @Override + public void bindView(View view, Context context, Cursor cursor) { + if (view instanceof FolderListItem) { + // 根据文件夹ID判断是根文件夹还是普通文件夹，并设置文件夹名称 + String folderName = (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context + .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN); + ((FolderListItem) view).bind(folderName); + } + } + + /* + * 根据位置获取文件夹名称 + * @param context 上下文对象。 + * @param position 列表中的位置。 + * @return 返回该位置上文件夹的名称。 + */ + public String getFolderName(Context context, int position) { + Cursor cursor = (Cursor) getItem(position); + return (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context + .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN); + } + + /* + * FolderListItem 内部类 + * 用于表示文件夹列表中的一个项的视图类。 + */ + private class FolderListItem extends LinearLayout { + private TextView mName; // 文件夹名称的文本视图 + + /* + * 构造函数 + * @param context 上下文对象。 + */ + public FolderListItem(Context context) { + super(context); + // 加载布局文件，并将自己作为根视图 + inflate(context, R.layout.folder_list_item, this); + mName = (TextView) findViewById(R.id.tv_folder_name); // 获取文件夹名称的视图 + } + + /* + * 绑定数据到视图上 + * @param name 要显示的文件夹名称。 + */ + public void bind(String name) { + mName.setText(name); + } + } + +} diff --git a/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NoteEditActivity.java b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NoteEditActivity.java new file mode 100644 index 0000000..76c4c22 --- /dev/null +++ b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NoteEditActivity.java @@ -0,0 +1,1141 @@ +/* + * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package net.micode.notes.ui; + +import android.app.Activity; +import android.app.AlarmManager; +import android.app.AlertDialog; +import android.app.PendingIntent; +import android.app.SearchManager; +import android.appwidget.AppWidgetManager; +import android.content.ContentUris; +import android.content.Context; +import android.content.DialogInterface; +import android.content.Intent; +import android.content.SharedPreferences; +import android.graphics.Paint; +import android.os.Bundle; +import android.preference.PreferenceManager; +import android.text.Spannable; +import android.text.SpannableString; +import android.text.TextUtils; +import android.text.format.DateUtils; +import android.text.style.BackgroundColorSpan; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.Menu; +import android.view.MenuItem; +import android.view.MotionEvent; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.WindowManager; +import android.widget.CheckBox; +import android.widget.CompoundButton; +import android.widget.CompoundButton.OnCheckedChangeListener; +import android.widget.EditText; +import android.widget.ImageView; +import android.widget.LinearLayout; +import android.widget.TextView; +import android.widget.Toast; + +import net.micode.notes.R; +import net.micode.notes.data.Notes; +import net.micode.notes.data.Notes.TextNote; +import net.micode.notes.model.WorkingNote; +import net.micode.notes.model.WorkingNote.NoteSettingChangedListener; +import net.micode.notes.tool.DataUtils; +import net.micode.notes.tool.ResourceParser; +import net.micode.notes.tool.ResourceParser.TextAppearanceResources; +import net.micode.notes.ui.DateTimePickerDialog.OnDateTimeSetListener; +import net.micode.notes.ui.NoteEditText.OnTextViewChangeListener; +import net.micode.notes.widget.NoteWidgetProvider_2x; +import net.micode.notes.widget.NoteWidgetProvider_4x; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + + +public class NoteEditActivity extends Activity implements OnClickListener, + NoteSettingChangedListener, OnTextViewChangeListener { + /** + * 头部视图的ViewHolder类，用于存储头部视图中的UI组件引用。 + */ + private class HeadViewHolder { + public TextView tvModified; // 显示修改日期的文本视图 + public ImageView ivAlertIcon; // 提示图标图像视图 + public TextView tvAlertDate; // 显示提醒日期的文本视图 + public ImageView ibSetBgColor; // 设置背景颜色的图像视图 + } + + /** + * 背景选择按钮与其对应选中状态图标的映射。 + */ + private static final Map sBgSelectorBtnsMap = new HashMap(); + + static { + // 初始化背景选择按钮映射 + sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW); + sBgSelectorBtnsMap.put(R.id.iv_bg_red, ResourceParser.RED); + sBgSelectorBtnsMap.put(R.id.iv_bg_blue, ResourceParser.BLUE); + sBgSelectorBtnsMap.put(R.id.iv_bg_green, ResourceParser.GREEN); + sBgSelectorBtnsMap.put(R.id.iv_bg_white, ResourceParser.WHITE); + } + + /** + * 背景选择按钮选中状态与其对应图标的映射。 + */ + private static final Map sBgSelectorSelectionMap = new HashMap(); + + static { + // 初始化背景选择按钮选中状态映射 + sBgSelectorSelectionMap.put(ResourceParser.YELLOW, R.id.iv_bg_yellow_select); + sBgSelectorSelectionMap.put(ResourceParser.RED, R.id.iv_bg_red_select); + sBgSelectorSelectionMap.put(ResourceParser.BLUE, R.id.iv_bg_blue_select); + sBgSelectorSelectionMap.put(ResourceParser.GREEN, R.id.iv_bg_green_select); + sBgSelectorSelectionMap.put(ResourceParser.WHITE, R.id.iv_bg_white_select); + } + + /** + * 字号选择按钮与其对应字体大小的映射。 + */ + private static final Map sFontSizeBtnsMap = new HashMap(); + + static { + // 初始化字号选择按钮映射 + sFontSizeBtnsMap.put(R.id.ll_font_large, ResourceParser.TEXT_LARGE); + sFontSizeBtnsMap.put(R.id.ll_font_small, ResourceParser.TEXT_SMALL); + sFontSizeBtnsMap.put(R.id.ll_font_normal, ResourceParser.TEXT_MEDIUM); + sFontSizeBtnsMap.put(R.id.ll_font_super, ResourceParser.TEXT_SUPER); + } + + /** + * 字号选择按钮选中状态与其对应图标的映射。 + */ + private static final Map sFontSelectorSelectionMap = new HashMap(); + + static { + // 初始化字号选择按钮选中状态映射 + sFontSelectorSelectionMap.put(ResourceParser.TEXT_LARGE, R.id.iv_large_select); + sFontSelectorSelectionMap.put(ResourceParser.TEXT_SMALL, R.id.iv_small_select); + sFontSelectorSelectionMap.put(ResourceParser.TEXT_MEDIUM, R.id.iv_medium_select); + sFontSelectorSelectionMap.put(ResourceParser.TEXT_SUPER, R.id.iv_super_select); + } + + private static final String TAG = "NoteEditActivity"; // 日志标签 + + private HeadViewHolder mNoteHeaderHolder; // 头部视图的ViewHolder + + private View mHeadViewPanel; // 头部视图面板 + + private View mNoteBgColorSelector; // 笔记背景颜色选择器 + + private View mFontSizeSelector; // 字号选择器 + + private EditText mNoteEditor; // 笔记编辑器 + + private View mNoteEditorPanel; // 笔记编辑器面板 + + private WorkingNote mWorkingNote; // 当前正在编辑的笔记 + + private SharedPreferences mSharedPrefs; // 共享偏好设置 + private int mFontSizeId; // 当前选中的字体大小资源ID + + 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'); // 标记为未检查的字符串 + + private LinearLayout mEditTextList; // 编辑文本列表 + + private String mUserQuery; // 用户查询字符串 + private Pattern mPattern; // 正则表达式模式 + + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + this.setContentView(R.layout.note_edit); // 设置活动的视图布局 + + // 检查实例状态是否被保存，如果未保存且初始化活动状态失败，则结束该活动 + if (savedInstanceState == null && !initActivityState(getIntent())) { + finish(); + return; + } + initResources(); // 初始化资源 + } + + /** + * 当活动被系统销毁后，为了恢复之前的状态，此方法会被调用。 + * 主要用于处理活动重新创建时的数据恢复。 + * + * @param savedInstanceState 包含之前保存状态的Bundle，如果活动之前保存了状态，这里会传入非空的Bundle。 + */ + @Override + protected void onRestoreInstanceState(Bundle savedInstanceState) { + super.onRestoreInstanceState(savedInstanceState); + // 检查是否有保存的状态并且包含必要的UID信息，用于恢复活动状态 + if (savedInstanceState != null && savedInstanceState.containsKey(Intent.EXTRA_UID)) { + Intent intent = new Intent(Intent.ACTION_VIEW); + intent.putExtra(Intent.EXTRA_UID, savedInstanceState.getLong(Intent.EXTRA_UID)); + // 使用intent尝试恢复活动状态，如果失败则结束该活动 + if (!initActivityState(intent)) { + finish(); + return; + } + Log.d(TAG, "Restoring from killed activity"); // 日志记录，表示活动状态正在从被杀死的状态恢复 + } + } + + + /** + * 初始化活动状态，根据传入的Intent确定是查看笔记、新建笔记还是编辑笔记。 + * + * @param intent 传入的Intent，包含了动作类型和相关数据。 + * @return boolean 返回true表示成功初始化活动状态，false表示初始化失败。 + */ + private boolean initActivityState(Intent intent) { + // 如果用户指定的是查看笔记的动作但未提供笔记ID，则跳转到笔记列表活动 + mWorkingNote = null; + if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) { + long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0); + mUserQuery = ""; + + // 从搜索结果开始 + if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) { + noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY)); + mUserQuery = intent.getStringExtra(SearchManager.USER_QUERY); + } + + // 检查指定的笔记在数据库中是否可见 + if (!DataUtils.visibleInNoteDatabase(getContentResolver(), noteId, Notes.TYPE_NOTE)) { + Intent jump = new Intent(this, NotesListActivity.class); + startActivity(jump); + showToast(R.string.error_note_not_exist); + finish(); + return false; + } else { + // 加载指定ID的笔记 + mWorkingNote = WorkingNote.load(this, noteId); + if (mWorkingNote == null) { + Log.e(TAG, "load note failed with note id" + noteId); + finish(); + return false; + } + } + // 隐藏软键盘 + getWindow().setSoftInputMode( + WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN + | WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE); + } else if (TextUtils.equals(Intent.ACTION_INSERT_OR_EDIT, intent.getAction())) { + // 处理新建或编辑笔记的情况 + long folderId = intent.getLongExtra(Notes.INTENT_EXTRA_FOLDER_ID, 0); + int widgetId = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_ID, + AppWidgetManager.INVALID_APPWIDGET_ID); + int widgetType = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, + Notes.TYPE_WIDGET_INVALIDE); + int bgResId = intent.getIntExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, + ResourceParser.getDefaultBgId(this)); + + // 解析通话记录笔记 + String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER); + long callDate = intent.getLongExtra(Notes.INTENT_EXTRA_CALL_DATE, 0); + if (callDate != 0 && phoneNumber != null) { + // 根据电话号码和通话日期尝试获取已有笔记ID + 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; + } + } else { + // 创建新的通话记录笔记 + mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId, + widgetType, bgResId); + mWorkingNote.convertToCallNote(phoneNumber, callDate); + } + } else { + // 创建普通空笔记 + mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId, widgetType, + bgResId); + } + + // 显示软键盘 + getWindow().setSoftInputMode( + WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE + | WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE); + } else { + // 不支持的Intent动作 + Log.e(TAG, "Intent not specified action, should not support"); + finish(); + return false; + } + // 设置笔记状态改变的监听器 + mWorkingNote.setOnSettingStatusChangedListener(this); + return true; + } + + + /** + * 当Activity恢复到前台时调用。 + * 主要负责初始化笔记界面。 + */ + @Override + protected void onResume() { + super.onResume(); + initNoteScreen(); + } + + /** + * 初始化笔记界面的函数。 + * 该函数设置笔记编辑器的外观，根据笔记类型切换到相应的模式，设置背景和头部信息， + * 以及处理提醒头部的显示。 + */ + private void initNoteScreen() { + // 设置编辑器的文本外观 + mNoteEditor.setTextAppearance(this, TextAppearanceResources + .getTexAppearanceResource(mFontSizeId)); + // 根据当前笔记的类型，切换到列表模式或高亮查询结果模式 + if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) { + switchToListMode(mWorkingNote.getContent()); + } else { + mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery)); + mNoteEditor.setSelection(mNoteEditor.getText().length()); + } + // 隐藏所有背景选择器 + for (Integer id : sBgSelectorSelectionMap.keySet()) { + findViewById(sBgSelectorSelectionMap.get(id)).setVisibility(View.GONE); + } + // 设置标题和编辑区域的背景 + mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId()); + mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId()); + + // 设置修改时间 + mNoteHeaderHolder.tvModified.setText(DateUtils.formatDateTime(this, + mWorkingNote.getModifiedDate(), DateUtils.FORMAT_SHOW_DATE + | DateUtils.FORMAT_NUMERIC_DATE | DateUtils.FORMAT_SHOW_TIME + | DateUtils.FORMAT_SHOW_YEAR)); + + // 显示提醒头部信息（当前禁用，因DateTimePicker未准备好） + showAlertHeader(); + } + + /** + * 显示提醒头部信息的方法。 + * 如果当前笔记设置了提醒，该方法将根据提醒时间显示相对的时间或者过期信息。 + */ + private void showAlertHeader() { + // 处理提醒显示 + if (mWorkingNote.hasClockAlert()) { + long time = System.currentTimeMillis(); + // 如果提醒时间已过，显示提醒已过期的信息 + if (time > mWorkingNote.getAlertDate()) { + mNoteHeaderHolder.tvAlertDate.setText(R.string.note_alert_expired); + } else { + // 否则，显示相对时间 + mNoteHeaderHolder.tvAlertDate.setText(DateUtils.getRelativeTimeSpanString( + mWorkingNote.getAlertDate(), time, DateUtils.MINUTE_IN_MILLIS)); + } + // 设置提醒视图可见 + mNoteHeaderHolder.tvAlertDate.setVisibility(View.VISIBLE); + mNoteHeaderHolder.ivAlertIcon.setVisibility(View.VISIBLE); + } else { + // 如果没有设置提醒，隐藏提醒视图 + mNoteHeaderHolder.tvAlertDate.setVisibility(View.GONE); + mNoteHeaderHolder.ivAlertIcon.setVisibility(View.GONE); + } + } + + /** + * 当Activity接收到新的Intent时调用。 + * 用于根据新的Intent重新初始化Activity状态。 + * + * @param intent 新的Intent + */ + @Override + protected void onNewIntent(Intent intent) { + super.onNewIntent(intent); + initActivityState(intent); + } + + /** + * 保存Activity状态时调用。 + * 用于保存当前编辑的笔记，如果该笔记还未保存到数据库，则首先保存它。 + * 并且保存当前笔记的ID到Bundle中。 + * + * @param outState 用于保存Activity状态的Bundle + */ + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + // 如果当前编辑的笔记不存在于数据库中，即还未保存，先保存它 + if (!mWorkingNote.existInDatabase()) { + saveNote(); + } + // 保存笔记ID + outState.putLong(Intent.EXTRA_UID, mWorkingNote.getNoteId()); + Log.d(TAG, "Save working note id: " + mWorkingNote.getNoteId() + " onSaveInstanceState"); + } + + + /** + * 分发触摸事件。如果触摸事件不在指定视图范围内，则隐藏该视图。 + * + * @param ev 触摸事件 + * @return 如果事件被消费则返回true，否则返回false + */ + @Override + public boolean dispatchTouchEvent(MotionEvent ev) { + // 如果背景颜色选择器可见且不在触摸范围内，则隐藏它并消费事件 + if (mNoteBgColorSelector.getVisibility() == View.VISIBLE + && !inRangeOfView(mNoteBgColorSelector, ev)) { + mNoteBgColorSelector.setVisibility(View.GONE); + return true; + } + + // 如果字体大小选择器可见且不在触摸范围内，则隐藏它并消费事件 + if (mFontSizeSelector.getVisibility() == View.VISIBLE + && !inRangeOfView(mFontSizeSelector, ev)) { + mFontSizeSelector.setVisibility(View.GONE); + return true; + } + // 如果上述条件都不满足，则将事件传递给父类处理 + return super.dispatchTouchEvent(ev); + } + + /** + * 判断触摸点是否在指定视图范围内。 + * + * @param view 视图 + * @param ev 触摸事件 + * @return 如果触摸点在视图范围内则返回true，否则返回false + */ + private boolean inRangeOfView(View view, MotionEvent ev) { + int[] location = new int[2]; + view.getLocationOnScreen(location); + int x = location[0]; + int y = location[1]; + // 判断触摸点是否在视图外 + if (ev.getX() < x + || ev.getX() > (x + view.getWidth()) + || ev.getY() < y + || ev.getY() > (y + view.getHeight())) { + return false; + } + return true; + } + + /** + * 初始化资源，包括视图和偏好设置。 + */ + private void initResources() { + // 初始化头部视图和相关组件 + mHeadViewPanel = findViewById(R.id.note_title); + mNoteHeaderHolder = new HeadViewHolder(); + mNoteHeaderHolder.tvModified = (TextView) findViewById(R.id.tv_modified_date); + mNoteHeaderHolder.ivAlertIcon = (ImageView) findViewById(R.id.iv_alert_icon); + mNoteHeaderHolder.tvAlertDate = (TextView) findViewById(R.id.tv_alert_date); + mNoteHeaderHolder.ibSetBgColor = (ImageView) findViewById(R.id.btn_set_bg_color); + mNoteHeaderHolder.ibSetBgColor.setOnClickListener(this); + // 初始化编辑器和相关组件 + mNoteEditor = (EditText) findViewById(R.id.note_edit_view); + mNoteEditorPanel = findViewById(R.id.sv_note_edit); + mNoteBgColorSelector = findViewById(R.id.note_bg_color_selector); + // 设置背景选择器按钮点击监听器 + for (int id : sBgSelectorBtnsMap.keySet()) { + ImageView iv = (ImageView) findViewById(id); + iv.setOnClickListener(this); + } + + mFontSizeSelector = findViewById(R.id.font_size_selector); + // 设置字体大小选择器按钮点击监听器 + for (int id : sFontSizeBtnsMap.keySet()) { + View view = findViewById(id); + view.setOnClickListener(this); + } + ; + // 从偏好设置中读取字体大小 + mSharedPrefs = PreferenceManager.getDefaultSharedPreferences(this); + mFontSizeId = mSharedPrefs.getInt(PREFERENCE_FONT_SIZE, ResourceParser.BG_DEFAULT_FONT_SIZE); + // 修复存储在偏好设置中的字体大小资源ID的错误 + if (mFontSizeId >= TextAppearanceResources.getResourcesSize()) { + mFontSizeId = ResourceParser.BG_DEFAULT_FONT_SIZE; + } + // 初始化编辑列表 + mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list); + } + + /** + * 暂停时保存笔记数据并清除设置状态。 + */ + @Override + protected void onPause() { + super.onPause(); + // 保存笔记数据 + if (saveNote()) { + Log.d(TAG, "Note data was saved with length:" + mWorkingNote.getContent().length()); + } + // 清除设置状态 + clearSettingState(); + } + + /** + * 更新小部件显示。 + */ + private void updateWidget() { + Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE); + // 根据小部件类型设置对应的类 + if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_2X) { + intent.setClass(this, NoteWidgetProvider_2x.class); + } else if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_4X) { + intent.setClass(this, NoteWidgetProvider_4x.class); + } else { + Log.e(TAG, "Unspported widget type"); + return; + } + + // 设置小部件ID + intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[]{ + mWorkingNote.getWidgetId() + }); + + // 发送广播更新小部件 + sendBroadcast(intent); + // 设置结果为OK + setResult(RESULT_OK, intent); + } + + + /** + * 点击事件的处理函数。 + * + * @param v 被点击的视图对象。 + */ + public void onClick(View v) { + int id = v.getId(); + // 如果点击的是设置背景颜色的按钮 + if (id == R.id.btn_set_bg_color) { + mNoteBgColorSelector.setVisibility(View.VISIBLE); + // 根据当前笔记的背景颜色，设置对应的色板按钮可见 + findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility( + View.VISIBLE); + } else if (sBgSelectorBtnsMap.containsKey(id)) { + // 如果点击的是背景色板上的颜色 + findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility( + View.GONE); // 隐藏当前选择的背景颜色 + mWorkingNote.setBgColorId(sBgSelectorBtnsMap.get(id)); // 更新笔记的背景颜色 + mNoteBgColorSelector.setVisibility(View.GONE); // 隐藏背景颜色选择器 + } else if (sFontSizeBtnsMap.containsKey(id)) { + // 如果点击的是字体大小按钮 + findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.GONE); // 隐藏当前选择的字体大小 + mFontSizeId = sFontSizeBtnsMap.get(id); // 更新选择的字体大小 + mSharedPrefs.edit().putInt(PREFERENCE_FONT_SIZE, mFontSizeId).commit(); // 保存选择的字体大小到SharedPreferences + findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE); // 设置新选择的字体大小按钮为可见 + // 根据当前笔记是否为清单模式，进行相应的文本更新 + if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) { + getWorkingText(); + switchToListMode(mWorkingNote.getContent()); + } else { + mNoteEditor.setTextAppearance(this, + TextAppearanceResources.getTexAppearanceResource(mFontSizeId)); + } + mFontSizeSelector.setVisibility(View.GONE); // 隐藏字体大小选择器 + } + } + + /** + * 按下返回键时的处理函数。 + */ + @Override + public void onBackPressed() { + // 尝试清除设置状态，如果成功，则不执行保存笔记操作 + if (clearSettingState()) { + return; + } + // 保存笔记并执行父类的onBackPressed()方法（结束当前Activity） + saveNote(); + super.onBackPressed(); + } + + /** + * 尝试清除设置状态（背景颜色选择或字体大小选择）。 + * + * @return 如果成功清除设置状态，返回true；否则返回false。 + */ + private boolean clearSettingState() { + // 如果背景颜色选择器可见，则隐藏它并返回true + if (mNoteBgColorSelector.getVisibility() == View.VISIBLE) { + mNoteBgColorSelector.setVisibility(View.GONE); + return true; + } else if (mFontSizeSelector.getVisibility() == View.VISIBLE) { // 如果字体大小选择器可见，则隐藏它并返回true + mFontSizeSelector.setVisibility(View.GONE); + return true; + } + return false; // 没有可见的设置状态需要清除，返回false + } + + /** + * 当背景颜色发生变化时的处理函数。 + */ + public void onBackgroundColorChanged() { + // 根据当前笔记的背景颜色，设置对应的色板按钮可见，并更新编辑器及标题栏的背景颜色 + findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility( + View.VISIBLE); + mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId()); + mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId()); + } + + /** + * 准备选项菜单的函数。 + * + * @param menu 选项菜单对象。 + * @return 总是返回true。 + */ + @Override + public boolean onPrepareOptionsMenu(Menu menu) { + // 如果Activity正在结束，则不进行任何操作 + if (isFinishing()) { + return true; + } + // 尝试清除设置状态 + clearSettingState(); + menu.clear(); // 清除菜单项 + // 根据笔记所属的文件夹，加载不同的菜单资源 + if (mWorkingNote.getFolderId() == Notes.ID_CALL_RECORD_FOLDER) { + getMenuInflater().inflate(R.menu.call_note_edit, menu); + } else { + getMenuInflater().inflate(R.menu.note_edit, menu); + } + // 根据当前笔记的清单模式，更新“清单模式”菜单项的标题 + if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) { + menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_normal_mode); + } else { + menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_list_mode); + } + // 根据笔记是否有提醒，更新“删除提醒”菜单项的可见性 + if (mWorkingNote.hasClockAlert()) { + menu.findItem(R.id.menu_alert).setVisible(false); + } else { + menu.findItem(R.id.menu_delete_remind).setVisible(false); + } + return true; + } + + + /** + * 处理选项菜单项的选择事件。 + * + * @param item 选中的菜单项 + * @return 总是返回true，表示事件已处理。 + */ + @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(); + } + }); + builder.setNegativeButton(android.R.string.cancel, null); + builder.show(); + break; + case R.id.menu_font_size: + // 显示字体大小选择器 + mFontSizeSelector.setVisibility(View.VISIBLE); + findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE); + break; + case R.id.menu_list_mode: + // 切换笔记的列表模式 + mWorkingNote.setCheckListMode(mWorkingNote.getCheckListMode() == 0 ? + TextNote.MODE_CHECK_LIST : 0); + break; + case R.id.menu_share: + // 获取当前编辑的笔记内容并分享 + getWorkingText(); + sendTo(this, mWorkingNote.getContent()); + break; + case R.id.menu_send_to_desktop: + // 将笔记发送到桌面 + sendToDesktop(); + break; + case R.id.menu_alert: + // 设置提醒 + setReminder(); + break; + case R.id.menu_delete_remind: + // 删除提醒设置 + mWorkingNote.setAlertDate(0, false); + break; + default: + break; + } + return true; + } + + /** + * 弹出日期时间选择器，用于设置提醒时间。 + */ + private void setReminder() { + DateTimePickerDialog d = new DateTimePickerDialog(this, System.currentTimeMillis()); + d.setOnDateTimeSetListener(new OnDateTimeSetListener() { + public void OnDateTimeSet(AlertDialog dialog, long date) { + // 用户设定时间后，设置提醒 + mWorkingNote.setAlertDate(date, true); + } + }); + d.show(); + } + + /** + * 分享笔记到支持 {@link Intent#ACTION_SEND} 操作和 {@text/plain} 类型的应用。 + * + * @param context 上下文 + * @param info 要分享的信息 + */ + private void sendTo(Context context, String info) { + Intent intent = new Intent(Intent.ACTION_SEND); + intent.putExtra(Intent.EXTRA_TEXT, info); + intent.setType("text/plain"); + context.startActivity(intent); + } + + /** + * 首先保存当前正在编辑的笔记，然后启动一个新的NoteEditActivity用于创建新笔记。 + */ + private void createNewNote() { + // 首先保存当前笔记 + saveNote(); + + // 安全地开始一个新的NoteEditActivity + finish(); + Intent intent = new Intent(this, NoteEditActivity.class); + intent.setAction(Intent.ACTION_INSERT_OR_EDIT); + intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mWorkingNote.getFolderId()); + startActivity(intent); + } + + + /** + * 删除当前正在编辑的笔记。 + * 如果笔记存在于数据库中，并且当前不是同步模式，将直接删除该笔记； + * 如果处于同步模式，则将笔记移动到回收站文件夹。 + */ + private void deleteCurrentNote() { + if (mWorkingNote.existInDatabase()) { + HashSet ids = new HashSet(); + long id = mWorkingNote.getNoteId(); + if (id != Notes.ID_ROOT_FOLDER) { + ids.add(id); + } else { + Log.d(TAG, "Wrong note id, should not happen"); + } + if (!isSyncMode()) { + // 非同步模式下直接删除笔记 + if (!DataUtils.batchDeleteNotes(getContentResolver(), ids)) { + Log.e(TAG, "Delete Note error"); + } + } else { + // 同步模式下将笔记移动到回收站 + if (!DataUtils.batchMoveToFolder(getContentResolver(), ids, Notes.ID_TRASH_FOLER)) { + Log.e(TAG, "Move notes to trash folder error, should not happens"); + } + } + } + mWorkingNote.markDeleted(true); + } + + /** + * 判断当前是否为同步模式。 + * 同步模式是指在设置中配置了同步账户名。 + * + * @return 如果配置了同步账户名返回true，否则返回false。 + */ + private boolean isSyncMode() { + return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0; + } + + /** + * 处理时钟提醒变更事件。 + * 首先检查当前笔记是否已保存，未保存则先保存。 + * 如果笔记存在，根据set参数设置或取消提醒。 + * 如果笔记不存在（即无有效ID），记录错误并提示用户输入内容。 + * + * @param date 提醒的日期时间戳 + * @param set 是否设置提醒 + */ + public void onClockAlertChanged(long date, boolean set) { + if (!mWorkingNote.existInDatabase()) { + saveNote(); + } + if (mWorkingNote.getNoteId() > 0) { + Intent intent = new Intent(this, AlarmReceiver.class); + intent.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mWorkingNote.getNoteId())); + PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, intent, 0); + AlarmManager alarmManager = ((AlarmManager) getSystemService(ALARM_SERVICE)); + showAlertHeader(); + if (!set) { + alarmManager.cancel(pendingIntent); + } else { + alarmManager.set(AlarmManager.RTC_WAKEUP, date, pendingIntent); + } + } else { + Log.e(TAG, "Clock alert setting error"); + showToast(R.string.error_note_empty_for_clock); + } + } + + /** + * 更新小部件显示。 + */ + public void onWidgetChanged() { + updateWidget(); + } + + /** + * 当删除某个编辑框中的文本时的处理逻辑。 + * 重新设置后续编辑框的索引，并将删除的文本添加到前一个或当前编辑框中。 + * + * @param index 被删除文本的编辑框索引 + * @param text 被删除的文本内容 + */ + public void onEditTextDelete(int index, String text) { + int childCount = mEditTextList.getChildCount(); + if (childCount == 1) { + return; + } + + for (int i = index + 1; i < childCount; i++) { + ((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text)) + .setIndex(i - 1); + } + + mEditTextList.removeViewAt(index); + NoteEditText edit = null; + if (index == 0) { + edit = (NoteEditText) mEditTextList.getChildAt(0).findViewById( + R.id.et_edit_text); + } else { + edit = (NoteEditText) mEditTextList.getChildAt(index - 1).findViewById( + R.id.et_edit_text); + } + int length = edit.length(); + edit.append(text); + edit.requestFocus(); + edit.setSelection(length); + } + + /** + * 当在编辑框中按下“Enter”键时的处理逻辑。 + * 在列表中添加一个新的编辑框，并重新设置后续编辑框的索引。 + * + * @param index 当前编辑框的索引 + * @param text 当前编辑框中的文本内容 + */ + public void onEditTextEnter(int index, String text) { + if (index > mEditTextList.getChildCount()) { + Log.e(TAG, "Index out of mEditTextList boundrary, should not happen"); + } + + View view = getListItem(text, index); + mEditTextList.addView(view, index); + NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text); + edit.requestFocus(); + edit.setSelection(0); + for (int i = index + 1; i < mEditTextList.getChildCount(); i++) { + ((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text)) + .setIndex(i); + } + } + + + /** + * 切换到列表模式。 + * 将文本分割成多行，并为每行创建一个列表项，展示在编辑文本列表中。 + * + * @param text 要转换成列表模式的文本，每行代表一个列表项。 + */ + private void switchToListMode(String text) { + // 清空当前的视图 + mEditTextList.removeAllViews(); + // 使用换行符分割文本，创建列表项 + String[] items = text.split("\n"); + int index = 0; + for (String item : items) { + // 忽略空行 + if (!TextUtils.isEmpty(item)) { + mEditTextList.addView(getListItem(item, index)); + index++; + } + } + // 添加一个空的列表项作为占位符 + mEditTextList.addView(getListItem("", index)); + // 请求焦点以便于编辑 + mEditTextList.getChildAt(index).findViewById(R.id.et_edit_text).requestFocus(); + + // 隐藏编辑器，显示列表 + mNoteEditor.setVisibility(View.GONE); + mEditTextList.setVisibility(View.VISIBLE); + } + + /** + * 高亮显示查询结果。 + * 在给定的文本中，根据用户查询字符串高亮显示匹配的部分。 + * + * @param fullText 完整的文本。 + * @param userQuery 用户的查询字符串。 + * @return 包含高亮显示的文本的Spannable对象。 + */ + private Spannable getHighlightQueryResult(String fullText, String userQuery) { + SpannableString spannable = new SpannableString(fullText == null ? "" : fullText); + // 如果有查询字符串，则进行高亮处理 + if (!TextUtils.isEmpty(userQuery)) { + mPattern = Pattern.compile(userQuery); + Matcher m = mPattern.matcher(fullText); + int start = 0; + while (m.find(start)) { + // 设置高亮背景 + spannable.setSpan( + new BackgroundColorSpan(this.getResources().getColor( + R.color.user_query_highlight)), m.start(), m.end(), + Spannable.SPAN_INCLUSIVE_EXCLUSIVE); + start = m.end(); + } + } + return spannable; + } + + /** + * 创建列表项视图。 + * 为列表模式创建并配置一个包含文本编辑框和复选框的视图。 + * + * @param item 列表项的文本内容。 + * @param index 列表项的索引。 + * @return 配置好的列表项视图。 + */ + private View getListItem(String item, int index) { + // 加载列表项布局 + View view = LayoutInflater.from(this).inflate(R.layout.note_edit_list_item, null); + final NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text); + // 设置文本样式 + edit.setTextAppearance(this, TextAppearanceResources.getTexAppearanceResource(mFontSizeId)); + CheckBox cb = ((CheckBox) view.findViewById(R.id.cb_edit_item)); + // 复选框的监听器，用于切换文本的划线状态 + cb.setOnCheckedChangeListener(new OnCheckedChangeListener() { + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { + if (isChecked) { + edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG); + } else { + edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG); + } + } + }); + + // 根据文本前缀设置复选框状态和文本内容 + if (item.startsWith(TAG_CHECKED)) { + cb.setChecked(true); + edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG); + item = item.substring(TAG_CHECKED.length(), item.length()).trim(); + } else if (item.startsWith(TAG_UNCHECKED)) { + cb.setChecked(false); + edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG); + item = item.substring(TAG_UNCHECKED.length(), item.length()).trim(); + } + + // 设置文本变化监听和索引 + edit.setOnTextViewChangeListener(this); + edit.setIndex(index); + // 设置带有查询结果高亮的文本 + edit.setText(getHighlightQueryResult(item, mUserQuery)); + return view; + } + + /** + * 根据文本内容是否为空，切换复选框的可见性。 + * + * @param index 列表项索引。 + * @param hasText 列表项是否包含文本。 + */ + public void onTextChange(int index, boolean hasText) { + if (index >= mEditTextList.getChildCount()) { + Log.e(TAG, "Wrong index, should not happen"); + return; + } + // 根据文本内容决定复选框的可见性 + if (hasText) { + mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.VISIBLE); + } else { + mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.GONE); + } + } + + /** + * 在切换编辑模式和列表模式时更新UI。 + * + * @param oldMode 旧的编辑模式。 + * @param newMode 新的编辑模式。 + */ + public void onCheckListModeChanged(int oldMode, int newMode) { + // 切换到列表模式 + if (newMode == TextNote.MODE_CHECK_LIST) { + switchToListMode(mNoteEditor.getText().toString()); + } else { + // 切换回编辑模式 + if (!getWorkingText()) { + mWorkingNote.setWorkingText(mWorkingNote.getContent().replace(TAG_UNCHECKED + " ", + "")); + } + mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery)); + mEditTextList.setVisibility(View.GONE); + mNoteEditor.setVisibility(View.VISIBLE); + } + } + + /** + * 根据当前列表项的选中状态，构建并返回工作文本。 + * + * @return 是否有已选中的列表项。 + */ + private boolean getWorkingText() { + boolean hasChecked = false; + if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < mEditTextList.getChildCount(); i++) { + View view = mEditTextList.getChildAt(i); + NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text); + // 构建带有选中状态前缀的文本 + if (!TextUtils.isEmpty(edit.getText())) { + if (((CheckBox) view.findViewById(R.id.cb_edit_item)).isChecked()) { + sb.append(TAG_CHECKED).append(" ").append(edit.getText()).append("\n"); + hasChecked = true; + } else { + sb.append(TAG_UNCHECKED).append(" ").append(edit.getText()).append("\n"); + } + } + } + mWorkingNote.setWorkingText(sb.toString()); + } else { + mWorkingNote.setWorkingText(mNoteEditor.getText().toString()); + } + return hasChecked; + } + + /** + * 保存笔记。 + * 更新笔记内容并保存。 + * + * @return 是否成功保存笔记。 + */ + private boolean saveNote() { + getWorkingText(); + boolean saved = mWorkingNote.saveNote(); + if (saved) { + // 设置结果为成功，以便外部调用者知道保存操作的状态 + setResult(RESULT_OK); + } + return saved; + } + + + /** + * 将当前编辑的笔记发送到桌面。首先会检查当前编辑的笔记是否已存在于数据库中， + * 如果不存在，则先保存。如果存在，会创建一个快捷方式放在桌面。 + */ + private void sendToDesktop() { + // 检查当前编辑的笔记是否存在于数据库，若不存在则先保存 + if (!mWorkingNote.existInDatabase()) { + saveNote(); + } + + // 如果笔记存在于数据库（有noteId），则创建快捷方式 + if (mWorkingNote.getNoteId() > 0) { + Intent sender = new Intent(); + Intent shortcutIntent = new Intent(this, NoteEditActivity.class); + shortcutIntent.setAction(Intent.ACTION_VIEW); + shortcutIntent.putExtra(Intent.EXTRA_UID, mWorkingNote.getNoteId()); + sender.putExtra(Intent.EXTRA_SHORTCUT_INTENT, shortcutIntent); + sender.putExtra(Intent.EXTRA_SHORTCUT_NAME, + makeShortcutIconTitle(mWorkingNote.getContent())); + sender.putExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE, + Intent.ShortcutIconResource.fromContext(this, R.drawable.icon_app)); + sender.putExtra("duplicate", true); + sender.setAction("com.android.launcher.action.INSTALL_SHORTCUT"); + showToast(R.string.info_note_enter_desktop); + sendBroadcast(sender); + } else { + // 如果用户未输入任何内容，无法创建快捷方式，提醒用户输入内容 + Log.e(TAG, "Send to desktop error"); + showToast(R.string.error_note_empty_for_send_to_desktop); + } + } + + /** + * 根据笔记内容生成快捷方式的标题。移除内容中的已选和未选标签，并确保标题长度不超过上限。 + * + * @param content 符合快捷方式图标标题要求的笔记内容 + * @return 标题字符串 + */ + private String makeShortcutIconTitle(String content) { + content = content.replace(TAG_CHECKED, ""); + content = content.replace(TAG_UNCHECKED, ""); + return content.length() > SHORTCUT_ICON_TITLE_MAX_LEN ? content.substring(0, + SHORTCUT_ICON_TITLE_MAX_LEN) : content; + } + + /** + * 显示一个Toast消息。 + * + * @param resId 资源ID，指向要显示的字符串 + */ + private void showToast(int resId) { + showToast(resId, Toast.LENGTH_SHORT); + } + + /** + * 显示一个指定时长的Toast消息。 + * + * @param resId 资源ID，指向要显示的字符串 + * @param duration 显示时长，可以是Toast.LENGTH_SHORT或Toast.LENGTH_LONG + */ + private void showToast(int resId, int duration) { + Toast.makeText(this, resId, duration).show(); + } + +} diff --git a/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NoteEditText.java b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NoteEditText.java new file mode 100644 index 0000000..8e3e59f --- /dev/null +++ b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NoteEditText.java @@ -0,0 +1,267 @@ +/* + * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package net.micode.notes.ui; + +import android.content.Context; +import android.graphics.Rect; +import android.text.Layout; +import android.text.Selection; +import android.text.Spanned; +import android.text.TextUtils; +import android.text.style.URLSpan; +import android.util.AttributeSet; +import android.util.Log; +import android.view.ContextMenu; +import android.view.KeyEvent; +import android.view.MenuItem; +import android.view.MenuItem.OnMenuItemClickListener; +import android.view.MotionEvent; +import android.widget.EditText; + +import net.micode.notes.R; + +import java.util.HashMap; +import java.util.Map; + +/** + * 自定义的可编辑文本视图，支持文本变化监听、删除和新增文本事件。 + */ +public class NoteEditText extends EditText { + private static final String TAG = "NoteEditText"; + private int mIndex; // 当前文本视图的索引 + private int mSelectionStartBeforeDelete; // 删除操作前的选择起始位置 + + private static final String SCHEME_TEL = "tel:"; + private static final String SCHEME_HTTP = "http:"; + private static final String SCHEME_EMAIL = "mailto:"; + + // URL方案与对应操作资源ID的映射 + private static final Map sSchemaActionResMap = new HashMap(); + + static { + sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel); + sSchemaActionResMap.put(SCHEME_HTTP, R.string.note_link_web); + sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email); + } + + /** + * 文本视图变化监听接口。 + */ + public interface OnTextViewChangeListener { + /** + * 当按下删除键且文本为空时，删除当前文本视图。 + */ + void onEditTextDelete(int index, String text); + + /** + * 当按下回车键时，新增一个文本视图。 + */ + void onEditTextEnter(int index, String text); + + /** + * 当文本变化时，隐藏或显示项目选项。 + */ + void onTextChange(int index, boolean hasText); + } + + private OnTextViewChangeListener mOnTextViewChangeListener; + + /** + * 构造函数，初始化编辑文本视图。 + * + * @param context 上下文对象 + */ + public NoteEditText(Context context) { + super(context, null); + mIndex = 0; + } + + /** + * 设置当前文本视图的索引。 + * + * @param index 当前文本视图的索引 + */ + public void setIndex(int index) { + mIndex = index; + } + + /** + * 设置文本视图变化监听器。 + * + * @param listener 文本视图变化监听器 + */ + public void setOnTextViewChangeListener(OnTextViewChangeListener listener) { + mOnTextViewChangeListener = listener; + } + + /** + * 构造函数，初始化编辑文本视图。 + * + * @param context 上下文对象 + * @param attrs 属性集 + */ + public NoteEditText(Context context, AttributeSet attrs) { + super(context, attrs, android.R.attr.editTextStyle); + } + + /** + * 构造函数，初始化编辑文本视图。 + * + * @param context 上下文对象 + * @param attrs 属性集 + * @param defStyle 样式 + */ + public NoteEditText(Context context, AttributeSet attrs, int defStyle) { + super(context, attrs, defStyle); + } + + /** + * 处理触摸事件，调整光标位置。 + */ + @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; + } + 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) { + if (0 == mSelectionStartBeforeDelete && mIndex != 0) { + mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString()); + return true; + } + } else { + Log.d(TAG, "OnTextViewChangeListener was not seted"); + } + break; + case KeyEvent.KEYCODE_ENTER: + // 处理回车键事件，新增文本视图 + if (mOnTextViewChangeListener != null) { + int selectionStart = getSelectionStart(); + String text = getText().subSequence(selectionStart, length()).toString(); + setText(getText().subSequence(0, selectionStart)); + mOnTextViewChangeListener.onEditTextEnter(mIndex + 1, text); + } else { + Log.d(TAG, "OnTextViewChangeListener was not seted"); + } + break; + default: + break; + } + return super.onKeyUp(keyCode, event); + } + + /** + * 当焦点变化时，通知文本变化情况。 + */ + @Override + protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) { + if (mOnTextViewChangeListener != null) { + if (!focused && TextUtils.isEmpty(getText())) { + mOnTextViewChangeListener.onTextChange(mIndex, false); + } else { + mOnTextViewChangeListener.onTextChange(mIndex, true); + } + } + super.onFocusChanged(focused, direction, previouslyFocusedRect); + } + + /** + * 创建上下文菜单，支持点击URL跳转。 + */ + @Override + protected void onCreateContextMenu(ContextMenu menu) { + if (getText() instanceof Spanned) { + int selStart = getSelectionStart(); + int selEnd = getSelectionEnd(); + + int min = Math.min(selStart, selEnd); + int max = Math.max(selStart, selEnd); + + final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class); + if (urls.length == 1) { + int defaultResId = 0; + for (String schema : sSchemaActionResMap.keySet()) { + if (urls[0].getURL().indexOf(schema) >= 0) { + defaultResId = sSchemaActionResMap.get(schema); + break; + } + } + + if (defaultResId == 0) { + defaultResId = R.string.note_link_other; + } + + menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener( + new OnMenuItemClickListener() { + public boolean onMenuItemClick(MenuItem item) { + // 跳转到URL指向的页面 + urls[0].onClick(NoteEditText.this); + return true; + } + }); + } + } + super.onCreateContextMenu(menu); + } +} + diff --git a/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NoteItemData.java b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NoteItemData.java new file mode 100644 index 0000000..e0c70c5 --- /dev/null +++ b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NoteItemData.java @@ -0,0 +1,257 @@ +/* + * 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 { + // 定义查询时要投影的列 + static final String[] PROJECTION = new String[]{ + NoteColumns.ID, + NoteColumns.ALERTED_DATE, + NoteColumns.BG_COLOR_ID, + NoteColumns.CREATED_DATE, + NoteColumns.HAS_ATTACHMENT, + NoteColumns.MODIFIED_DATE, + NoteColumns.NOTES_COUNT, + NoteColumns.PARENT_ID, + NoteColumns.SNIPPET, + NoteColumns.TYPE, + NoteColumns.WIDGET_ID, + NoteColumns.WIDGET_TYPE, + }; + + // 各列数据的索引 + private static final int ID_COLUMN = 0; + private static final int ALERTED_DATE_COLUMN = 1; + private static final int BG_COLOR_ID_COLUMN = 2; + private static final int CREATED_DATE_COLUMN = 3; + private static final int HAS_ATTACHMENT_COLUMN = 4; + private static final int MODIFIED_DATE_COLUMN = 5; + private static final int NOTES_COUNT_COLUMN = 6; + private static final int PARENT_ID_COLUMN = 7; + private static final int SNIPPET_COLUMN = 8; + private static final int TYPE_COLUMN = 9; + private static final int WIDGET_ID_COLUMN = 10; + private static final int WIDGET_TYPE_COLUMN = 11; + + // 笔记的各项数据 + private long mId; + private long mAlertDate; + private int mBgColorId; + private long mCreatedDate; + private boolean mHasAttachment; + private long mModifiedDate; + private int mNotesCount; + private long mParentId; + private String mSnippet; + private int mType; + private int mWidgetId; + private int mWidgetType; + private String mName; + private String mPhoneNumber; + + // 用于标识笔记在列表中的位置状态 + private boolean mIsLastItem; + private boolean mIsFirstItem; + private boolean mIsOnlyOneItem; + private boolean mIsOneNoteFollowingFolder; + private boolean mIsMultiNotesFollowingFolder; + + /** + * 根据Cursor数据构造一个NoteItemData对象。 + * + * @param context 上下文对象，用于访问应用全局功能。 + * @param cursor 包含笔记数据的Cursor对象。 + */ + public NoteItemData(Context context, Cursor cursor) { + // 从Cursor中提取各项数据并赋值 + mId = cursor.getLong(ID_COLUMN); + mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN); + mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN); + mCreatedDate = cursor.getLong(CREATED_DATE_COLUMN); + mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0) ? true : false; + mModifiedDate = cursor.getLong(MODIFIED_DATE_COLUMN); + mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN); + mParentId = cursor.getLong(PARENT_ID_COLUMN); + mSnippet = cursor.getString(SNIPPET_COLUMN); + mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace( + NoteEditActivity.TAG_UNCHECKED, ""); + mType = cursor.getInt(TYPE_COLUMN); + mWidgetId = cursor.getInt(WIDGET_ID_COLUMN); + mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN); + + // 如果是通话记录笔记，尝试获取通话号码和联系人名称 + mPhoneNumber = ""; + if (mParentId == Notes.ID_CALL_RECORD_FOLDER) { + mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId); + if (!TextUtils.isEmpty(mPhoneNumber)) { + mName = Contact.getContact(context, mPhoneNumber); + if (mName == null) { + mName = mPhoneNumber; + } + } + } + + // 如果没有获取到联系人名称，则默认为空字符串 + if (mName == null) { + mName = ""; + } + checkPostion(cursor); + } + + /** + * 根据当前Cursor位置，更新NoteItemData的状态信息（如是否为列表中的最后一个项目等）。 + * + * @param cursor 包含笔记数据的Cursor对象。 + */ + private void checkPostion(Cursor cursor) { + // 更新位置状态信息 + mIsLastItem = cursor.isLast(); + mIsFirstItem = cursor.isFirst(); + mIsOnlyOneItem = (cursor.getCount() == 1); + mIsMultiNotesFollowingFolder = false; + mIsOneNoteFollowingFolder = false; + + // 检查当前笔记是否跟随文件夹，并更新相应状态 + if (mType == Notes.TYPE_NOTE && !mIsFirstItem) { + int position = cursor.getPosition(); + if (cursor.moveToPrevious()) { + if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER + || cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) { + if (cursor.getCount() > (position + 1)) { + mIsMultiNotesFollowingFolder = true; + } else { + mIsOneNoteFollowingFolder = true; + } + } + // 确保Cursor能够回到原来的位置 + if (!cursor.moveToNext()) { + throw new IllegalStateException("cursor move to previous but can't move back"); + } + } + } + } + + // 以下为获取NoteItemData各项属性的方法 + + public boolean isOneFollowingFolder() { + return mIsOneNoteFollowingFolder; + } + + public boolean isMultiFollowingFolder() { + return mIsMultiNotesFollowingFolder; + } + + public boolean isLast() { + return mIsLastItem; + } + + public String getCallName() { + return mName; + } + + public boolean isFirst() { + return mIsFirstItem; + } + + public boolean isSingle() { + return mIsOnlyOneItem; + } + + public long getId() { + return mId; + } + + public long getAlertDate() { + return mAlertDate; + } + + public long getCreatedDate() { + return mCreatedDate; + } + + public boolean hasAttachment() { + return mHasAttachment; + } + + public long getModifiedDate() { + return mModifiedDate; + } + + public int getBgColorId() { + return mBgColorId; + } + + public long getParentId() { + return mParentId; + } + + public int getNotesCount() { + return mNotesCount; + } + + public long getFolderId() { + return mParentId; + } + + public int getType() { + return mType; + } + + public int getWidgetType() { + return mWidgetType; + } + + public int getWidgetId() { + return mWidgetId; + } + + public String getSnippet() { + return mSnippet; + } + + public boolean hasAlert() { + return (mAlertDate > 0); + } + + public boolean isCallRecord() { + return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber)); + } + + /** + * 从Cursor中获取笔记的类型。 + * + * @param cursor 包含笔记数据的Cursor对象。 + * @return 笔记的类型。 + */ + public static int getNoteType(Cursor cursor) { + return cursor.getInt(TYPE_COLUMN); + } +} + diff --git a/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NotesListActivity.java b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NotesListActivity.java new file mode 100644 index 0000000..b53dfee --- /dev/null +++ b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NotesListActivity.java @@ -0,0 +1,1305 @@ +/* + * 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.app.Dialog; +import android.appwidget.AppWidgetManager; +import android.content.AsyncQueryHandler; +import android.content.ContentResolver; +import android.content.ContentValues; +import android.content.Context; +import android.content.DialogInterface; +import android.content.Intent; +import android.content.SharedPreferences; +import android.database.Cursor; +import android.os.AsyncTask; +import android.os.Bundle; +import android.preference.PreferenceManager; +import android.text.Editable; +import android.text.TextUtils; +import android.text.TextWatcher; +import android.util.Log; +import android.view.ActionMode; +import android.view.ContextMenu; +import android.view.ContextMenu.ContextMenuInfo; +import android.view.Display; +import android.view.HapticFeedbackConstants; +import android.view.LayoutInflater; +import android.view.Menu; +import android.view.MenuItem; +import android.view.MenuItem.OnMenuItemClickListener; +import android.view.MotionEvent; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.View.OnCreateContextMenuListener; +import android.view.View.OnTouchListener; +import android.view.inputmethod.InputMethodManager; +import android.widget.AdapterView; +import android.widget.AdapterView.OnItemClickListener; +import android.widget.AdapterView.OnItemLongClickListener; +import android.widget.Button; +import android.widget.EditText; +import android.widget.ListView; +import android.widget.PopupMenu; +import android.widget.TextView; +import android.widget.Toast; + +import net.micode.notes.R; +import net.micode.notes.data.Notes; +import net.micode.notes.data.Notes.NoteColumns; +import net.micode.notes.gtask.remote.GTaskSyncService; +import net.micode.notes.model.WorkingNote; +import net.micode.notes.tool.BackupUtils; +import net.micode.notes.tool.DataUtils; +import net.micode.notes.tool.ResourceParser; +import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute; +import net.micode.notes.widget.NoteWidgetProvider_2x; +import net.micode.notes.widget.NoteWidgetProvider_4x; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.util.HashSet; + +public class NotesListActivity extends Activity implements OnClickListener, OnItemLongClickListener { + // 定义文件夹中笔记列表查询的标记 + private static final int FOLDER_NOTE_LIST_QUERY_TOKEN = 0; + + // 定义文件夹列表查询的标记 + private static final int FOLDER_LIST_QUERY_TOKEN = 1; + + // 菜单中删除文件夹的选项 + private static final int MENU_FOLDER_DELETE = 0; + + // 菜单中查看文件夹的选项 + private static final int MENU_FOLDER_VIEW = 1; + + // 菜单中更改文件夹名称的选项 + private static final int MENU_FOLDER_CHANGE_NAME = 2; + + // 首次使用应用时，添加介绍信息的偏好设置键 + private static final String PREFERENCE_ADD_INTRODUCTION = "net.micode.notes.introduction"; + + // 列表编辑状态的枚举，包括笔记列表、子文件夹和通话记录文件夹 + private enum ListEditState { + NOTE_LIST, SUB_FOLDER, CALL_RECORD_FOLDER + } + + ; + + // 当前编辑状态 + private ListEditState mState; + + // 后台查询处理器 + private BackgroundQueryHandler mBackgroundQueryHandler; + + // 笔记列表的适配器 + private NotesListAdapter mNotesListAdapter; + + // 笔记列表视图 + private ListView mNotesListView; + + // 添加新笔记的按钮 + private Button mAddNewNote; + + // 是否分发事件的标志 + private boolean mDispatch; + + // 触摸点的原始Y坐标 + private int mOriginY; + + // 分发事件时的Y坐标 + private int mDispatchY; + + // 标题栏文本视图 + private TextView mTitleBar; + + // 当前文件夹的ID + private long mCurrentFolderId; + + // 内容解析器 + private ContentResolver mContentResolver; + + // 模式回调接口 + private ModeCallback mModeCallBack; + + // 日志标签 + private static final String TAG = "NotesListActivity"; + + // 笔记列表视图滚动速率 + public static final int NOTES_LISTVIEW_SCROLL_RATE = 30; + + // 聚焦的笔记数据项 + private NoteItemData mFocusNoteDataItem; + + // 普通文件夹选择条件 + private static final String NORMAL_SELECTION = NoteColumns.PARENT_ID + "=?"; + + // 根文件夹选择条件 + private static final String ROOT_FOLDER_SELECTION = "(" + NoteColumns.TYPE + "<>" + + Notes.TYPE_SYSTEM + " AND " + NoteColumns.PARENT_ID + "=?)" + " OR (" + + NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER + " AND " + + NoteColumns.NOTES_COUNT + ">0)"; + + // 打开节点请求代码 + private final static int REQUEST_CODE_OPEN_NODE = 102; + // 新建节点请求代码 + private final static int REQUEST_CODE_NEW_NODE = 103; + + /** + * 在活动创建时调用，用于初始化资源和设置应用信息。 + * + * @param savedInstanceState 如果活动之前被销毁，这参数包含之前的状态。如果活动没被销毁之前，这参数是null。 + */ + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.note_list); + initResources(); + + // 用户首次使用时插入介绍信息 + setAppInfoFromRawRes(); + } + + /** + * 处理从其他活动返回的结果。 + * + * @param requestCode 启动其他活动时传入的请求代码。 + * @param resultCode 其他活动返回的结果代码。 + * @param data 其他活动返回的数据。 + */ + @Override + protected void onActivityResult(int requestCode, int resultCode, Intent data) { + // 如果返回结果为OK且请求代码为打开节点或新建节点，则刷新列表 + if (resultCode == RESULT_OK + && (requestCode == REQUEST_CODE_OPEN_NODE || requestCode == REQUEST_CODE_NEW_NODE)) { + mNotesListAdapter.changeCursor(null); + } else { + super.onActivityResult(requestCode, resultCode, data); + } + } + + + /** + * 从原始资源中设置应用信息。此方法会读取R.raw.introduction中的内容， + * 并且只有当之前未添加介绍信息时，才将读取到的内容保存为一个工作笔记。 + */ + private void setAppInfoFromRawRes() { + // 获取SharedPreferences实例 + SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this); + // 检查是否已经添加了介绍信息 + if (!sp.getBoolean(PREFERENCE_ADD_INTRODUCTION, false)) { + StringBuilder sb = new StringBuilder(); + InputStream in = null; + try { + // 从资源中打开introduction文件 + in = getResources().openRawResource(R.raw.introduction); + if (in != null) { + // 读取文件内容到StringBuilder + InputStreamReader isr = new InputStreamReader(in); + BufferedReader br = new BufferedReader(isr); + char[] buf = new char[1024]; + int len = 0; + while ((len = br.read(buf)) > 0) { + sb.append(buf, 0, len); + } + } else { + // 打印错误日志，如果无法打开文件 + Log.e(TAG, "Read introduction file error"); + return; + } + } catch (IOException e) { + e.printStackTrace(); + return; + } finally { + // 确保InputStream被关闭 + if (in != null) { + try { + in.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + // 创建一个新的工作笔记并设置其内容 + WorkingNote note = WorkingNote.createEmptyNote(this, Notes.ID_ROOT_FOLDER, + AppWidgetManager.INVALID_APPWIDGET_ID, Notes.TYPE_WIDGET_INVALIDE, + ResourceParser.RED); + note.setWorkingText(sb.toString()); + // 保存工作笔记并标记已添加介绍信息 + if (note.saveNote()) { + sp.edit().putBoolean(PREFERENCE_ADD_INTRODUCTION, true).commit(); + } else { + // 打印错误日志，如果保存工作笔记失败 + Log.e(TAG, "Save introduction note error"); + return; + } + } + } + + /** + * Activity启动时调用，开始异步查询笔记列表。 + */ + @Override + protected void onStart() { + super.onStart(); + startAsyncNotesListQuery(); + } + + /** + * 初始化资源，包括ListView、适配器和其他UI组件。 + */ + private void initResources() { + // 获取ContentResolver实例 + mContentResolver = this.getContentResolver(); + // 创建后台查询处理器 + mBackgroundQueryHandler = new BackgroundQueryHandler(this.getContentResolver()); + mCurrentFolderId = Notes.ID_ROOT_FOLDER; + // 初始化ListView和相关监听器 + mNotesListView = (ListView) findViewById(R.id.notes_list); + mNotesListView.addFooterView(LayoutInflater.from(this).inflate(R.layout.note_list_footer, null), + null, false); + mNotesListView.setOnItemClickListener(new OnListItemClickListener()); + mNotesListView.setOnItemLongClickListener(this); + // 初始化并设置笔记列表适配器 + mNotesListAdapter = new NotesListAdapter(this); + mNotesListView.setAdapter(mNotesListAdapter); + // 初始化新建笔记按钮并设置点击监听器 + mAddNewNote = (Button) findViewById(R.id.btn_new_note); + mAddNewNote.setOnClickListener(this); + mAddNewNote.setOnTouchListener(new NewNoteOnTouchListener()); + // 初始化状态变量和触摸相关的变量 + mDispatch = false; + mDispatchY = 0; + mOriginY = 0; + // 初始化标题栏和其他状态变量 + mTitleBar = (TextView) findViewById(R.id.tv_title_bar); + mState = ListEditState.NOTE_LIST; + mModeCallBack = new ModeCallback(); + } + + + /** + * 用于处理列表的多选择模式和菜单点击事件的回调类。 + */ + private class ModeCallback implements ListView.MultiChoiceModeListener, OnMenuItemClickListener { + private DropdownMenu mDropDownMenu; // 下拉菜单 + private ActionMode mActionMode; // 动作模式 + private MenuItem mMoveMenu; // 移动菜单项 + + /** + * 创建动作模式时的回调方法。 + * + * @param mode 动作模式实例。 + * @param menu 菜单实例。 + * @return 如果成功创建动作模式，返回true；否则返回false。 + */ + public boolean onCreateActionMode(ActionMode mode, Menu menu) { + // 加载菜单项 + getMenuInflater().inflate(R.menu.note_list_options, menu); + // 设置删除项的点击监听器 + menu.findItem(R.id.delete).setOnMenuItemClickListener(this); + mMoveMenu = menu.findItem(R.id.move); + // 根据条件决定是否显示移动菜单项 + if (mFocusNoteDataItem.getParentId() == Notes.ID_CALL_RECORD_FOLDER + || DataUtils.getUserFolderCount(mContentResolver) == 0) { + mMoveMenu.setVisible(false); + } else { + mMoveMenu.setVisible(true); + mMoveMenu.setOnMenuItemClickListener(this); + } + // 初始化动作模式和列表选择模式 + mActionMode = mode; + mNotesListAdapter.setChoiceMode(true); + mNotesListView.setLongClickable(false); + mAddNewNote.setVisibility(View.GONE); + + // 设置自定义视图并初始化下拉菜单 + View customView = LayoutInflater.from(NotesListActivity.this).inflate( + R.layout.note_list_dropdown_menu, null); + mode.setCustomView(customView); + mDropDownMenu = new DropdownMenu(NotesListActivity.this, + (Button) customView.findViewById(R.id.selection_menu), + R.menu.note_list_dropdown); + // 设置下拉菜单项点击监听器 + mDropDownMenu.setOnDropdownMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() { + public boolean onMenuItemClick(MenuItem item) { + mNotesListAdapter.selectAll(!mNotesListAdapter.isAllSelected()); + updateMenu(); + return true; + } + + }); + return true; + } + + /** + * 更新动作模式下的菜单项。 + */ + private void updateMenu() { + int selectedCount = mNotesListAdapter.getSelectedCount(); + // 更新下拉菜单标题 + String format = getResources().getString(R.string.menu_select_title, selectedCount); + mDropDownMenu.setTitle(format); + // 更新“选择全部”菜单项的状态 + MenuItem item = mDropDownMenu.findItem(R.id.action_select_all); + if (item != null) { + if (mNotesListAdapter.isAllSelected()) { + item.setChecked(true); + item.setTitle(R.string.menu_deselect_all); + } else { + item.setChecked(false); + item.setTitle(R.string.menu_select_all); + } + } + } + + /** + * 准备动作模式时的回调方法。 + * + * @param mode 动作模式实例。 + * @param menu 菜单实例。 + * @return 返回false，表示未进行任何操作。 + */ + public boolean onPrepareActionMode(ActionMode mode, Menu menu) { + // TODO Auto-generated method stub + return false; + } + + /** + * 点击动作模式中的菜单项时的回调方法。 + * + * @param mode 动作模式实例。 + * @param item 被点击的菜单项。 + * @return 返回false，表示未进行任何操作。 + */ + public boolean onActionItemClicked(ActionMode mode, MenuItem item) { + // TODO Auto-generated method stub + return false; + } + + /** + * 销毁动作模式时的回调方法。 + * + * @param mode 动作模式实例。 + */ + public void onDestroyActionMode(ActionMode mode) { + // 还原列表选择模式和设置 + mNotesListAdapter.setChoiceMode(false); + mNotesListView.setLongClickable(true); + mAddNewNote.setVisibility(View.VISIBLE); + } + + public void finishActionMode() { + mActionMode.finish(); + } + + /** + * 处理列表项选择状态变化的回调方法。 + * + * @param mode 动作模式实例。 + * @param position 列表中被改变选择状态的项的位置。 + * @param id 项的ID。 + * @param checked 项的新选择状态。 + */ + public void onItemCheckedStateChanged(ActionMode mode, int position, long id, + boolean checked) { + // 更新列表项的选择状态并更新菜单 + mNotesListAdapter.setCheckedItem(position, checked); + updateMenu(); + } + + /** + * 处理菜单项点击事件的回调方法。 + * + * @param item 被点击的菜单项。 + * @return 如果已处理点击事件，返回true；否则返回false。 + */ + public boolean onMenuItemClick(MenuItem item) { + // 若未选择任何项，则显示提示 + if (mNotesListAdapter.getSelectedCount() == 0) { + Toast.makeText(NotesListActivity.this, getString(R.string.menu_select_none), + Toast.LENGTH_SHORT).show(); + return true; + } + + // 根据菜单项ID执行相应操作 + switch (item.getItemId()) { + case R.id.delete: + // 显示删除确认对话框 + AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this); + builder.setTitle(getString(R.string.alert_title_delete)); + builder.setIcon(android.R.drawable.ic_dialog_alert); + builder.setMessage(getString(R.string.alert_message_delete_notes, + mNotesListAdapter.getSelectedCount())); + builder.setPositiveButton(android.R.string.ok, + new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, + int which) { + batchDelete(); + } + }); + builder.setNegativeButton(android.R.string.cancel, null); + builder.show(); + break; + case R.id.move: + // 启动查询目标文件夹的操作 + startQueryDestinationFolders(); + break; + default: + return false; + } + return true; + } + } + + + /** + * 为“新建笔记”按钮添加触摸监听器的内部类，实现点击和拖动事件的处理。 + */ + private class NewNoteOnTouchListener implements OnTouchListener { + + /** + * 处理触摸事件。 + * + * @param v 触摸的视图。 + * @param event 触摸事件。 + * @return 如果事件被处理则返回true，否则返回false。 + */ + public boolean onTouch(View v, MotionEvent event) { + // 根据触摸事件的动作进行不同的处理 + switch (event.getAction()) { + case MotionEvent.ACTION_DOWN: { + // 获取屏幕高度和“新建笔记”视图的高度 + Display display = getWindowManager().getDefaultDisplay(); + int screenHeight = display.getHeight(); + int newNoteViewHeight = mAddNewNote.getHeight(); + int start = screenHeight - newNoteViewHeight; + int eventY = start + (int) event.getY(); + // 如果当前状态为子文件夹编辑状态，需减去标题栏的高度 + if (mState == ListEditState.SUB_FOLDER) { + eventY -= mTitleBar.getHeight(); + start -= mTitleBar.getHeight(); + } + // 当点击到“新建笔记”按钮透明部分时，将事件分发给背后的列表视图 + // 这里使用了一种硬编码的方式处理透明部分的点击，依赖于当前的背景公式 + if (event.getY() < (event.getX() * (-0.12) + 94)) { + View view = mNotesListView.getChildAt(mNotesListView.getChildCount() - 1 + - mNotesListView.getFooterViewsCount()); + if (view != null && view.getBottom() > start + && (view.getTop() < (start + 94))) { + mOriginY = (int) event.getY(); + mDispatchY = eventY; + event.setLocation(event.getX(), mDispatchY); + mDispatch = true; + return mNotesListView.dispatchTouchEvent(event); + } + } + break; + } + case MotionEvent.ACTION_MOVE: { + // 如果正在分发触摸事件，则更新事件的位置并继续分发 + if (mDispatch) { + mDispatchY += (int) event.getY() - mOriginY; + event.setLocation(event.getX(), mDispatchY); + return mNotesListView.dispatchTouchEvent(event); + } + break; + } + default: { + // 当触摸动作结束或取消时，停止分发事件 + if (mDispatch) { + event.setLocation(event.getX(), mDispatchY); + mDispatch = false; + return mNotesListView.dispatchTouchEvent(event); + } + break; + } + } + // 如果事件未被分发，则返回false + return false; + } + + } + + ; + + + /** + * 异步查询笔记列表。 + * 根据当前文件夹ID选择不同的查询条件，启动一个后台查询处理该查询。 + */ + private void startAsyncNotesListQuery() { + // 根据当前文件夹ID选择查询条件 + String selection = (mCurrentFolderId == Notes.ID_ROOT_FOLDER) ? ROOT_FOLDER_SELECTION + : NORMAL_SELECTION; + // 启动查询，排序方式为类型降序，修改日期降序 + mBackgroundQueryHandler.startQuery(FOLDER_NOTE_LIST_QUERY_TOKEN, null, + Notes.CONTENT_NOTE_URI, NoteItemData.PROJECTION, selection, new String[]{ + String.valueOf(mCurrentFolderId) + }, NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC"); + } + + /** + * 处理后台查询的类。 + * 继承自AsyncQueryHandler，用于处理异步查询完成后的操作。 + */ + private final class BackgroundQueryHandler extends AsyncQueryHandler { + public BackgroundQueryHandler(ContentResolver contentResolver) { + super(contentResolver); + } + + /** + * 查询完成时的处理逻辑。 + * 根据查询标记的不同，执行不同的操作，如更新笔记列表或显示文件夹列表。 + * + * @param token 查询标记，用于区分不同的查询。 + * @param cookie 查询时传入的附加对象。 + * @param cursor 查询结果的游标。 + */ + @Override + protected void onQueryComplete(int token, Object cookie, Cursor cursor) { + switch (token) { + case FOLDER_NOTE_LIST_QUERY_TOKEN: + // 更新笔记列表适配器的数据源 + mNotesListAdapter.changeCursor(cursor); + break; + case FOLDER_LIST_QUERY_TOKEN: + // 根据查询结果展示或记录错误 + if (cursor != null && cursor.getCount() > 0) { + showFolderListMenu(cursor); + } else { + Log.e(TAG, "Query folder failed"); + } + break; + default: + // 对未知标记不做处理 + return; + } + } + } + + /** + * 显示文件夹列表的菜单。 + * 使用查询结果构建一个对话框，让用户选择一个文件夹。 + * + * @param cursor 查询结果的游标，包含文件夹信息。 + */ + private void showFolderListMenu(Cursor cursor) { + // 构建文件夹列表选择的对话框 + AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this); + builder.setTitle(R.string.menu_title_select_folder); + final FoldersListAdapter adapter = new FoldersListAdapter(this, cursor); + builder.setAdapter(adapter, new DialogInterface.OnClickListener() { + + /** + * 用户选择文件夹时的处理逻辑。 + * 将选中的笔记移动到用户选择的文件夹中，并给出反馈。 + * + * @param dialog 对话框实例。 + * @param which 用户选择的项的索引。 + */ + public void onClick(DialogInterface dialog, int which) { + // 批量移动选中的笔记到目标文件夹 + DataUtils.batchMoveToFolder(mContentResolver, + mNotesListAdapter.getSelectedItemIds(), adapter.getItemId(which)); + // 显示移动操作的反馈信息 + Toast.makeText( + NotesListActivity.this, + getString(R.string.format_move_notes_to_folder, + mNotesListAdapter.getSelectedCount(), + adapter.getFolderName(NotesListActivity.this, which)), + Toast.LENGTH_SHORT).show(); + // 结束当前的操作模式 + mModeCallBack.finishActionMode(); + } + }); + builder.show(); + } + + /** + * 创建新的笔记。 + * 启动一个活动用于编辑新笔记或编辑现有笔记。 + */ + private void createNewNote() { + // 构建意图并指定动作为插入或编辑，以及初始文件夹ID + Intent intent = new Intent(this, NoteEditActivity.class); + intent.setAction(Intent.ACTION_INSERT_OR_EDIT); + intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mCurrentFolderId); + // 启动该意图并期待返回结果 + this.startActivityForResult(intent, REQUEST_CODE_NEW_NODE); + } + + + /** + * 批量删除笔记的函数。根据当前是否处于同步模式，采取不同的删除策略：如果不处于同步模式，则直接删除笔记；如果处于同步模式，则将笔记移动到回收站文件夹。 + * 执行删除操作后，会更新相应的widgets。 + */ + private void batchDelete() { + new AsyncTask>() { + // 在后台执行任务，获取选中的widgets并执行删除操作 + protected HashSet doInBackground(Void... unused) { + // 获取当前选中的widgets + 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"); + } + } + return widgets; + } + + // 删除操作完成后，在UI线程执行后续操作 + @Override + protected void onPostExecute(HashSet widgets) { + // 遍历所有受影响的widgets，对有效的widgets进行更新 + if (widgets != null) { + for (AppWidgetAttribute widget : widgets) { + if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID + && widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) { + // 更新有效的widget + updateWidget(widget.widgetId, widget.widgetType); + } + } + } + // 结束动作模式 + mModeCallBack.finishActionMode(); + } + }.execute(); + } + + + /** + * 删除指定的文件夹。 + * 如果是在同步模式下，文件夹会被移动到回收站，否则直接删除。 + * 同时，也会更新与该文件夹相关的所有小部件。 + * + * @param folderId 要删除的文件夹ID。 + */ + private void deleteFolder(long folderId) { + // 根据ID判断是否为根文件夹，根文件夹不能被删除 + if (folderId == Notes.ID_ROOT_FOLDER) { + Log.e(TAG, "Wrong folder id, should not happen " + folderId); + return; + } + + HashSet ids = new HashSet(); + ids.add(folderId); + + // 获取与文件夹相关联的小部件信息 + 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) { + // 有效的小部件才进行更新 + if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID + && widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) { + updateWidget(widget.widgetId, widget.widgetType); + } + } + } + } + + /** + * 打开指定的笔记节点进行编辑。 + * + * @param data 包含要打开的笔记节点信息的对象。 + */ + private void openNode(NoteItemData data) { + // 构造Intent并设置动作和额外数据，然后启动Activity + Intent intent = new Intent(this, NoteEditActivity.class); + intent.setAction(Intent.ACTION_VIEW); + intent.putExtra(Intent.EXTRA_UID, data.getId()); + this.startActivityForResult(intent, REQUEST_CODE_OPEN_NODE); + } + + /** + * 打开指定的文件夹，并加载其笔记列表。 + * 根据文件夹ID的不同，更新UI状态，包括标题和新增笔记按钮的可见性。 + * + * @param data 包含要打开的文件夹信息的对象。 + */ + private void openFolder(NoteItemData data) { + // 设置当前文件夹ID并启动异步查询 + mCurrentFolderId = data.getId(); + startAsyncNotesListQuery(); + + // 根据文件夹ID更新UI状态 + if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) { + mState = ListEditState.CALL_RECORD_FOLDER; + mAddNewNote.setVisibility(View.GONE); + } else { + mState = ListEditState.SUB_FOLDER; + } + + // 更新标题栏显示 + if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) { + mTitleBar.setText(R.string.call_record_folder_name); + } else { + mTitleBar.setText(data.getSnippet()); + } + mTitleBar.setVisibility(View.VISIBLE); + } + + /** + * 点击事件的处理方法。 + * 目前仅处理新建笔记按钮的点击事件。 + * + * @param v 被点击的视图对象。 + */ + public void onClick(View v) { + // 根据视图ID执行相应的操作 + switch (v.getId()) { + case R.id.btn_new_note: + createNewNote(); + break; + default: + break; + } + } + + + /** + * 显示软键盘。 + */ + private void showSoftInput() { + InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); + if (inputMethodManager != null) { + inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0); + } + } + + /** + * 隐藏软键盘。 + * + * @param view 触发隐藏软键盘的视图。 + */ + private void hideSoftInput(View view) { + InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); + inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0); + } + + /** + * 显示创建或修改文件夹的对话框。 + * + * @param create 如果为true，则为创建文件夹；如果为false，则为修改文件夹。 + */ + private void showCreateOrModifyFolderDialog(final boolean create) { + final AlertDialog.Builder builder = new AlertDialog.Builder(this); + View view = LayoutInflater.from(this).inflate(R.layout.dialog_edit_text, null); + final EditText etName = (EditText) view.findViewById(R.id.et_foler_name); + showSoftInput(); // 显示软键盘 + + if (!create) { + // 如果是修改文件夹 + if (mFocusNoteDataItem != null) { + etName.setText(mFocusNoteDataItem.getSnippet()); // 设置当前文件夹名称 + builder.setTitle(getString(R.string.menu_folder_change_name)); // 设置对话框标题 + } else { + Log.e(TAG, "The long click data item is null"); // 日志记录，长按的数据项为null + return; + } + } else { + // 如果是创建文件夹 + etName.setText(""); // 清空输入框内容 + builder.setTitle(this.getString(R.string.menu_create_folder)); // 设置对话框标题 + } + + // 设置对话框的确定和取消按钮 + builder.setPositiveButton(android.R.string.ok, null); + builder.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int which) { + hideSoftInput(etName); // 点击取消时隐藏软键盘 + } + }); + + final Dialog dialog = builder.setView(view).show(); // 显示对话框 + final Button positive = (Button) dialog.findViewById(android.R.id.button1); // 获取确定按钮 + positive.setOnClickListener(new OnClickListener() { + public void onClick(View v) { + hideSoftInput(etName); // 隐藏软键盘 + String name = etName.getText().toString(); // 获取输入的文件夹名称 + if (DataUtils.checkVisibleFolderName(mContentResolver, name)) { // 检查文件夹名称是否已存在 + Toast.makeText(NotesListActivity.this, getString(R.string.folder_exist, name), + Toast.LENGTH_LONG).show(); // 显示文件夹已存在的提示 + etName.setSelection(0, etName.length()); // 选中输入框中的所有文本 + return; + } + if (!create) { + // 如果是修改文件夹 + if (!TextUtils.isEmpty(name)) { // 验证输入的文件夹名称不为空 + ContentValues values = new ContentValues(); + values.put(NoteColumns.SNIPPET, name); // 设置新的文件夹名称 + values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER); // 设置类型为文件夹 + values.put(NoteColumns.LOCAL_MODIFIED, 1); // 标记为已修改 + mContentResolver.update(Notes.CONTENT_NOTE_URI, values, NoteColumns.ID + + "=?", new String[]{ + String.valueOf(mFocusNoteDataItem.getId()) + }); // 更新数据库中的文件夹信息 + } + } else if (!TextUtils.isEmpty(name)) { // 如果是创建文件夹 + ContentValues values = new ContentValues(); + values.put(NoteColumns.SNIPPET, name); // 设置文件夹名称 + values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER); // 设置类型为文件夹 + mContentResolver.insert(Notes.CONTENT_NOTE_URI, values); // 在数据库中插入新的文件夹信息 + } + dialog.dismiss(); // 关闭对话框 + } + }); + + // 初始状态下，如果输入框为空，则禁用确定按钮 + if (TextUtils.isEmpty(etName.getText())) { + positive.setEnabled(false); + } + + // 监听输入框文本变化，以动态启用或禁用确定按钮 + etName.addTextChangedListener(new TextWatcher() { + public void beforeTextChanged(CharSequence s, int start, int count, int after) { + // 空实现 + } + + public void onTextChanged(CharSequence s, int start, int before, int count) { + if (TextUtils.isEmpty(etName.getText())) { // 当输入框为空时，禁用确定按钮 + positive.setEnabled(false); + } else { // 当输入框不为空时，启用确定按钮 + positive.setEnabled(true); + } + } + + public void afterTextChanged(Editable s) { + // 空实现 + } + }); + } + + + /** + * 当用户按下返回键时调用的方法，根据当前状态执行不同的操作。 + * 在子文件夹状态下，返回根文件夹并显示笔记列表； + * 在通话记录文件夹状态下，也返回根文件夹但显示添加新笔记按钮； + * 在笔记列表状态下，执行父类的onBackPressed方法，通常是退出或返回上一级。 + */ + @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; + } + } + + /** + * 更新小部件显示。 + * 根据传入的小部件类型，设置对应的Provider并发送更新广播。 + * + * @param appWidgetId 小部件ID + * @param appWidgetType 小部件类型 + */ + private void updateWidget(int appWidgetId, int appWidgetType) { + Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE); + // 根据小部件类型设置Provider + if (appWidgetType == Notes.TYPE_WIDGET_2X) { + intent.setClass(this, NoteWidgetProvider_2x.class); + } else if (appWidgetType == Notes.TYPE_WIDGET_4X) { + intent.setClass(this, NoteWidgetProvider_4x.class); + } else { + Log.e(TAG, "Unspported widget type"); + return; + } + + intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[]{ + appWidgetId + }); + + sendBroadcast(intent); + setResult(RESULT_OK, intent); + } + + /** + * 文件夹列表的上下文菜单创建监听器。 + * 在焦点笔记项不为空时，添加查看、删除和重命名菜单项。 + */ + private final OnCreateContextMenuListener mFolderOnCreateContextMenuListener = new OnCreateContextMenuListener() { + public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) { + if (mFocusNoteDataItem != null) { + menu.setHeaderTitle(mFocusNoteDataItem.getSnippet()); + menu.add(0, MENU_FOLDER_VIEW, 0, R.string.menu_folder_view); + menu.add(0, MENU_FOLDER_DELETE, 0, R.string.menu_folder_delete); + menu.add(0, MENU_FOLDER_CHANGE_NAME, 0, R.string.menu_folder_change_name); + } + } + }; + + /** + * 上下文菜单关闭时的回调方法。 + * 在列表视图中取消上下文菜单的监听器。 + * + * @param menu 被关闭的菜单对象 + */ + @Override + public void onContextMenuClosed(Menu menu) { + if (mNotesListView != null) { + mNotesListView.setOnCreateContextMenuListener(null); + } + super.onContextMenuClosed(menu); + } + + + /** + * 当上下文菜单中的项目被选择时调用。 + * + * @param item 被选择的菜单项。 + * @return 如果事件已成功处理，则返回true；否则如果事件未处理，则返回false。 + */ + @Override + public boolean onContextItemSelected(MenuItem item) { + if (mFocusNoteDataItem == null) { + Log.e(TAG, "The long click data item is null"); + return false; + } + switch (item.getItemId()) { + case MENU_FOLDER_VIEW: + openFolder(mFocusNoteDataItem); // 打开指定的文件夹 + break; + case MENU_FOLDER_DELETE: + // 显示删除文件夹的确认对话框 + AlertDialog.Builder builder = new AlertDialog.Builder(this); + builder.setTitle(getString(R.string.alert_title_delete)); + builder.setIcon(android.R.drawable.ic_dialog_alert); + builder.setMessage(getString(R.string.alert_message_delete_folder)); + builder.setPositiveButton(android.R.string.ok, + new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int which) { + deleteFolder(mFocusNoteDataItem.getId()); // 确认后删除文件夹 + } + }); + builder.setNegativeButton(android.R.string.cancel, null); + builder.show(); + break; + case MENU_FOLDER_CHANGE_NAME: + showCreateOrModifyFolderDialog(false); // 显示修改文件夹名称的对话框 + break; + default: + break; + } + + return true; + } + + /** + * 准备选项菜单。 + * + * @param menu 菜单对象。 + * @return 总是返回true。 + */ + @Override + public boolean onPrepareOptionsMenu(Menu menu) { + menu.clear(); // 清除之前的菜单项 + // 根据当前状态加载不同的菜单布局 + if (mState == ListEditState.NOTE_LIST) { + getMenuInflater().inflate(R.menu.note_list, menu); + // 设置同步或取消同步菜单项的标题 + menu.findItem(R.id.menu_sync).setTitle( + GTaskSyncService.isSyncing() ? R.string.menu_sync_cancel : R.string.menu_sync); + } else if (mState == ListEditState.SUB_FOLDER) { + getMenuInflater().inflate(R.menu.sub_folder, menu); + } else if (mState == ListEditState.CALL_RECORD_FOLDER) { + getMenuInflater().inflate(R.menu.call_record_folder, menu); + } else { + Log.e(TAG, "Wrong state:" + mState); + } + return true; + } + + /** + * 处理选项菜单项的选择。 + * + * @param item 被选择的菜单项。 + * @return 如果事件已成功处理，则返回true；否则如果事件未处理，则返回false。 + */ + @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; + } + + /** + * 处理搜索请求。 + * + * @return 总是返回true。 + */ + @Override + public boolean onSearchRequested() { + startSearch(null, false, null /* appData */, false); + return true; + } + + + /** + * 将笔记导出为文本文件。 + * 在后台任务中执行导出操作，并根据操作结果展示不同的对话框。 + */ + private void exportNoteToText() { + final BackupUtils backup = BackupUtils.getInstance(NotesListActivity.this); + new AsyncTask() { + + @Override + protected Integer doInBackground(Void... unused) { + // 执行导出操作 + return backup.exportToText(); + } + + @Override + protected void onPostExecute(Integer result) { + // 根据导出结果展示不同的对话框 + if (result == BackupUtils.STATE_SD_CARD_UNMOUONTED) { + showExportFailedDialog(NotesListActivity.this.getString(R.string.failed_sdcard_export), + NotesListActivity.this.getString(R.string.error_sdcard_unmounted)); + } else if (result == BackupUtils.STATE_SUCCESS) { + showExportSuccessDialog(NotesListActivity.this.getString(R.string.success_sdcard_export), + backup.getExportedTextFileName(), backup.getExportedTextFileDir()); + } else if (result == BackupUtils.STATE_SYSTEM_ERROR) { + showExportFailedDialog(NotesListActivity.this.getString(R.string.failed_sdcard_export), + NotesListActivity.this.getString(R.string.error_sdcard_export)); + } + } + + }.execute(); + } + + /** + * 检查当前是否为同步模式。 + * + * @return 如果已配置同步账户名则返回true，否则返回false。 + */ + private boolean isSyncMode() { + return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0; + } + + /** + * 启动设置活动。 + * 用于打开设置界面。 + */ + private void startPreferenceActivity() { + Activity from = getParent() != null ? getParent() : this; + Intent intent = new Intent(from, NotesPreferenceActivity.class); + from.startActivityIfNeeded(intent, -1); + } + + /** + * 列表项点击监听器。 + * 处理列表项的点击事件，根据不同的状态和项类型执行相应的操作。 + */ + private class OnListItemClickListener implements OnItemClickListener { + + public void onItemClick(AdapterView parent, View view, int position, long id) { + if (view instanceof NotesListItem) { + NoteItemData item = ((NotesListItem) view).getItemData(); + if (mNotesListAdapter.isInChoiceMode()) { + // 在选择模式下处理项的点击事件 + if (item.getType() == Notes.TYPE_NOTE) { + position = position - mNotesListView.getHeaderViewsCount(); + mModeCallBack.onItemCheckedStateChanged(null, position, id, + !mNotesListAdapter.isSelectedItem(position)); + } + return; + } + + // 根据当前状态处理项的点击事件 + switch (mState) { + case NOTE_LIST: + if (item.getType() == Notes.TYPE_FOLDER + || item.getType() == Notes.TYPE_SYSTEM) { + openFolder(item); + } else if (item.getType() == Notes.TYPE_NOTE) { + openNode(item); + } else { + Log.e(TAG, "Wrong note type in NOTE_LIST"); + } + break; + case SUB_FOLDER: + case CALL_RECORD_FOLDER: + if (item.getType() == Notes.TYPE_NOTE) { + openNode(item); + } else { + Log.e(TAG, "Wrong note type in SUB_FOLDER"); + } + break; + default: + break; + } + } + } + + } + + /** + * 启动查询目标文件夹。 + * 根据当前状态查询并显示文件夹列表。 + */ + private void startQueryDestinationFolders() { + String selection = NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>? AND " + NoteColumns.ID + "<>?"; + selection = (mState == ListEditState.NOTE_LIST) ? selection : + "(" + selection + ") OR (" + NoteColumns.ID + "=" + Notes.ID_ROOT_FOLDER + ")"; + + mBackgroundQueryHandler.startQuery(FOLDER_LIST_QUERY_TOKEN, + null, + Notes.CONTENT_NOTE_URI, + FoldersListAdapter.PROJECTION, + selection, + new String[]{ + String.valueOf(Notes.TYPE_FOLDER), + String.valueOf(Notes.ID_TRASH_FOLER), + String.valueOf(mCurrentFolderId) + }, + NoteColumns.MODIFIED_DATE + " DESC"); + } + + /** + * 长按列表项时的处理。 + * 根据不同的项类型启动选择模式或显示上下文菜单。 + * + * @return 总是返回false。 + */ + public boolean onItemLongClick(AdapterView parent, View view, int position, long id) { + if (view instanceof NotesListItem) { + mFocusNoteDataItem = ((NotesListItem) view).getItemData(); + if (mFocusNoteDataItem.getType() == Notes.TYPE_NOTE && !mNotesListAdapter.isInChoiceMode()) { + // 长按笔记项时启动选择模式 + if (mNotesListView.startActionMode(mModeCallBack) != null) { + mModeCallBack.onItemCheckedStateChanged(null, position, id, true); + mNotesListView.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS); + } else { + Log.e(TAG, "startActionMode fails"); + } + } else if (mFocusNoteDataItem.getType() == Notes.TYPE_FOLDER) { + // 长按文件夹项时设置上下文菜单监听器 + mNotesListView.setOnCreateContextMenuListener(mFolderOnCreateContextMenuListener); + } + } + return false; + } + + /** + * 显示导出失败的对话框。 + * + * @param title 对话框标题 + * @param message 对话框消息内容 + */ + private void showExportFailedDialog(String title, String message) { + AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this); + builder.setTitle(title); + builder.setMessage(message); + builder.setPositiveButton(android.R.string.ok, null); + builder.show(); + } + + /** + * 显示导出成功的对话框。 + * + * @param title 对话框标题 + * @param fileName 导出文件的名称 + * @param fileDir 导出文件的目录 + */ + private void showExportSuccessDialog(String title, String fileName, String fileDir) { + AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this); + builder.setTitle(title); + builder.setMessage(NotesListActivity.this.getString(R.string.format_exported_file_location, fileName, fileDir)); + builder.setPositiveButton(android.R.string.ok, null); + builder.show(); + } + +} diff --git a/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NotesListAdapter.java b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NotesListAdapter.java new file mode 100644 index 0000000..057de6a --- /dev/null +++ b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NotesListAdapter.java @@ -0,0 +1,269 @@ +/* + * 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.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; + + +/** + * 用于管理笔记列表的适配器，继承自CursorAdapter。 + */ +public class NotesListAdapter extends CursorAdapter { + private static final String TAG = "NotesListAdapter"; + private Context mContext; + // 用于存储选中项的索引和状态 + private HashMap mSelectedIndex; + private int mNotesCount; // 笔记总数 + private boolean mChoiceMode; // 选择模式标志 + + /** + * AppWidget属性容器，用于存储与小部件相关的数据。 + */ + public static class AppWidgetAttribute { + public int widgetId; // 小部件ID + public int widgetType; // 小部件类型 + } + + ; + + /** + * 构造函数。 + * + * @param context 上下文对象 + */ + public NotesListAdapter(Context context) { + super(context, null); + mSelectedIndex = new HashMap(); + mContext = context; + mNotesCount = 0; + } + + /** + * 创建新的列表项视图。 + * + * @param context 上下文对象 + * @param cursor 数据游标 + * @param parent 父视图 + * @return 新的列表项视图 + */ + @Override + public View newView(Context context, Cursor cursor, ViewGroup parent) { + return new NotesListItem(context); + } + + /** + * 绑定数据到视图。 + * + * @param view 列表项视图 + * @param context 上下文对象 + * @param cursor 数据游标 + */ + @Override + public void bindView(View view, Context context, Cursor cursor) { + if (view instanceof NotesListItem) { + NoteItemData itemData = new NoteItemData(context, cursor); + ((NotesListItem) view).bind(context, itemData, mChoiceMode, + isSelectedItem(cursor.getPosition())); + } + } + + /** + * 设置指定位置的项为选中或未选中状态。 + * + * @param position 项的位置 + * @param checked 选中状态 + */ + public void setCheckedItem(final int position, final boolean checked) { + mSelectedIndex.put(position, checked); + notifyDataSetChanged(); + } + + /** + * 获取当前是否处于选择模式。 + * + * @return 选择模式状态 + */ + public boolean isInChoiceMode() { + return mChoiceMode; + } + + /** + * 设置选择模式。 + * + * @param mode 选择模式状态 + */ + public void setChoiceMode(boolean mode) { + mSelectedIndex.clear(); + mChoiceMode = mode; + } + + /** + * 全选或全不选。 + * + * @param checked 选中状态 + */ + public void selectAll(boolean checked) { + Cursor cursor = getCursor(); + for (int i = 0; i < getCount(); i++) { + if (cursor.moveToPosition(i)) { + if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) { + setCheckedItem(i, checked); + } + } + } + } + + /** + * 获取所有选中项的ID集合。 + * + * @return 选中项ID的HashSet + */ + public HashSet getSelectedItemIds() { + HashSet itemSet = new HashSet(); + for (Integer position : mSelectedIndex.keySet()) { + if (mSelectedIndex.get(position) == true) { + Long id = getItemId(position); + if (id == Notes.ID_ROOT_FOLDER) { + Log.d(TAG, "Wrong item id, should not happen"); + } else { + itemSet.add(id); + } + } + } + + return itemSet; + } + + /** + * 获取所有选中小部件的属性集合。 + * + * @return 选中小部件属性的HashSet + */ + public HashSet getSelectedWidget() { + HashSet itemSet = new HashSet(); + for (Integer position : mSelectedIndex.keySet()) { + if (mSelectedIndex.get(position) == true) { + Cursor c = (Cursor) getItem(position); + if (c != null) { + AppWidgetAttribute widget = new AppWidgetAttribute(); + NoteItemData item = new NoteItemData(mContext, c); + widget.widgetId = item.getWidgetId(); + widget.widgetType = item.getWidgetType(); + itemSet.add(widget); + } else { + Log.e(TAG, "Invalid cursor"); + return null; + } + } + } + return itemSet; + } + + /** + * 获取选中项的数量。 + * + * @return 选中项数量 + */ + public int getSelectedCount() { + Collection values = mSelectedIndex.values(); + if (null == values) { + return 0; + } + Iterator iter = values.iterator(); + int count = 0; + while (iter.hasNext()) { + if (true == iter.next()) { + count++; + } + } + return count; + } + + /** + * 判断是否全部选中。 + * + * @return 全部选中的状态 + */ + public boolean isAllSelected() { + int checkedCount = getSelectedCount(); + return (checkedCount != 0 && checkedCount == mNotesCount); + } + + /** + * 检查指定位置的项是否被选中。 + * + * @param position 项的位置 + * @return 选中状态 + */ + public boolean isSelectedItem(final int position) { + if (null == mSelectedIndex.get(position)) { + return false; + } + return mSelectedIndex.get(position); + } + + /** + * 当内容改变时调用，更新笔记数量。 + */ + @Override + protected void onContentChanged() { + super.onContentChanged(); + calcNotesCount(); + } + + /** + * 当游标改变时调用，更新笔记数量。 + * + * @param cursor 新的游标 + */ + @Override + public void changeCursor(Cursor cursor) { + super.changeCursor(cursor); + calcNotesCount(); + } + + /** + * 计算并更新笔记总数。 + */ + private void calcNotesCount() { + mNotesCount = 0; + for (int i = 0; i < getCount(); i++) { + Cursor c = (Cursor) getItem(i); + if (c != null) { + if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) { + mNotesCount++; + } + } else { + Log.e(TAG, "Invalid cursor"); + return; + } + } + } +} + diff --git a/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NotesListItem.java b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NotesListItem.java new file mode 100644 index 0000000..1e53b26 --- /dev/null +++ b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NotesListItem.java @@ -0,0 +1,157 @@ +/* + * 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.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; +import net.micode.notes.data.Notes; +import net.micode.notes.tool.DataUtils; +import net.micode.notes.tool.ResourceParser.NoteItemBgResources; + + +/* + * 该类表示一个笔记列表项，继承自LinearLayout，并包含了显示笔记各种信息的组件。 + * 它用于在UI中展示一个笔记或文件夹的条目。 + */ + +public class NotesListItem extends LinearLayout { + private ImageView mAlert; // 用于显示提醒图标 + private TextView mTitle; // 显示笔记标题 + private TextView mTime; // 显示修改时间 + private TextView mCallName; // 在通话记录笔记中显示通话名称 + private NoteItemData mItemData; // 绑定的笔记数据 + private CheckBox mCheckBox; // 选择框，用于多选模式 + + /* + * 构造函数，初始化视图组件。 + */ + public NotesListItem(Context context) { + super(context); + inflate(context, R.layout.note_item, this); + // 初始化视图组件 + mAlert = (ImageView) findViewById(R.id.iv_alert_icon); + mTitle = (TextView) findViewById(R.id.tv_title); + mTime = (TextView) findViewById(R.id.tv_time); + mCallName = (TextView) findViewById(R.id.tv_name); + mCheckBox = (CheckBox) findViewById(android.R.id.checkbox); + } + + /* + * 绑定数据到视图，根据数据设置视图状态。 + * + * @param context 上下文 + * @param data 要绑定的笔记数据 + * @param choiceMode 是否为选择模式 + * @param checked 是否选中 + */ + public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) { + // 根据是否为选择模式和笔记类型，控制复选框的可见性和选中状态 + if (choiceMode && data.getType() == Notes.TYPE_NOTE) { + mCheckBox.setVisibility(View.VISIBLE); + mCheckBox.setChecked(checked); + } else { + mCheckBox.setVisibility(View.GONE); + } + + mItemData = data; + // 根据笔记类型和状态，设置标题、提醒图标和背景 + if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) { + // 通话记录文件夹 + mCallName.setVisibility(View.GONE); + mAlert.setVisibility(View.VISIBLE); + mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem); + mTitle.setText(context.getString(R.string.call_record_folder_name) + + context.getString(R.string.format_folder_files_count, data.getNotesCount())); + mAlert.setImageResource(R.drawable.call_record); + } else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) { + // 通话记录笔记 + mCallName.setVisibility(View.VISIBLE); + mCallName.setText(data.getCallName()); + mTitle.setTextAppearance(context, R.style.TextAppearanceSecondaryItem); + mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet())); + if (data.hasAlert()) { + mAlert.setImageResource(R.drawable.clock); + mAlert.setVisibility(View.VISIBLE); + } else { + mAlert.setVisibility(View.GONE); + } + } else { + // 其他类型的笔记或文件夹 + mCallName.setVisibility(View.GONE); + mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem); + + if (data.getType() == Notes.TYPE_FOLDER) { + mTitle.setText(data.getSnippet() + + context.getString(R.string.format_folder_files_count, + data.getNotesCount())); + mAlert.setVisibility(View.GONE); + } else { + mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet())); + if (data.hasAlert()) { + mAlert.setImageResource(R.drawable.clock); + mAlert.setVisibility(View.VISIBLE); + } else { + mAlert.setVisibility(View.GONE); + } + } + } + // 设置时间显示 + mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate())); + + // 设置背景资源 + setBackground(data); + } + + /* + * 根据笔记数据设置列表项的背景资源。 + */ + private void setBackground(NoteItemData data) { + int id = data.getBgColorId(); + 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()); + } + } + + /* + * 获取绑定的笔记数据。 + * + * @return 绑定的NoteItemData对象 + */ + public NoteItemData getItemData() { + return mItemData; + } +} + diff --git a/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NotesPreferenceActivity.java b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NotesPreferenceActivity.java new file mode 100644 index 0000000..76640bc --- /dev/null +++ b/src/HwFrameWorkSource-master/HwFrameWorkSource-master/Mate10_8_1_0/NotesPreferenceActivity.java @@ -0,0 +1,481 @@ +/* + * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package net.micode.notes.ui; + +import android.accounts.Account; +import android.accounts.AccountManager; +import android.app.ActionBar; +import android.app.AlertDialog; +import android.content.BroadcastReceiver; +import android.content.ContentValues; +import android.content.Context; +import android.content.DialogInterface; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.SharedPreferences; +import android.os.Bundle; +import android.preference.Preference; +import android.preference.Preference.OnPreferenceClickListener; +import android.preference.PreferenceActivity; +import android.preference.PreferenceCategory; +import android.text.TextUtils; +import android.text.format.DateFormat; +import android.view.LayoutInflater; +import android.view.Menu; +import android.view.MenuItem; +import android.view.View; +import android.widget.Button; +import android.widget.TextView; +import android.widget.Toast; + +import net.micode.notes.R; +import net.micode.notes.data.Notes; +import net.micode.notes.data.Notes.NoteColumns; +import net.micode.notes.gtask.remote.GTaskSyncService; + + +public class NotesPreferenceActivity extends PreferenceActivity { + // 常量定义部分：主要用于设置和同步相关的偏好设置键 + public static final String PREFERENCE_NAME = "notes_preferences"; // 偏好设置的名称 + public static final String PREFERENCE_SYNC_ACCOUNT_NAME = "pref_key_account_name"; // 同步账户名称的键 + public static final String PREFERENCE_LAST_SYNC_TIME = "pref_last_sync_time"; // 上次同步时间的键 + public static final String PREFERENCE_SET_BG_COLOR_KEY = "pref_key_bg_random_appear"; // 设置背景颜色的键 + private static final String PREFERENCE_SYNC_ACCOUNT_KEY = "pref_sync_account_key"; // 同步账户的键 + private static final String AUTHORITIES_FILTER_KEY = "authorities"; // 权限过滤键 + + // 类成员变量定义部分：主要用于账户同步和UI更新 + private PreferenceCategory mAccountCategory; // 账户分类偏好项 + private GTaskReceiver mReceiver; // 接收同步任务的广播接收器 + private Account[] mOriAccounts; // 原始账户数组 + private boolean mHasAddedAccount; // 标记是否已添加新账户 + + /** + * 当设置Activity创建时调用。 + * 主要进行界面初始化和设置账户同步。 + * + * @param icicle 保存Activity状态的Bundle，用于恢复状态。 + */ + @Override + protected void onCreate(Bundle icicle) { + super.onCreate(icicle); + + // 设置返回按钮 + getActionBar().setDisplayHomeAsUpEnabled(true); + + // 从XML加载偏好设置 + addPreferencesFromResource(R.xml.preferences); + mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY); + mReceiver = new GTaskReceiver(); + IntentFilter filter = new IntentFilter(); + filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME); + registerReceiver(mReceiver, filter); // 注册广播接收器以监听同步服务 + + mOriAccounts = null; + // 添加设置头部视图 + View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null); + getListView().addHeaderView(header, null, true); + } + + /** + * 当设置Activity恢复到前台时调用。 + * 主要用于检查并自动设置新添加的账户进行同步。 + */ + @Override + protected void onResume() { + super.onResume(); + + // 自动设置新添加的账户进行同步 + if (mHasAddedAccount) { + Account[] accounts = getGoogleAccounts(); + if (mOriAccounts != null && accounts.length > mOriAccounts.length) { + for (Account accountNew : accounts) { + boolean found = false; + for (Account accountOld : mOriAccounts) { + if (TextUtils.equals(accountOld.name, accountNew.name)) { + found = true; + break; + } + } + if (!found) { + setSyncAccount(accountNew.name); // 设置新账户进行同步 + break; + } + } + } + } + + // 刷新UI + refreshUI(); + } + + + /** + * 当Activity即将被销毁时调用，用于注销广播接收器。 + */ + @Override + protected void onDestroy() { + if (mReceiver != null) { + unregisterReceiver(mReceiver); // 注销广播接收器，避免内存泄漏 + } + super.onDestroy(); + } + + /** + * 加载账户偏好设置，展示当前同步账户信息及操作。 + */ + private void loadAccountPreference() { + mAccountCategory.removeAll(); // 清空账户分类下的所有条目 + + // 创建并配置账户偏好项 + Preference accountPref = new Preference(this); + final String defaultAccount = getSyncAccountName(this); // 获取默认同步账户名称 + accountPref.setTitle(getString(R.string.preferences_account_title)); // 设置标题 + accountPref.setSummary(getString(R.string.preferences_account_summary)); // 设置摘要 + accountPref.setOnPreferenceClickListener(new OnPreferenceClickListener() { + public boolean onPreferenceClick(Preference preference) { + // 处理账户点击事件 + if (!GTaskSyncService.isSyncing()) { + if (TextUtils.isEmpty(defaultAccount)) { + // 如果尚未设置账户，则展示选择账户对话框 + showSelectAccountAlertDialog(); + } else { + // 如果已经设置账户，则展示更改账户确认对话框 + showChangeAccountConfirmAlertDialog(); + } + } else { + // 如果正在同步中，则展示无法更改账户的提示 + Toast.makeText(NotesPreferenceActivity.this, + R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT) + .show(); + } + return true; + } + }); + + mAccountCategory.addPreference(accountPref); // 将账户偏好项添加到账户分类下 + } + + /** + * 加载同步按钮，并根据同步状态设置其文本和点击事件。 + */ + private void loadSyncButton() { + Button syncButton = (Button) findViewById(R.id.preference_sync_button); // 获取同步按钮 + TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview); // 获取上次同步时间视图 + + // 根据同步状态设置按钮文本和点击事件 + if (GTaskSyncService.isSyncing()) { + syncButton.setText(getString(R.string.preferences_button_sync_cancel)); // 设置为取消同步文本 + syncButton.setOnClickListener(new View.OnClickListener() { + public void onClick(View v) { + GTaskSyncService.cancelSync(NotesPreferenceActivity.this); // 设置点击事件为取消同步 + } + }); + } else { + syncButton.setText(getString(R.string.preferences_button_sync_immediately)); // 设置为立即同步文本 + syncButton.setOnClickListener(new View.OnClickListener() { + public void onClick(View v) { + GTaskSyncService.startSync(NotesPreferenceActivity.this); // 设置点击事件为开始同步 + } + }); + } + syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this))); // 只有在设置了同步账户时才使能同步按钮 + + // 根据同步状态设置上次同步时间的显示 + if (GTaskSyncService.isSyncing()) { + lastSyncTimeView.setText(GTaskSyncService.getProgressString()); // 如果正在同步，显示进度信息 + lastSyncTimeView.setVisibility(View.VISIBLE); // 显示上次同步时间视图 + } else { + long lastSyncTime = getLastSyncTime(this); // 获取上次同步时间 + if (lastSyncTime != 0) { + lastSyncTimeView.setText(getString(R.string.preferences_last_sync_time, + DateFormat.format(getString(R.string.preferences_last_sync_time_format), + lastSyncTime))); // 格式化并显示上次同步时间 + lastSyncTimeView.setVisibility(View.VISIBLE); // 显示上次同步时间视图 + } else { + lastSyncTimeView.setVisibility(View.GONE); // 如果未同步过，则隐藏上次同步时间视图 + } + } + } + + /** + * 刷新用户界面，加载账户偏好设置和同步按钮。 + */ + private void refreshUI() { + loadAccountPreference(); // 加载账户偏好设置 + loadSyncButton(); // 加载同步按钮 + } + + /** + * 显示选择账户的对话框。 + * 该对话框列出了已连接的Google账户，并允许用户选择一个账户用于同步。 + * 如果没有账户，对话框将提供添加账户的选项。 + */ + private void showSelectAccountAlertDialog() { + // 创建对话框构建器并设置自定义标题 + AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this); + + View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null); + TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title); + titleTextView.setText(getString(R.string.preferences_dialog_select_account_title)); + TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle); + subtitleTextView.setText(getString(R.string.preferences_dialog_select_account_tips)); + + dialogBuilder.setCustomTitle(titleView); + dialogBuilder.setPositiveButton(null, null); // 移除默认的确定按钮 + + // 获取当前设备上的Google账户 + Account[] accounts = getGoogleAccounts(); + String defAccount = getSyncAccountName(this); // 获取当前同步的账户名称 + + mOriAccounts = accounts; // 保存原始账户列表 + mHasAddedAccount = false; // 标记是否已添加新账户 + + if (accounts.length > 0) { + // 创建账户选项并设置选中项 + CharSequence[] items = new CharSequence[accounts.length]; + final CharSequence[] itemMapping = items; + int checkedItem = -1; // 记录默认选中的账户 + int index = 0; + for (Account account : accounts) { + if (TextUtils.equals(account.name, defAccount)) { + checkedItem = index; + } + items[index++] = account.name; + } + // 设置单选列表，并为选中的账户执行同步操作 + dialogBuilder.setSingleChoiceItems(items, checkedItem, + new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int which) { + setSyncAccount(itemMapping[which].toString()); + dialog.dismiss(); + refreshUI(); + } + }); + } + + // 添加“添加账户”选项 + View addAccountView = LayoutInflater.from(this).inflate(R.layout.add_account_text, null); + dialogBuilder.setView(addAccountView); + + final AlertDialog dialog = dialogBuilder.show(); + // 点击“添加账户”执行添加账户操作 + addAccountView.setOnClickListener(new View.OnClickListener() { + public void onClick(View v) { + mHasAddedAccount = true; + Intent intent = new Intent("android.settings.ADD_ACCOUNT_SETTINGS"); + intent.putExtra(AUTHORITIES_FILTER_KEY, new String[]{ + "gmail-ls" + }); + startActivityForResult(intent, -1); + dialog.dismiss(); + } + }); + } + + /** + * 显示更改账户确认对话框。 + * 提供用户更改当前同步账户或取消更改的选择。 + */ + private void showChangeAccountConfirmAlertDialog() { + AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this); + + // 设置自定义标题，包含当前同步账户名称 + View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null); + TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title); + titleTextView.setText(getString(R.string.preferences_dialog_change_account_title, + getSyncAccountName(this))); + TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle); + subtitleTextView.setText(getString(R.string.preferences_dialog_change_account_warn_msg)); + dialogBuilder.setCustomTitle(titleView); + + // 创建菜单项并设置点击事件 + CharSequence[] menuItemArray = new CharSequence[]{ + getString(R.string.preferences_menu_change_account), + getString(R.string.preferences_menu_remove_account), + getString(R.string.preferences_menu_cancel) + }; + dialogBuilder.setItems(menuItemArray, new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int which) { + if (which == 0) { + // 选择更改账户，显示账户选择对话框 + showSelectAccountAlertDialog(); + } else if (which == 1) { + // 选择移除账户，执行移除操作并刷新UI + removeSyncAccount(); + refreshUI(); + } + } + }); + dialogBuilder.show(); + } + + /** + * 获取设备上的Google账户列表。 + * + * @return Account[] 返回设备上所有类型为“com.google”的账户数组。 + */ + private Account[] getGoogleAccounts() { + AccountManager accountManager = AccountManager.get(this); + return accountManager.getAccountsByType("com.google"); + } + + + /** + * 设置同步账户信息。 + * 如果当前账户与传入账户不一致，则更新SharedPreferences中的账户信息，并清理本地相关的gtask信息。 + * + * @param account 需要设置的账户名 + */ + private void setSyncAccount(String account) { + // 检查当前账户是否与传入账户名一致，不一致则更新账户信息 + if (!getSyncAccountName(this).equals(account)) { + SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE); + SharedPreferences.Editor editor = settings.edit(); + // 如果账户名非空，则保存账户名，否则清除账户名 + if (account != null) { + editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, account); + } else { + editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, ""); + } + editor.commit(); + + // 清理上次同步时间 + setLastSyncTime(this, 0); + + // 清理本地相关的gtask信息 + new Thread(new Runnable() { + public void run() { + ContentValues values = new ContentValues(); + values.put(NoteColumns.GTASK_ID, ""); + values.put(NoteColumns.SYNC_ID, 0); + getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null); + } + }).start(); + + // 显示设置成功的提示信息 + Toast.makeText(NotesPreferenceActivity.this, + getString(R.string.preferences_toast_success_set_accout, account), + Toast.LENGTH_SHORT).show(); + } + } + + /** + * 移除同步账户信息。 + * 清除SharedPreferences中的账户信息和上次同步时间，并清理本地相关的gtask信息。 + */ + private void removeSyncAccount() { + SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE); + SharedPreferences.Editor editor = settings.edit(); + // 如果存在账户信息，则移除 + if (settings.contains(PREFERENCE_SYNC_ACCOUNT_NAME)) { + editor.remove(PREFERENCE_SYNC_ACCOUNT_NAME); + } + // 如果存在上次同步时间信息，则移除 + if (settings.contains(PREFERENCE_LAST_SYNC_TIME)) { + editor.remove(PREFERENCE_LAST_SYNC_TIME); + } + editor.commit(); + + // 清理本地相关的gtask信息 + new Thread(new Runnable() { + public void run() { + ContentValues values = new ContentValues(); + values.put(NoteColumns.GTASK_ID, ""); + values.put(NoteColumns.SYNC_ID, 0); + getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null); + } + }).start(); + } + + /** + * 获取当前同步账户名。 + * 从SharedPreferences中获取存储的账户名，默认为空字符串。 + * + * @param context 上下文 + * @return 同步账户名 + */ + public static String getSyncAccountName(Context context) { + SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME, + Context.MODE_PRIVATE); + return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, ""); + } + + /** + * 设置上次同步的时间。 + * 将指定的时间保存到SharedPreferences中。 + * + * @param context 上下文 + * @param time 上次同步的时间戳 + */ + public static void setLastSyncTime(Context context, long time) { + SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME, + Context.MODE_PRIVATE); + SharedPreferences.Editor editor = settings.edit(); + editor.putLong(PREFERENCE_LAST_SYNC_TIME, time); + editor.commit(); + } + + /** + * 获取上次同步的时间。 + * 从SharedPreferences中获取上次同步的时间戳，默认为0。 + * + * @param context 上下文 + * @return 上次同步的时间戳 + */ + public static long getLastSyncTime(Context context) { + SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME, + Context.MODE_PRIVATE); + return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0); + } + + /** + * 广播接收器类，用于接收gtask同步相关的广播消息，并据此刷新UI。 + */ + private class GTaskReceiver extends BroadcastReceiver { + + @Override + public void onReceive(Context context, Intent intent) { + refreshUI(); + // 如果广播消息表明正在同步，则更新UI显示的同步状态信息 + if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) { + TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview); + syncStatus.setText(intent + .getStringExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_PROGRESS_MSG)); + } + + } + } + + /** + * 处理选项菜单项的选择事件。 + * + * @param item 选中的菜单项 + * @return 如果事件已处理，则返回true；否则返回false。 + */ + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case android.R.id.home: + // 当选择返回按钮时，启动NotesListActivity并清除当前活动栈顶以上的所有活动 + Intent intent = new Intent(this, NotesListActivity.class); + intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); + startActivity(intent); + return true; + default: + return false; + } + } +} From 6209233589c6f467ae55b98e01ed491b2a12469c Mon Sep 17 00:00:00 2001 From: yhz <2678576348@qq.com> Date: Mon, 16 Dec 2024 23:11:06 +0800 Subject: [PATCH 3/4] qqq --- doc/AlarmAlertActivity.java | 196 ++++++++++++++++++++++++++++++++++++ 1 file changed, 196 insertions(+) create mode 100644 doc/AlarmAlertActivity.java diff --git a/doc/AlarmAlertActivity.java b/doc/AlarmAlertActivity.java new file mode 100644 index 0000000..3c77e81 --- /dev/null +++ b/doc/AlarmAlertActivity.java @@ -0,0 +1,196 @@ +/* + * 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.DialogInterface.OnClickListener; +import android.content.DialogInterface.OnDismissListener; +import android.content.Intent; +import android.media.AudioManager; +import android.media.MediaPlayer; +import android.media.RingtoneManager; +import android.net.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; + + +/* + * AlarmAlertActivity 类用于处理提醒通知的界面和声音播放。 + * 当一个笔记的提醒时间到达时，这个活动会被启动，显示提醒信息并播放提醒声音。 + */ +public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener { + // 笔记的ID + private long mNoteId; + // 笔记内容的简短预览 + private String mSnippet; + // 预览文本的最大长度 + private static final int SNIPPET_PREW_MAX_LEN = 60; + // 用于播放提醒声音的MediaPlayer对象 + MediaPlayer mPlayer; + + /* + * onCreate 方法初始化活动，设置窗口特性，根据传入的Intent获取笔记ID和简短内容， + * 并根据情况显示对话框和播放声音。 + */ + @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中获取笔记ID和简短内容 + Intent intent = getIntent(); + try { + mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1)); + 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(); + } + } + + /* + * 检查屏幕是否处于打开状态。 + * + * @return 如果屏幕已打开则返回true，否则返回false。 + */ + private boolean isScreenOn() { + PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE); + return pm.isScreenOn(); + } + + /* + * 播放提醒声音。 + * 根据系统设置选择合适的音频流类型，并尝试播放选定的报警声音。 + */ + private void playAlarmSound() { + 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 { + 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); + startActivity(intent); + break; + default: + // 关闭活动 + break; + } + } + + /* + * 对话框关闭时的处理。 + * 停止播放提醒声音，结束当前活动。 + */ + public void onDismiss(DialogInterface dialog) { + stopAlarmSound(); + finish(); + } + + /* + * 停止播放提醒声音。 + * 如果MediaPlayer对象不为空，则停止播放并释放资源。 + */ + private void stopAlarmSound() { + if (mPlayer != null) { + mPlayer.stop(); + mPlayer.release(); + mPlayer = null; + } + } +} From 21228e358dae9216960cca7be30eff456a5d7f99 Mon Sep 17 00:00:00 2001 From: zhouhui <2779783722@qq.com> Date: Tue, 31 Dec 2024 10:49:40 +0800 Subject: [PATCH 4/4] zhouhui --- Contact.java | 80 ------------------ ...泛读报告_202212809017_于昊正.docx} | Bin 525875 -> 472864 bytes 2 files changed, 80 deletions(-) delete mode 100644 Contact.java rename doc/{小米便签开源代码泛读报告 .docx => 小米便签开源代码泛读报告_202212809017_于昊正.docx} (68%) diff --git a/Contact.java b/Contact.java deleted file mode 100644 index b302f4a..0000000 --- a/Contact.java +++ /dev/null @@ -1,80 +0,0 @@ -/* - * Contact 类用于通过电话号码查询联系人信息 - * 该类实现了从联系人数据库中获取与特定电话号码相关联的显示名称。 - */ - -package net.micode.notes.data; - -import android.content.Context; -import android.database.Cursor; -import android.provider.ContactsContract.CommonDataKinds.Phone; -import android.provider.ContactsContract.Data; -import android.telephony.PhoneNumberUtils; -import android.util.Log; - -import java.util.HashMap; - -public class Contact { - // 缓存已查询过的电话号码和对应的联系人名称，以减少数据库查询次数。 - private static HashMap sContactCache; - private static final String TAG = "Contact"; // 日志标签 - - // 用于查询具有完整国际号码格式的电话号码的selection字符串。 - private static final String CALLER_ID_SELECTION = "PHONE_NUMBERS_EQUAL(" + Phone.NUMBER - + ",?) AND " + Data.MIMETYPE + "='" + Phone.CONTENT_ITEM_TYPE + "'" - + " AND " + Data.RAW_CONTACT_ID + " IN " - + "(SELECT raw_contact_id " - + " FROM phone_lookup" - + " WHERE min_match = '+')"; - - /** - * 根据电话号码获取联系人名称。 - * - * @param context 上下文对象，用于访问内容解析器。 - * @param phoneNumber 需要查询的电话号码。 - * @return 与电话号码相关联的联系人名称，如果找不到则返回null。 - */ - public static String getContact(Context context, String phoneNumber) { - // 初始化或获取联系人缓存 - if (sContactCache == null) { - sContactCache = new HashMap(); - } - - // 从缓存中直接获取联系人名称，如果存在。 - if (sContactCache.containsKey(phoneNumber)) { - return sContactCache.get(phoneNumber); - } - - // 使用PhoneNumberUtils将电话号码格式化为适合查询的形式 - String selection = CALLER_ID_SELECTION.replace("+", - PhoneNumberUtils.toCallerIDMinMatch(phoneNumber)); - - // 执行查询以获取与电话号码相关联的联系人名称 - Cursor cursor = context.getContentResolver().query( - Data.CONTENT_URI, - new String[]{Phone.DISPLAY_NAME}, - selection, - new String[]{phoneNumber}, - null); - - if (cursor != null && cursor.moveToFirst()) { - try { - // 从查询结果中获取联系人名称并加入缓存 - String name = cursor.getString(0); - sContactCache.put(phoneNumber, name); - return name; - } catch (IndexOutOfBoundsException e) { - // 处理查询结果异常 - Log.e(TAG, " Cursor get string error " + e.toString()); - return null; - } finally { - // 关闭游标 - cursor.close(); - } - } else { - // 如果查询无结果，记录日志 - Log.d(TAG, "No contact matched with number:" + phoneNumber); - return null; - } - } -} diff --git a/doc/小米便签开源代码泛读报告 .docx b/doc/小米便签开源代码泛读报告_202212809017_于昊正.docx similarity index 68% rename from doc/小米便签开源代码泛读报告 .docx rename to doc/小米便签开源代码泛读报告_202212809017_于昊正.docx index f063739538f6938f927a3646a814d84ca6f178f3..0875d40417c465b9ba1fd7a1e6b4b031dd485436 100644 GIT binary patch delta 108784 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

3T%IZ~AOHm<26P<-# z#&&VUEG)~vqpy3qirRizL#)9VS%XG|*x-FAT%*n`EXj^R&@g=v!qEf!+%EEu5c)D9 z-b|0!ID!C8k!x!72w)}rJvxD><^+Gi1>hXCn=V5Ue;Eet2CgU`9|wsNQeP_P&9+U6 zUpi)vEwUXfk?%hpfAEDK#f0VNIaWkjRFY&rfP@Eyp0x*pQw8<6=`{M!i*M4){a|LW z+xD~Je~Y)V149dNuX{OGLCgPw+M+h(xkP;V=q$GUKM-?{w&0Z6FMljCH+JAS+iq`7 zJ2QN_cbd5G3m1m+iZ;A9_j<`o=y#=}jTufX3MtBE*z1Ab{RsT&Hb=D~h_>YI5-*}E zy=bh{26m=>!5ImJQ-W9o)FIR-xai=G7Fl;j5In!xK#{|a%m)5%ulDeaEu}kgUSfhD z0+>)c6;37_68k=zuIvGt6Q97rr~U19B+DZ%SdnBbx0M6>+6kHjfT+!$im9*rklk3D zZ2t(sHPnU!7qV4~_q^w$iKQCW?Zqq z`GdlviKM(%q|#4yN5X_&rfMhz!|c8jG7SDDj)*DbN}CgcAgWOG?H0h5EYEl*tXJEF z&~UzRPoKX?6mx+fu`;aei{jultjyHe!O#`K=tV|6M9BGHyT7=%EJa0(l zqNb~#^nGcYz6hUob(Az_3uzxR9FEdEp1&EcAW}){Ozgrd-hy!_5_v_ePmq$D&JD#+Nssu|8TF|*=tHx8w0tE zuKJ$lr_az*EQ?GZKl%+eK7Q8~Z6m(XKs4=zQ7Z9iA3yRPIzB|5AQZ^l*<(u9GWlvP zj}@qnu)-IQjf_j_ZOwLho7o6z*z%PdG5$c`{!O&&PO8hz2;dh0(Q#piN4l!%b~RjvCE@PG)ng-s>*_1>AD}L9CDs;6%Doha72t`$^-W7evndQ zUENoEjl{PPio;5e^0q%QSM}-lzhNEj#$KeAu2?ErC67aUi9V&7duwXIP(c`Ck1z0Y z;cO!Qd;>iDIa1HFl#;?>VcuIc#Ss*etl29ryzzL~PFBcV&kaI;v>3PtYx%9!w=q@5 zY;)RnczG$|jY-2?&2SIp26%i0XMO6C%Jxp`@P1FwqdF<>WPdjuI|n}==I1S6mr)ab z7HJ_1VN7Adew9&~Goj;;5Z^ZVX&CR2J%w$y)NuFAAq6mU7vBTm1z{u$)&p=T4P}7xON5 zuqeNyoW(`AooB;h!I#=pG;PaNnhh-Elg%lj!Zg6lD+9-3apKr1pnj$Q59lyhn_wIQ zI2;Taj%pPEJz)K^@>(6!eV?iXg*F>c8SAQ!mDF)?lP|o+5Ocrq5yv>14EQT&2Hvt^ zFDj<1`c*yk!ZI&q2Nf1Am~X@<(wRFAfI!SQi$?d zP{vrFahuHcu5FLLoxTODkEYv=4hhSF&za4d0y@1%rEg#UzuyzTPv@*(3Qqtp(~<9o zA}WRcfE*!$KjMFUMZYKhq8aj()O^||k(4Zf=6-GZwhd`xr0-wD4C; zTj=rQ#d~_f!M$tXZZ!5(OvJ1bmn)?=47x7u;2PZBA$V|icL;7B+}*WtcXxN!U=0L!4IbPrxLdx?^UV9rnpyL+ ze{|oq?&_*_>g>I*+B?m8-i-tbz8Rxj18kg^{~hBu+wT%eqYN^kJ`;?a_A!K-1s01r z!Tx~_=HpHo+pwdv;R3A|97&-}_>)7z1yl0gF(d_ZGBy&=i6#|R2?r^QVjDf@M=o|F??6Xmxd}*9o!O z2NrR9Mu(b<$0QiR+qSCIbzfqYa-2Cv`E6ePh}!=x zl#BZBERuaRr-f>D_2|A#Hd5u`cX5zNy2QuVgy#%0qtn`$C{K8`*`R{+flF^6mFjGS z@?~nKzejD9?Ntc*O9OM9rNboTOt1SudB5%k>3GfYMo30}Q6a0{!*pLQwT{m0S0-Zq zZ@mWSBl1*Wq5^U=VwDiL|EauEZsFqfj>N=%NY2v02bODS|9`m#TK>20C%?!x*KV9x z%>D}h_+{)RntC_}BITxHiE!Ti5rPF7!R>K4q_?Wa1PmFGL0p zw1NK`M%a(rOJ+Su9z=yMd9#4{flHQVj!AfGlCtni1>#O8eWlV{vZ#6|ny5-@x%@(` zXnn1A@#_WHQ>zvof^0k|?ObUJs8$_iYCfMk`6XmyB}`hst$7-8u*6&_7;%8KM-==V zTs>^z3iaA`^FHDZZq}*JGoqEmusIMlqdCt|VSbXi)8x^S){UX z=S-5!a%kHKk}ak?APq1)IkG(u>@6Z4c#nFd`z=29crr8G--<}iCX;+qyLjXAsH$$a z>20i^$>jk0S~tyMRKRKJbR{RcO4{ccPY)FfXXJ?%24^HwHrD|a92;u4-0UbX8|rsq#`=>(AWberl6bCb@iiuqFEl4zgM7x`J zk;2S)Cu`j=usjC7xHBWD>(V3G68`2q!{V-(yOjzOlfkkf+wRcZ)2(IKojTGlE_ZE} zia!8mqA)OT6tQQ)ALCTZ1Z?T{^r-9RaUW_|UjKRPE) z?sHc)0FG8sOm^sKLP1DpdkuQ3`nPCjz1M0V2z5C{HM+Rn3jO?b9R{(hVOM$c#^w># z@eR3rDkjHREsHSF>b$cKf2b>11&=^`rq#8m?t8ztUU2u(bmh<`QGF(+y*q zLn?MZbN(^*ZsAZeJi$3k>LYl(c7U{&E@50gd?#Rs1m|eLOtkM4do13P%72vwNuSqHPYxREyO!4k6(bYsq-AYhZ#r4H0_yR=IEJH z`B#!PaYsSP`&W&CbX7+|S%iq9pQly?!Dr9!5IN%4_r4IXAxyr4(9||p_g9C>DQuRvAz#06(-0@1jFN<$Pi1-x5xN}s#N+L5=Et{$ zHQ`E;rlZa&8KzEG&)*|AKeO+7Z^S{P$FleFWU0B2qR0IK~hx`9Q&*zZ6jUV#q%``XuZs`%3H<8&lU`*W4^!2X_KK%oGH_ z;`mc6dbJ5-k?O5T)WlC|ly!>&B8cv#`kiCadmVAkrOGxsSS0?~17w;rA7I}}g9u`t z`gcTHnWotP_@!E1ny38k_!~S$YrUjxmmb#qNsd{tV$#PrYf{^9!Wy_Rk-SyJL2OAg zbZ;{}Pi%5n`ue7$#a5E>;>49W@BBA$fo7e>4fUJfpqh5O?vo?#nE46{!DrM<|!|H6`^nI?zzBm&GEI_agYa$L*}9%MZEzLFN@{cG-P z*h1P%*n;|3?bVM7i7%grzK9N7_*YApK$rc~5Cs)OhUY34%a6|W2k3+BRdoQ5l+b@9$<35|b zEbhU$x%}2Ol?etxcw1rH0ODa2ruK#b{9EiL^wX}vLv;+j_dcMc`ZN|`Qd7Y@`dmG_g#|u{;h)RVO(*)_!$6Z;?W``NH^f#_I1*p zHbQ;S9u;M%nGV`5^<}_+ksE^|iSC7p1n)pfj5`MUsEjIx_5>!lo6UbPsH&t8B&Uv* zCSr9feLIe+*$3Qu{Y)i@OX7yPe#dQTnE>fOcJz4}PgbCEAek>W5c!I~jk!S;aY~o` zkKC!Pi{lS7(Q~mXOK*5PQdwg;&I;`Z$iLEvQeJNX*{~a|pL3AjKpT>s{=D6>r3C8i z9@KDhzEF?y>jUewYj*PWBsUA!X{O5isGqejE8Kj*JtyFwIzj$YqO{%8|wnZmj-qicpj*s%bQ3{FXkEVK=oR#iJ1OP6}QXLboUR#7r#7Jkq zp!9GrTi|gSabfJ*kk;Ankj`!s4R^0%wH-2FL-Ntrrw)V7&t2;s>MOrD)Qq}x^UdzG zf5b`t`GMhH^Xz9%@U|?GR41z1cz#<+F8TSUXg3E3`dmVYP?_qNz{f)2Q?iTd*Wp%I zc6UR)W{1YT^O6o88%D0c)Txp8=`fhn1Ira!;_uSlE5P4uQeU9g5xcK)m@u{Fb%Iyxg)t-Vt2!cR!f z^rO=Dz)ct^!EJr$vp=yE+DoX-8ke1Sh3$>%Wr{3RO5CAb8Q5V3sw?_z_4NcT?`ikI z;r2#I$49qkHI#8f$r`&bE1Mqe`26u?F_SkNICqzl+mO*^Ti6{y@A&r~G{(kw!CZwS z_VSU+DXzq^&+pW@GxOY;?7H?mshK=r-qG`yuJyPZHi>0eiVleI-4!PeIZLlO2}{68v#wlea~qD{3RD43tsB_vl! ziqsT8%u-@AqYvLGeIvX$Bkaf<>;()N!HFs%A4?D*fC~nf-JY{udzQ`f4thN$O`=>-cO3aH^>)vj?4n>bSfY^DN*H1NHM^jx*)PQ!cN~pNpR2|OuxV6Pk7`iejV?GkqyuF+RI&g6~@`(eBJ4Ms&<6q(%mn9 z|BNQNrHem~+H&nIRMjZ`vHOFgVdE6~62Dj{eu13!``VKR+VRt57M}$&{Y@ewn7cFS zn9STyn4sad)iGd~xG@oOgMJUxXez7q=R@619MzB`T>59_gUsb9l`zTwM^5+;I03;z z7fyXs3#BM8QimtO^TM%{8l$WsGakT-|oQF`yrh3)^025(Lb7^ng=G)FF6&2h7sDZqI0BZA|4 zF)0IMH0so|$KjL)^tQp!0wGr8gsKFYn2{mfFE~-#qB<)g*9I$Uo9a5{sY2@0=#6B9 zBm;v%5=UlZi*JA|Y^v8udRkAXMpL<0w!FCbcFr;IFUSK6Wd;c)tdq0%LGD}`%EOVd z>m3SRF6jJWaw_G;9hL^a6>oOI0qsSrvMnSAmI!LcM{%%@6=ggjj8?r4ie!Az)9UOI zeeTqPmx2bSJSI9;g9tS{T%J4Y)5n+bhY3w2OitZS*6(vc@Y=R6*IFjm)U(^H{izwJ zShQi+mcWyZrt2NZaln5~03y+SpAfWSeivkI5GDkZ>%eQBDdlPG>9qDtRPo}UP<-Kc zswz4QcXkg#!HuF-inqva{56)g7@Lb!m_dYLW;i)r8^WxOP_(T-b#WGJ?an10j1OP) zGZhcMWfs4O_!iTaI`G48cBTl!T*y4yZH`f2~ zn*80Vm`SX(8o&LOrI(vo_f`YXrJskT24M6ycJ9)?93#&}3G^P<)^#(UJSU zBZJ17T!zIJ+hFs|4mSvQSicky-)}N z&TH$Xl5nhc;cmntevFo=Cc1KuH$k5^`(U^37%>$}>(ElA#e!q!f2Rv8GdLvjivF&J zJG62YL6(-aqF>f7N#U69*2X?VPoDj^LjXqLe711@AE#%y05FY@4k74~i~#=rItNxm zQ5WGlA8w@lc7L%jP}N`tg+yTGbaCDyjvBKhDMFvXplrmM1hVbo=6aR3QGReNN}JM} zFZlErY!RKb5EZ^Et>CE^%voRlK6RNdN8MbpA)9!pd9#*GxG=0_rLBB1njqsBjncxk zWD-tdW#?L_4}5?PQj>s@^G_8Vq2v`v8ldD&AOX*t&XoBN4jcQ6a+x?+5t`(-(U6~& zZ6cktbdoY}`kes2-fLA`K$D$Yt%}aI^Za@^sXZLa*a_=AfCc}MXMhS z6uL09Pj4(wwvfjFL*Wg>cUv3-2XVkiBwm3Qj~Lv|Hkxi%)9ou-Kwk^d0M3NzAHXP7 zJas8LFkU!O)@++kW!(!j1$40t7(RffV6kf`7M4K#&=Y)Ams(~wsm)X5htLzm|73Lx z`M!6d^f!JS|grx)Y-!S$sKjiW)H8d7{=_7w$ z7TkTiZH$6wO(PgUSzZ3+!ud%@s25Ky*ix^~QSQ#>%5IRujMti+IeC=q`uKdPI8T2rnQRPK(yK2o>|9G^;a`Ks1hQeK~@pPXv-A9;}K0<%Y16|@@8ruqJ-cqTxDV* zaNY3Es5+vAFmfQny1yh&5QH10bSg89hHfzcuC6tE-OF&qtOSis_+92^=IQ$2r#khi zJD0Fo`&LWDksR%(A~mWo;zV5K0k?X7lrT&pkKH?&lDr;E1)D!8ZMvF8N|-nHh-wf0 zxA&T4R(33i(n`kZ&Nl6)BzqT%x)r3LR$76F<=F%YQ~O%mTogMNWxzM;b27G!1(e|u zGX~e0vJ@dZsE_?Okqa;M#WtM7I7MFu3Eh;2@5ZZC=YCnvz5aoa*ac=l;LY5^B`PPJ z{`iB=)z2ZC^15g&)eoqYTuZJsx53fU-;c#{^2!h2UbR%GPd~EWHzEKio-_t5w&k(QW|E}=XTV>CYd38 z^_{QUft;)DwZ0I3M_538aM}A6L&a-M9?09|gZpaT`4+m;t>)J%Hkz^A(f987OG9Lozh7?MF%+`PZFSA+XUF=zpscwi|Hho zDSLZVi0LybckID(Y`FE8%zN@{4K`NlcL~$`4S|}W0bNa8OP9~HpiI|-4y6U%=A<4M zM4L)Eyl++%fe@Qxi^})-f;dY_XVuswOV*H#C21#m@HWqb1-qyrUIi{r-K};T-h0qO>X|0t=4Q2>84We>&pv;us&V-Z%GNs{vJiYuqA#Af33KqM)H zYj9^J?Dp?$$099s6V*)Rz2o{P(fClz)EDc}a7=!Dr4-huXa0>aApt^128Z^h?jw9M{@`u&uPW$^>G)M zo64^q%`N{7b|}`7mYt#s43m;Ivs9j*&t`5-8YReGTbHeqyGJ0Sd%)8Phr^GreHW^+dWq!ZGz;(wv!kXLXgH>5uoTJxhvG~@`gC;w zx|-gDz#%R;oYDm0}%7kruSVs3EDD{|U z3jf~oqhS*OemrQNHLqN>~X&Om{hROR94^C$uJ z`%KT%*?1kXOZJvun57o87I(|Yr5#Kv;+LT|$g?9RC z>2Z7Q#2J+=ul0>nw5;8F#VYJ&LPvg7!S_brGFtm4co#CEJAN_x`ZEQyeq|S14`f^& zE~aPAh?fFcHK{n_&jloApeE2P6{{78b2!NMj@Xre;c1Z_WV6a`4=t7rVwih5K(FE@ z+IFhn6cNHK4kD9hV>#M&Vj+2~V!?=~oVaNi(wfN7w0-4k|%7CbD=3Op-Bnx5ov@!f{Xf27_8WUCC`Z{eH0+kygzV6}{v1P;_?MjECe6H}9OraDq9GqXqsKCuJ(F#*$VQdjJ1SxBT zIBJ_6)Ch>qVBQIc#$UPD-{n2+7t9bQ^J=;Ps)v>~Y_-N~?k6y@siK%N`qraKRb;S= zyF<4j>hT7tR1K#Fs=Yid_t#jNAmNp4Ksk350MdoDBE5 z_SqQ%zLq$S;_iv7v^Q*bJjEaEUKUN0F#9^a_juh>h${Jk)`E!kWWA0`KxptGrVc#A zP*LwhD(5gqE2%IGNJ!K_u)cuN+YLFu1+`T>y2^cXAzcHOFo^<%Q2bM($Kwv^8NnBl zn`23yyTE{PSacnx*>X;%*VG5M(l({N1jCowzedGWgnU%r329E$Xo&E23+Cxc$)$K%0I=t;nl zL5mRiYcF5zWoLe2B_mvT1w6qp5U)^PKivP26BS=DYmpMucji2q9lFbd2de>EK;E3m z1GlDMOAx7#slmq^Z%js8PGa&VxtcE2B>JqWM6&Ta;;#X2MDuLn_23cd(l z9hU|WrHUC|%(=wp`P{_{dIN7ilIL$IZ-?bw{3~Iuhlsr_qz$nphw9;p`aA2XRal-z zUS|?Lh+KEaLus9SfgFQnC{DO}83zlH;WoizUx6*P=jPY)D<^;F)=oSfJu%2V)pePb zlXc70jF?hi*rvzn>1q(w^cJL7VSgG!lrNk(g!7vQ7ccPUd$VY}=K_%$N;Pl>Hc2KV zd(H1jG%uJQrKh5xRXkL&%+^r&t)JCiRFmMSUKOU>*3csq9SX>u4F3I2v~DkGgVMidbIz}7)dzdX{6^A#RfUFS+`~%x zGP?}xDyc0JIdU6mdIOvdXmsspxE53`#=*EY+M`5s8aF%Jp1*cOS|UIg~a@@vLdB=zzo{ZSOXfw@Vl10q@ckK?gwOu z=7l=sgj(QvtcN-@BeA>&2UZYlV{*K#>F+T6S{Qh862(f0tD-n+L2(TloqFN);C?@) zR=tZh%+xBoZ&fp> z3Acw^-;;bd{XG!PW5){=Z?QvYu_G@}8bv5?JD>Aa(2UW^vg-k20ZDYIyy!5`HNU#K|b!7^KDMnks|-^+@GyTE#F~X z^t-x$wthR%W~9Gy^#%N%OTitL~2_2xzGpic6X|ceLel};Vj80IoOdR zs_A9p3z#6knDAIn*Gj1%iVg8J%u8Roo%dE?1TyZoplhAh^nmX1$?$R=bd#O+N;TNm1 z)spm9yc)c}7!eO16x)fDHK4}PGsknL3WM=fN_TA%q?LQRU8?w9j z*@pi|2}>P7g>|?n>c^TM~H1$T;W$@qn>`Y28RM1cOUSQ(ltY0y9U5TFg73quXYXtf-QF~)nf>w}Ry-pNfA8M|JJ`4IEl47Coyo9_7g_(;D11gU zwTc73e-gCNr+jFZI{yRd)B4{BZBP0Ph{_`BZnqL$$5C#srq&M6AM_7DYQWU$k**XS z%>G=mDEYDI-NsE_`w*{*y=4!4@6>SVx)1boHB*%kzBG<3$yjtg1Td$}2s705+KC1^ zk#4Srr(;nQ!Ap8dG}co_b*r>oSUZEO64%GYdqd9ico?1W_}8oT@FO8#)aNTTl{Cl? zyyXbLT68;xAGGCT@|)mSelc(vhBEOez0O}#0BkrIPLir5yjDohOvzOn^PC=p73?gA(l_on=_mg zZIeDf>Nb~yU?w-71ReJvu$U@>I6cC$XZ);%w2b{#Onei3b9Y=yV*yjo(xIuX|M*ll zf^oWA<_q2qR9HwrA4*V2L;W9|i!l$3RuYpVR-dK*p~F0Z$Ndi4E%7{1RMm?%>reEW z7hOutm|MX*C%c!M5+a2g7v&yqm9x+WB8?)o2#@V6lpIqKKlWLj+IMWPrPS|G=(@u< zK6|?a%0q3dfm#%DKWSmTWK{s!4C{do^MR;CnB^nQz@=nhrLUhJVv@!T@rTw;n}wJ< zZ1c7L+vsc|1VBX-GHNh^t{rNI*z@A&V*=DAQb@n5s#?3^w4L+HzM{{{)aozrHpzDt z_#y|lMO!f~OJveXdyUJw4Ben7nXe##46cNyFK3sRYEL3nXt+xbZthAHaHMDTb$iA{ zF~B$ihkM}qH++Mcm{xE1X^ea(#%#;u(^p|k1#0Q}2Qds?-DT$x$YUp4;YLx7D*f0f z!!JbJZv1|BLLSTf_Db6U?fd{Hk&rarF5RB??~?*_f3Gr*c7C4^M?2HusY9dKFE2Ys zbX_ZUUMIGbILt*p%Ao@o_e}!XF9uy`^Z2h>nJ|Ev>NFmfWI}Zo5%r1SEpz$>3>*KU zbAJElMuzq9HX6j#Q-5zX#O$y(VLx4F|8g@(k_K}z_$Y;A7zJb8L{TZQJ3{F%fVAb< zl6)}On`2JmdwtUR^>#j|%aU!8s_`1ZM^=A1Cgfg!3SDct_7Sm2E0Kz{ZK0!d zv$(@c$F}d|pyN5$NQ@r3${I6kW(w&mH5ITzA@!EaYm;UxbdWn@rARi}l3n2gXMKSFaxaO2- zfV;7Df3E@L!NV{Cq4fTH-(2>5BbzxV8+Qj*hyZKwzkR{ZGtb2Mf&9IH; zu%$bB1AnDbV-%YCKlXz@`t<)9zNVi}%$`5aa6<4rc5`z*C9xJO0N)3iJSQ8KP2vQM zwoLnlGNO)#gT648!(n>g02S1P^#C;J;eoK<+T0c=3RO6caq+KkSVoUvo}5^~uEruE29;1tUA-i_$8omnaqsxCt}9(fG*)+k zoES&d4VEBFJD6SwzLa4)`^*P|T{$vJ^oyk^;A*W^sMg@j&co2I5BU)0(MQFxKI|)% z`1Q?2PS1}*hW;Xk#q+5l)UGB8j9?B!B|^e2!sgqdM{ar2y28S|z$1L5m3T zj+<_2CK;}aZGQeIL!bgyaZ@@j;e$&fxyKd%#Wus73M(1{u-S=605EfVF96sQfA;=@ z2OnXaG2?x}#V^~(nXBS3y$N1(9DvJzgF*Qq;d#PCCXRx6N4FP$Z2mk&>?A%z4P`+7g^-#tTk9jcK!@b{q=V&MG+ z=k4Wf&J^g6o9UCUj25)>X=eR)QgCMdkwo1P`J1uv2U^==N9|^HTz5STe+K^psmr;Q zOZBhs-e1T<-VI5)Q(xEA4==iq9&=+$z_$UxuL_VnR##uAu;!6Ik8;QxE=}za}WjZ>q9|RDob*qw0oY_!j@n0|#d4Tg& zd+$^p>yK!!N}6v;=jl{=I>$$okRB)54NEfklvb%*X2S-EPZIU#7RgkeUj$i7k4nLH zuN<(xqOf3w^l(78BXzU6^bX=;{xM9RMM~^bZ}jyODJ~At%LV1E2i93#OQSy6(FXGA zf#(v`geYoiiufkwf z860o3vX{G0qZ!1I(ri(+dfQ?v^<)yFH-U6mRq;lXSJqkn^<|Fdur4wMx zzU-eHOV-@_=buXDTBIqXTAMl@=3R2ZZl1{mx!wj_QyTl=Mmg1IjUJa)SDT&WyD}U3 zc|9~rIjUVGM07)oU(1?MkKvE&q%=9+^lo^Z@j5dh70Bj$9Z!jc;!siau%TqAGQfKs zk*X0yKy>{Q5`$LEe_#qR{}8a9PLILCjXk;E-RPp9E5oooeiXHRIoX?!>`myY2$ zmxEO~>nxNKNE&2PNILI77+!!M>dtf>?Wg^)`UBmOKw+H_*dWa;#B2HG5roL${|1N_49RdtJrC(LpRui3Xa1$ zqFeKILVnv;wxTsbTlPU*lv<<2x3H?an zLdK^=%cA)Yj3^_zr+hB^ba@egLhIs{3#5bj@6`_}H{NnsyCjkO6*w`AK|$7v*&1yn zTbtKq+4t=>5T_yANvO7%x?F#kt3m^sb+5h(?PtqE7hgPkGnzdXm>06OtmE5lHyp42 z7}(fg%EorL4AR=l>J?hALxmqm@M*3r(q({N8K`$Vm*}M*5!>BdlydeH0bg;T*ZEC{ z>5Ia`o}$)W-xda%_X5}2sS}jnpVmHomcxmfVs9=C$*XfyUyt;OOgy6TA=+)8K-A{o zF^+3C0r5|F{IXU7|M8{Ng7}mS=e}LxMT{gpy?`63qpT|n5X!rZn=)0qkJTyB&B1F| z4QaE*=POv<$n4~-xsxoFJisHc%Do6TP4k#cOf+5)JSToGu8|Tba)@~Vf$Bm;CK1() zD>x}LfkM;6cMAiWoin9K3pNoY`u(&mvq&q=9{J0QLg3eP-_!rd)fviQmH+xJP(f3E zkKZ%qf0XXe`2S@ZIWp!c?6tA8s?AgCvgQxP0)M8HBMC;Na=pB7d{{5mN`RAT?0LaZ zbN?~K@0x5o{a=3gKb+L*!65up_l}Zj)kOE_Y`z>v<8|w+%D9|qxuWx z5K>wgZ;&(ya6ozH)+I656%zf&vcH4iTWB^cun$9mup~k%`i7kMNiWt9{<+mPOhC?; zgjAu_M(8K!7_IA&ZR{O&nu5a^26Tu|)z+RHP;xDCSx+nhkM#~y+JS?fVN(Q+p>~j0 z$wv2q0WGe!sD_o`Im43=+tT9f*49@7>7eE51nsk$op5ycas%b-e0hxp)3*N)i(rGN z_#dMBdo+;?$iMLgo5jA7{iZ3h=+dc|pGl;b;m-@#G5Z~~H6_*H-n?twR?=|Op8<9` z0&DO+F2O7X!Ugu{kyrj9LQ{2uO^O9g?G6)t?@`0-84?0v!ykrQo>tQ=JNIA=aOMOU z(klxxZ+!1x;~1{O1#~m}t}ymIiAXhW7>MG<7(@F`-L}S~fTKcHTuc7KIw7+5lY1ZWSM=FpWNWixj*fb3{P9WU6hNtC0VHTn!+%2Bg$d*q* zDKbo9_5_{CHpb${sG=#2ah@-dX>y^|GH#Jm3WnAc!qR<*S;$4k=On;>59&Xwd;|#I z=XDj_-}%`%wLPp5Oue}qG?VVIVN`m%1rLQIGMts>&&=V?$6VjGDVn|mJv!5VPi!|B zPK>xdmDz8sqX<{=jY>gY0ET}>xF5M6oVD&v>lOfjK9KRl z4%uNBxLxB&o);RZ!rp*BTHX^r2odBU+_7op*6-u1`66G!lZE^GNjNobrtaWc*|&=; z{Ks$`AcZPM(b`UP2o@zHAp&81L4k6_8X6!AX;CcHyLP4%G5ykC*sAQ z=e=no7Cq*c& znq}gYboQUqj#|dh{*TRI3B-laWcn5i4*MWN4J2D7z4;fC=YSFRqLJJ3>ThXuW>!Un zF&dxvvrD4LV5k5IBM^@OqJ~}tHT507YjOtrON3;s(3dJ)kd*wrDl=o03^T@|Lr!o> z8l7y?Ck(KKx zkE2KavKhg$dq86a%qYR3@Bd<*&uNm0eq%Hg+F>JKMe>x(B#6JxEW^OO*G&w&Bwvg##(jwj zeVdRBx=+h&Yq{@Fv;MQUO38{;o9_-hCcP}FLvgLZNfjxja-Vg7ewU8!i;AvyM2hM2 zuE1&K)L1#^OuyHFUtfim8p!%Stj)QZnTgRS-5Mv3y16wy?ZbZ46KWfB+XiR(GTUPd zFP#L4HS=!Yqr>e01Za1u=>ts+y^#k4z|ivwEZPhxFxCQ>)~PFWiu(4Y%IhzEpI|}z z;9+gsen99EPe1@R$bVP`>B_}+MlRVUG}UXirty0G$$vA$%Sxe}sb-5Y9|(&D^A`2I z+j#v%!>pENz?EmKuEb&9L&=I%{WvwGV*)(9)Xs2vRDFK%Gx0BMXpGoH@b4c6@wzOw zyZ`C7(4WvP#>vhNV1$Nyx?dKj}6HK6q#(s~vR%|K%f%LE8_t&Q-&qwIxRg{?R zw@=*=0Qji}xqGN}P7tc`oM@;K*)j zI`fJM{CHtSMU#<g{k`%;=R#=l%wAMu#U0O+7mxJp}Vd;IBr;XNKp)p54nhye5b_<)iSBW#Q=J{ELKni%!G-6E4;RfM|ldixlM@DxU>C7Nle+{xIaF88P;+)U|Mn zP+_1*Ri(mom+)TW!X(e4uPMG6isngD+4)EMLkp?~aKq^qZ z>8f@R9RyQ;8HBZTz4dj4EWoI|bpLQC)7s}3IFnm}LX%~xvv?SaCN-#wC21->bop~D zLYpmiuv{gRD#^K@8q9f1&nHoN4nYbIzefo8UZF_5l&fsPhFw< zDSaPF=p4#KL4*5p2s6NUSV515BsSW{RygLqb$%YBaP2^&UFGn3nXG+2JAA04bQ}i< zxU@u8EkEIK#Sjur7VET{dUW6;Ou)b}S<3MKQTOzxihl$3G$z8ZlE(12G_a4oEB-;Vf4vzBCO9WRg`gbsd{tF#e+~T zU(GGNMO#2_qN@Q^a>0wNQ$1bn(kJ%;hlVB!WaI`1=Lg%sc;$fTw!wX$5cE8(rA8N2 zCqrgB!dBk6ZI%P#eg}mjzSlj zA~=l6HZPow42J@VS5di7a71z7SK!_^Z6DhYe-!oTD|`uJ@)|hY*yvxZG~4&heiU&t z^Yr?8^ThzPKmGTj?WN_yi3$Cww5(hRoB(}RL&JgkjNXm#>QESw`>y0fYwf%6g^h~} zmj-#9Ay%pW<74JWk1$iVgVY`@;17w48qr$+PhoV>kGx> zy!qeDoNc>|Vc1w;(5VbJBpCg`6@|O0NoYFUwT1TWYuP4xcnb!T#5O6g9i0PJ;_h&m z10jqu>gkPt#rN>u%mqa^37Rq5M!Apzp^9^gTm%6J_>L`pf_5UhKdc|(@QOwP%VBa2 z^NdD**Z(4b#c?YZ1q48qaB>uPJmrLhR>V&#h%+pN;LR*x7P+8{c(ty$k}k4i!C@MhzhPUrQSWESTcU21h%V6gOJmyr~2&m#l4CtLtM! z)AvU!ANRE?Y%X^zi|phi2~5))L2!DDjSPKyV=s3u4ZN=_ASo?1aDReb=RKgA<{sM%uC$yJ1NO2UTN;;R1M1GrJXR)Ca{#MEnnwsJe4Xv?Y8XYvQG-9G{sTHMMLil*2rA`Gz)T)K;71zrNlyEP zB-`rv+0yX|k=%tLw>L=p6=@%bJYOdxCy_zz#B_yK8@NY3#uS8@UyZ{uM$R*y2?nc>)ja8f~p-%P?y1zpCz z7WXJ0pbAXT%FaIm>SI6RwMDJM>3AuH+KyHptM(Udq!2dlIy8dpXBgLha}#Yy$HTHz zM8F#KUwmBdE1Yz;v@J@QnQ7_=C<>v6O*B5xO$`SS8($e-FH9#C5fv1s{X?xt-B`S{ ziIKM`Nrpj3T1jZ=9^HXr%%jA^9jmXMQj!`-PxqC&VItOpMp6`8eUk1x?EfS0E#uOiGC%C&q2yVe00*gR^P{G~Z-95Mk_h116!GZ)Q_^a%_yZ1i#bido@ z_I>Akcpnx&YO#tn#{7>t=CC=(n;OZDM%bvmHONE`s@#*YhHI2fJc%JQBaSBC4u(LB zE&lf~mrRV8Vv!+BBd-BD2&v1ZDLS|OIFsxu%1VXyN9=nW6Ksw+`M&p z?=CUJ7Jiq^YWot#zSE*!vINzB#rLzgHQ#Aku}}FcFsPUA?ukdD z3D$t9K0avUTg2*O8niF+mrk4d&VDuZcjL5mA6BAs4xvXIGKC zVddH@VRE|SYsaqrz%1)dz1eD12aM@f4TWbjpsj*q59Xh)W!mmmTYHNR1RyK4Jj**A zdD_Bp5eRQYuSWj(5w&fUBoQ7V!FcYa&96p#1twR!Pqk48kmB-|`1WyRiBiIxpj(SM z&8r!GxCZOY%Y8G$(eG_Z^K4z0Lqm^fD&!e@sRvYw(w_`oD2f;eQ#=zX2keqt#1ZwU zKQCkCki_O^FeX^yO#8o3DSi_eHp)K=*GPLSLpv&?c*v@3Qv|y*>@uq?)Z?^@BDO$~ zqAKK^`a%p%z#Uf4b<5?Qw15u|ZKFxQRFaNeEph|5ZoyX8hy9s;#A^3X?-X3O^-ahY zVN&xtIjz`)Xo*5gn#w0YGC(4mpF+8X_9#ai#0MiiI6LuV!%BO=SYQ7w95jK+{PCJh z8UK6!`<;f4fI!EErhMtW&zR+1A(E|ytEtQy+nBV|!KI>SGVo>`opH1XLoHlb0a<05 zMsx34ttxAK2((Yk6+0L#9_#bbc5+o=#f|Q$V;SG`yoxDSWqiE?rUbB0@Av4{dzPLJ^ssuxSo=|pyb?M1?x+4E)Ru5wD(D2mBP9HK3w#+;C+8WY z`8>7m47zZuiFi?iW4a@%kxYaIMWe)r6@}5P0wS^mE79%vSu-ZtA5s-H1`q6(+={ct zOwYNuXr;XuV{q02=mCbI{M`VtD58G5D&aI+cEM8%p-`H0Mf|K=cmaedd81`V6$>}v z=ZzQKFiopIG6SACl>~S(JYF?;4j(CqKC_mHEs6?a4}Wudk@-}_AForXz*!(}9_jX5 zXAL|O7Hcz+0$TK%n>W~?awKT4qE#TVc=vmQl?>&$ifOO&Dclr(GH5%>DcMRT z5x&H}X2(D-2?{${^)vY8+6ljxf}6HD82G@i2F~dHUbE_EDX|E{8@N)M z*jk+4;K|M}mM3IV^Co(xm9(srG5T&zH^ALq#r;gejQs@NuXpVi8~Ta!4nqK&(zfh8n0NvZpVIZ~zH@ zC)MeB#Vqr70(9DWnu1F@tcvwK(ZV57IzRSoD zl3egCj7VUEiXNjX$0^0toSHojXY^Ly^`#+USk#*}(Qw;yNtwE+9Q&=_cUuf+=%dqV z{-@&wi@Y$S(pQcV+!?#pzH7QgeE_kb&{q#50?(xZNetih*Iu<%$jQp$U~Jko@_bIO z32}oYR+>lqJiG(4_NMVy8~(i1tzOHC2=cxJHhRd7_-C*covbEghE-}CK~lYBw^9bf zo-#@@6rFy2hgCsoIH^$s3ZPXVxS(E!AQ{9nOtUp;Uj)+m0%tQP{Nqq|R>faWZw1vMb6Do( z*R96MAu-zo=MavHxvjo1zp*WXBlWsucM1^=n*;u% z{3&LZ%+CUFAdmspU*yly(ZNmA#PqerFZt`&nQ)w8$L*jw5tVGIG`h*un7W3(}`AHhK_{oz0yj*kK;gme)Ji7adv~l;q*QIL(#%)fgW> zTf6$0bXbO|_xccvicy8QvF+{a5714wKc@57s(-8^SIxdwDCFDQNM^`4`GI3&{H5iM zjj!R46WRp)auxFoDRkfH!rs=+A!{+hM3OhM*v$)@fnRa`AsxNdUhKp#!}v%x;ytVt zXZ!{wtYibWd|E))YN5UE~)Sl$fWkOm&4qF(i>!s65bqr#alBT%Ux8CI-$Bx5d#VHV~-1MHLd5`d@ zb$gan@Oaq{rVTNA?N4%iP5aSuAf_IZK)N=Fm}dnWm&@+0J+(t`rMP5-Twjn<3e5Rr z8Pm-BOq@L-9|%c^ErulJgn7bhkr}u?U}&nlj>6a&AM_RWDH6!3PKWJj!HoA$2 zR(ZnjQaaT&3!A!^KIy5IO}zkBYS#=O0Rm=20A>gNd+abBS~Olv1pY$xRMavoQv%9k z5A-Z?Mvw#vwRpvnK4srL=L;}THj&Xgc1_j8LRo@N3}cqh{rIn(v05iRr|fL>NC=r4 zJP7N1w}sG-_;+*1WCF2s0G7G{9GIWIiIzc}3Z1wNgg>xj%7bwIw@HeY_z=}sR;|b~ zpG7jwq7ZpHK-xsAD9SaXYQSv(b_Og51S4zTP=XCku^!jaq;XCFW-V7IW9 zQ@vF>u~k<#7=*dApjft?(&KW4;sD|i!;NqEGjY$>P@S5GzAtJD0!CR1@vo^Pjr~OY zA1`+|&o+5gvUB+Oz2dzYB4^Sjyz< z16)}VwXD_>!_BH?sDCOndxAcf!rGY2IvG11?J~asX(MM>EZ|>$?=$A1Yoqhrt8led zzQB3JW%o-_IM)YuFu-_k-_2@l{^0oO-uWjPm)oPyNEv7kmvvjxoIXAD&9Fp*oI3)H z1IjArJX?;JAr_4GBtc)Xw2b!T{s(oMRqrz7qx)fUx&Xn3fm3;GAr00jh!LBvTCy+%ZiGyQ~%!m&CK zX0itY>FmV?e8NxaghhIi)D#C(3=bCs7uoa_6MhILi8&F58jzSyjBB8OVv!L4T)&?d zqL<<_=>6@%-Rzd<^MiNR?P2FYgy4e^+FG@lt)m<#Lua}JXo<2t~MOluk!cjxd6+hN6^IcM*!rPbyDV) zhwGAEqw&W(4<11g6pM|WXQPjxHLE+@Rp`0T#Vnc+V-1g>Osj`m(M_34`>MM$(W}Kr z5OEWPL*{??=AnN|HDDU4iO=*mYJL%u_ZKP*`U&$A5FlB95@Y=rDzs0e!CT_y{}y4u zKc(znAS~wJA2Hycf%VUa?EflZz(2r}y67+P{zanZ+SMTZs=EJV#JJ8_keg%DNnxE+ zD++9BG^XvJ_4ykwQOPwrj8AqwMZU9!VkP<)aDNjq;CC6b6V*K-6;Sk)H??XGSy(B> zdP^M?2Q<$ld z^v3eRfmv{S&9meH!Qho)7@BA%CBZ&+Tg47_JPp`!1%WNi^C9@nPGAcvywq3!nBjTS zmmHD0l^%=AR^eGp6dTE|)lpY9{dP8~rM9+P)G=sQuhT+d2GKfIrJ(eLb^cc;A5`3d zKPF%8|Ii!&{)t}rQ!V^^l$ri-WC{3BApT9A{rBhv;J=_N{~VM5jjH^AS6KgHNPvHN zenB-nbV#KBfe!yCbg6eVDd5F9}+m_yKL2@@UnX#;Orzk zFbol8TmvhEEvTdj7!tv}LNF}#@w^LK|Fz@{t1ZAnz=cU_xiCtAtdIJX80kZm9m>ih z$o9J{lffblAsj`5UI=R3ek5X%NP~pb%rlG+U&}@q+mj;4;aej@u?M#zkq){}(cNPQ zYICGPCF_Bl=uE{@D12~lA)xhkt5?s?g{AV|W;X`%#L8V`KF9p}^48DKN4ql1mg|cW z3;pzR#K6)G;c1%+VD+%?o7pfU#7JvTQd-N4pleR-u>?B%bVym-*pcC)J$_?#8bG(j zlDr9z?P90UbE)lQP*!nKUnd;SKJw(?fH6HTE^Fg*&&X<#YSnl|>D!K=w5u#j#k^&* z1Ytr5YA_Maz8EP_@gz?bUEh&KEJZB;l=xHF;2@cx?;M#QIR&*JK_TRO>!Nm@5N~64FBn$ zvRiB+W%qejPzylR30Uivxs1rVyYGGk0SE-*E^~M~fBu`OLlV*J+n|RB6t=*vQl_du zpQKpg0nV-v@9%Jp5Joh$jQ{?iX#ML)(C@Uiq9zuXcK-cAz#3{aOsr5`9jmz!utJ%F za`m@I|70R}mrXyn^bz#u!@o%Vol>dEe}Suiohjh|6R!Ssrv4cJ|I1wc>r4Uv1+4yc zuKsnXpc?r9*8&Lqe>1KAWvKo({{IaEX#AV5pxBg}9MMWD^ZO|hanCGHOecrS$!;Nx z#E+K+z2_fs&t!G{wnPf|*Ey9iuw;NoLH?l_9@pa`V@`(Jw=@?0?w3D_-dQLXjW>VF~!JegyuV zFaKZoF7SUu_5bmUqf8$`?f?_dvn!p`(x#>0k3bHDpH4H?Wdwy{^A)PuDV~A&98h2X zfvC{yVUD|8;}fxS#CJ@%=?^ePH9%`;0tvxw-f5*--%IerNXUhWwdbI%MWh*Z0tN;T z`?%{6x3AJ?)6ULBEbgYbjA|_K8Y6{Q@WU>29bjc0Gf4HBzR;zKo zlG#!>jXuxq(wOPO-=R30dIX)*sM>b!Q{C{Mm*G>K90B`zkDy)YvhSV#6nTJr=<)m6 zTnMvxFs_;y!k<^7>k|x)KW(HaB+(Vz+DFikJjKoSBWP6JX6@uF;%#7}@inr>gLU++nKaic}{T%6OogEUb) zasIMr^{M=^G7U_g$=R7%t+(A<4aLw`toNa7MGpZdBHn6Xdw@Aa75dYiOJ; z=Z3MRj@(pu6YsKY9&{fo8s;Y$na~zs-Ia}jy{}>sa(e(=)^U###0uAg*(qEQKJl%) zc$ak$H`dpn!d4u3j#!bZUr$zpD1|ZDy%}06+pP1fabfyj+SD~1u51kWCU21#rP^qH zQwj}$A?!7K`*zIsr=7ALlA?=(*BR2xsGiZNc+Esob1dTKp3##jF_0>V(K>n# z?#)G^E|6*OgYd+?Tihe)1-G%*BS;T(shHpiqWK>1_(co6FH1HeWYp>2^r8vJiikef4W*6s7HL>h0j<_qp)1+~w}{@Jn?H4^ z=jXD%j8Ex)Cg+_i918D6dIXtp0{Yu~c9necYP+rqIO;}9$PHh#fs3TGM^Kjm#c;{T zzG>3-%E7th)K>`aQIHw3$&^&^B1Y?2UJz(Iq{Ty)6R~zJ#u#QR<%E^3i$0;%uwzRP ztI*I8}3E#uZ`tvK%iO5CRIL=bRE$0y$CIQZcX=SXEljq{xPz_I8DuAF2SqR`2i zBPw5;R7Q>#CuMLTVspH7@`||7E!y<-XY!`WMAjFVm=`*(Mbj^s?#LPEUkMr2Mah8X zrRU)Um7hn($7cw*=;z$Z4VKI=d)-_h5%5e732QI`6%LC(mla#As4SjAk#6J^<#=f) zWg`t@otMqY&K$aXiR!VqwyJ*a-qTx$_daiaGo%tlRVT7|zaTt3qaf$Yl-eM*JY?6C87)u{;^&+ZwxXZJ@g3&&$f(7WMKE0YXKagoBjxc)8!sxeKRPqBJw!H;HAl*hMVM7{=`iO9}L?7?qa0 zn9Oy!fNn!eZnO--?DJ8#J_NePZL*g@e@&Z}iwGuqnp4o6?5aJAnB<7$`#XMeZz#Sw?7U)+1X%!6&Bg|*V-e*P4ljVctPSXEpd8h zGIvkXA_OicW1Q_+ye>4N#>;e?xU758a)8k0QUYT96xTSqc-oub?tA7+{?Id;L|uw4 zt7x^CNxXq>Dg0Wo&mTs#h~B`wRynGoGZxb%UNkEa9({?C%g4lA2Y_T@nElfMZ_%3z zbxim#D=+9Gw>d*|UP;STSl752tCJI#?z)`oKvgdidBGz{cztkFUI?MsvpMvl2)HOU z>ivGwpU*6u$3{dq^4Vy4$a4sA;TuFJ+G+ z8B`0Y1{G8aBv@%|SQ#=(Q=nicLctgN1^)a0cJQaw=K|EEa6!MWc+Y}D`F&ynvtT&d zR8U?qM{+^Dc}Uuim_9hm7 z6>u&JL;^b;8s|fxV@;YGhDj7qCy%cWEdXg&KZ2rMA3;X6kD$p2ojG7$;@ojhn?-aJ z8Vvj_Cwfk!bzyuFeNS?u?YNEwb>FmulDfH|!mK=7pHU23_=mH`XaNm##fx5yL09_x z|JAI(BYTQpV#8?L1=VpNaBk3az|%%%k?W2bE)RvN4sYNKV$lXrVUVg7LJ%{KCr&$O zFM<#Lj2*7Pu_ALNV{)xw)ORu2ng>F0r!2^4&xL?Nxsasy(=hajFJayO$AD4wQPVoA z#9u;8Xa$c8Tfw1>k5e=>ln!P|+oB2&32x9Tcv9R<20WEDiZ zEiL#>q}*pl^5cjE#BkP;%Q?KQG)moBi*D}xr^=6Kz$@dQggNw=;-g9G_jutC;HgbM zJE#MQmbIrwL9pBV@Ure)LhGQ^gKjR=)d#YZHjv7hN$+|tAunW+M{(^1)v6$_`v{dS zg2tki-RIJFXkJZHqNhJa@kGCB3~sQ}E82I2p1f9f+nGbx3|dTWDJZR3TN;UC+n}Gw zL#Zag;AZ90k2NdKAHp?PC#+BUn)t*5NL7S@^c83H=Db-zSKRtW^1~DtNvc(I{ak4a zNwlqrXHw>$Hk7DEnx^~_x#7Ipq>Qh95qFF3m=gFq-ref56<**?P!R2QSxuOoOT73w zB29De8&yi|KT!1Qa`MQHD3AMH2iugv!^@KkjR!m~f4XVfJwJlY{$~~luTkfJ(W4?(o(tNb!0yc}O3WK=F^SI1+-`Vh_$62I zTW;l8iB%-+Gn!KHcioNZXYE!6OBQOYUk9xRDN-uoROhPP?%|>&woW zk59U0VhA&im>yNC%Z|^nM#{h)R~Anfkj0FCpG!Olk=u@sqpkdQvC=ogxR29rPhF|T zPIzNgpx|ug>`24-VmKRnxQGyX>Qa%Js25QFgb}J~!kVFK6QKuUR8i+Y)5JH z%jKttsU&264$6-8fmsbif;QjXNB&x(kW=oAM>Bh|kM6268+yY%Tn9KEuf2_y^dCpT!YOKNhBn%jKUV%ei6AoVbQIc z>_m?^G_3xkC^KD`Cq*~KsNLJSb|s*cLus2(bSIV6-?FClqUuHBlbf-0JdVbnSc_kN z-e?ciHK0Ds7Kvt;8${vl6OcKCn@zJLn5h|6_o_!p#Ogv~zr-ncyYr7WVMEOsz~)o2 zH<#wV6;~kkTU~isL-Ng<3VXtoRmCa=jfVU()RB0mcTalZ!lwrN*LM`mKTH+uukPeL8=qhQ8`gg@_$kOV374S-k!U* zoY4HKcokN^-QG*u&gm2_b51dVfgPIT^GbncRJ$kcGXv+T!shDpmNDf92K)FOZtx)# zewbR^`51N+HvNkkQ?~NE`rzCcaVSzS(B#=Pc|45zKXN>E|KZxI*BKyPfUBmDmXuQs zPX-98PkUse{Ab5I4w^XnU#GC9o0zUc!sg9v?MS&1SKp5_q@4y|C} zc-rsLOXGCwBH=R~APM+I?t3FYQCcTY*EURgqTpo;f_X|q)1hoLX@o?X0xz#GwL}`1 zfLP(`%WIeBnrml;Y$mdsizFYF=3yALoZ8~ilDT0+9cCs5;>5omM+8~c&Rb|14z?F> zdT*W+_v(;s zDhoK=pu^Fe59aF(6>78Puh$#(?6<^jFO&QBsc1e&Cg3imAulX}L#Upm5x#6urD zND@PojkgkQ3ugnEiZzN;?ID1Akdp34!g_MzmCJ+a`#gvBFPA$rMGf*dQmuQZ@)Er) z^5vex<+2Q<+27pDo2v=~=M~(MrdmFswRB&Qhm^}zyp+SqBYbdzs}8rQnPE6CVsd|W zbcJhy@$o~?Fsi+Be}&o-j=)>qR5F8OGR*l>J09mnMI4st7B)k_6`V=HXI9HK)Ul8ETbo#LEtx1MO$kMWSPePYd_V7d?~ny-W$ zmyRhr$X@PA4Ipz^=R!tdCgZR!RiWil?K^|D@=Ns`v2SvoG6`BSh)#bbJug>zx~sOY zo#TSuXDc4nrsd#tGH^jtoViSt|7-V;!(2_@zKVLZ`9?r$6&iVrYnlrubidt>??=- z?4>ns)s`J!4{h^F9h5lf{6TFKgzEeb&9GO`eSRd3H0@amL zpP^hMJ8l^enOJ#7`8u%+?-O3^L0WI(xX$FM!nq)t(fr@Em|C6fTr6jR1*q{cI||M# z(5tO(ou$VzketSuecN@Dnnc^+(5vQX=GcurocdLAd@%gSL&9EA!Kz{b(dPyE!eH2f{~VI6`HLHk{ih!d^)Vyl z!MXKGQ&G?)k@|ng5-B{pdzSHmS_QM?<_AiGeor|FJtU~16Ur@*m<^gXZT zu5>=vVJMG2&8}jE?C0{VdFIC-I4>MJA(^&&n$4^v>-iyVWe4Xo6Z&x4z(cq@?J<$JaH-zIg<1 zQx`MMq&&^KQ{Q~H$Hg9}34e2>OOZC|{6n20bpB%%U_o(=rO#r|RzC4PL4Xv2)id<# zHzMf5uqXQCt-J_%_v(Yn?Yi2u^@D`uq ztK6myZne7#PXUoI^BnbYWCYewJ^I5neN}hz7d!VpyN?czVKnsvm1*ZKMDLhpBtBX4)S-5=|$932OB zRd+~0u-F=A1%}6}yy!aRT)92HLie1|4dh2u?}DK5r$^8m6!GIrv@?L={+RLJCCS-O zy~->wFZCSZC-i{Di-W-jSOn!v*cpN!3WENWfV>Kc+-vTj(h2_jDnR{1cdL*&4vdRv zd*9ry8yV+{|IskWPaYP~4~+_y)bCa)6G|izObdE%zZEC?McvNya}V*yc~mhfjaBLH zyRunqyl@jOu}i|DO-PUKb!V{d5+7m3;^2Z8_B=N6sZ~a2YbUs}aC&%koQkZSkr-o` zLt`Vc#Y)@tXUZIks!Yg`qWYASr8Taa6zI1LnpmOQ6T|xl-oMs|{~T>k`w9PB!BG+x z7#a}xd$G}fjASwXk>UOO+`Wg!wpcip@-OjT4EYt>JkurR{q*!)ZS6#KI!V=)QGsuq z-0X}(l1$~dzy=mOcrs7z`@qjcc}OdiQXn9D1AAQsUsCzRHB} z@#z5cT_wBtAlnU{rTO`%5nmse^Bhkc^ZEHbN9=)sbx&cri;_J?>tCvcD(PtyjItJ2 zHJLTc9Ku+ib`24oQ>kF;`<44#evyHpqavc$heZ+&8{D@NVflz28`-aJHSmTEC%j25 ziO@KBSLu-6_*xYh$j*sv(tUaBFka|1)4j@tfC+IRX3bJ`??Gs>z8cAp@#M65tz@d?T%G~{{b>#P0VP#p{cJwXtNo5ik%`dDa5RD&?4=HZhtQbhSf z*>GHzdERDXsLg8WF3wsbUp~1v&>+KJSn{);lNDE2%3sOWdK<(KNx!g)Q|%|~?{anD zdcX2YvVGk*bGtBbnvf`!ugi+xY&L74s9!KRxi5@b^?i<}6X;N-pEaq59`+f}zayd1 z)6=~2iYWN8ECQP9{5|E~^ksSjYYvcYwJ=L*Q_SN?cE)O;px@5A1zcRKaDE_4v8R)4 zrWydu@IJ)9juEWgf@Z=v1EW**tK6L$kCPm;;YvgT-*S?SBq7*;9n4~YyN~%2p=9sS zcwBBb>CVt{WXsHKX*4r2dg}M%QU=|Eyr(lPR9??epqRXC*0Ir4hd?RFr&`@#1l3G>VRK)F4`#`v~{l>h^JZ1on%cU&nDbfLA z%ckgfs%)ssTw)F0q{}dkrt0!t*RVLPJE;d(cX`iew*0paxD;F`pM@SltX`Gij8N;&pE1Fu6)%2!mj0}g9h>{$c-d@M7fjnW2~^$Ky) zWrsyH+9>@g<|~*(RH3HO){Nc{e0O)Tpe@}2R9}uG;gU-pbn8?8IQkdJQY32rK@HF& z5yptYxzWGW0|(!~W(fQI!Ci!K)kQUek+}70 zsZt2ImcL8>7>Mpf;At}&YQa5pXT-kYiK%n^}at8(Lp^-LssWX0fb zpIh!NRIE(Nu54wtS{Kph=K9r!O?D{9r*H**e^ZpwVC1OBB zZXABcAr+A@o{YMR`1QY`O{b{ff|DIaTHNHmb{XL&Qkqd5EDp?)hZ$wi0k$>CnH?@*gpa5;)d0f}Tw~MIm z$3&v5XaZESaqP&AP#i^$XoorG2sgAEh}C4TyEBxC6c#ezjoW6jS68!=(yom1^|(=J zK$9ck+y=FhE~swj;uAYYxW^4lc9T6`sZNvUEeShf|9!jpg<|Timiu`&Xn%@9xbiJz}HErXN%LI^IFP zF#VU{b0w@tkiBRx_jbLuOV_k7F^h$y zFG6EOk!-D>C1%h}S7jsSAqvw0evc&geTc#SK zzwQQA@rv(Q?_fUPo*V;A2VD2sGwL5kfyNBuS*w@}yg~Kwy`#ud_Z;CAe~6fk9nG&* zipkL zP0)#Ut2m_#GUmj-%XO76XJOm$EMod%(bSTy4YyZroNgaB0fs8HMfZhcV$799z}fRu z-JMId-5IYRic!?yo%l;CF^ZB>&O34F78Y%WhbI@k8;MPkD6zlcGA|lcHL=q8*1tt` zKF5*Fb}+ZA^B85D(N3jI-Pn9=gQ=rP>Jfz8Sabig^T%6RA^Y;3dvoKfqn7XTB2^04 z63eqkZu`LIM@@HG%sI@TvnM}qeo|!4g}aA0Eq#d@%PF7696}dk1x@qnl#N_wKi@_1n;&_2Cm2 z-}hz9t@3;gcA4#+Eov3m`~2?GvH^ExdI!?Apf7J8N2`_;(^Cu`RXnw=%p>s9)Ew5S zVtD)81I&wT#l-DPX8Y0ug_fRN=mBE5gH4$R0b?QyI`GtJ*nSg54Jx=O&6d5gPf(*d zZ2?ur_qN$&AflZDQK*ia27~j*h_Vs>#NCFE3si4e%WeF0VNU`_q4nid5q%5lBZzcO zS$>JSDXX9&5M7H`=ve=jUlp)khm1ngm;cr!>bgcRK6=|aj% zmitc-AAAsnxV8`*S zf-8j-Hk^?B9qH#V)1t%`45M&QMBelA`1<_`}Km*B$MDyuK0vA*IHK zXG541swFDKf&Hff?Vj|6YwU<3Y)qjZMD=?@UK0sLMwOr9sF!mFTM%>pf*>OMg zu-N7BAc&y*naTNsy76abA8b^QvtQ+xR&6a+mu?kA*c8kb0DuKHOY95fAN7QRa4`=) znvIS4`&@yWh$GVIN$Wf!ne}$`u63d2488(2;BlZ$hsCLpqrbz9jVSpE1q0E9%8nkt zLY&L2*|@pk5-qgv%GZR(YAd3xH0>G=R^MAeryFVF8}GQZ`Ahp$ntEpofSnyxblP z2jNqK8 z=oJKirepH`@T$Ya$4rjY`oyOXyYa(91|#0tZx+Tm=5rJB)09jjBXC`|l3r;O0qf*U zTa}+9QEgtmFSbn78bsk3@O}jG7uzrG78m%*vzk-aXRM)puW60Rgww3iWmq(|p%F2M zOn-}I57^9plAmfUs?waITJCEirsDEEMuBt&ukIBuS4=BM_d0&T7=5Vqn%Xn2UHh*o zF>(v6+mLV1u84Z2ZXb!Cm0Du`O{QM?0OEdPcePRCT`~ePUHZ56RrR#L=%v?Ad zyuW@%P8fWWx|5R){k5ZWeM|ZK%G_GnWY7qU?u)hnHsIrVX|-4^`he!O^tK^+LXq2e z;s{Ygq-p6IZ&JXAOeA4DkpUjPL~R&TQhtYbK3d%!+Mi+#`{EY6vgMm#sDL=nM3mSS zUq4$^UuVHwWL&{&7$;>wzRl0}ipso>+`e3{!6Q@CH?n14>)>0+GN*TPayTQLpzuTe zY!>VMxB8Y3#Fbg-1-E^cva>J&xS4C4dM}z95bNwxa#|7wrKORF$@0#gR5yR>p7L zxwpf)-r)}7k&5Vv$w%Q-7HI(0MVMN5C)v4=maFWfLkit`*woEq(!pJFVSXLo<<_Un zc|KjBi?dW%BtVX|=rq&KFH0{4mR`!&Aa&7Fq?qd%hMPMn3(TtTsiQJCYrTtLimvS4 znaC0TPGV>9zG~jF&ae^K41F%}$_kW;nN4b%5yR`rHd5Bt#1yk3d%e0pM0kEN2*`iL z8+9qIccBU7L`mOn$x!au_TEWgC2eO>M4*YP9wI#ppYI>f{QOdTUiU>t|CIlmTk_fR zkTkA$kY36_;Rr#e0Xt4I?%0zfa>XZvi-b#$|KeoR!Vw&S)ET#J=E zNyu}pyxK_ml|prA=v|YWRBGramO^!vt3peP7`}W0+DvD7`WNM0?kJqj`-X#%cInrw zn;~P}sTM1w6s;W%AL)t%h$!{QUv?Lo@?SFG_55s;j{WqtMSX%uy>ca;NA9krGF-@v zDNME(ixDiMkqmfx8@AP03dO4E%Y&<2%?8eXm78Ly$WMlhy)@w43bY=Ll;D7WLcV&D zWq`kc@4;DKN*gJ&e)-MCuZ*c8-w}5A-po7O z{<>ynPuwzd{z%XpD@N87%|rn#EX|}K)KF^R4Swm33&eLbygKr}x@YFuvP-3{6ekOO z7qgbYUYAX#gC1#f*~s2dV`F}u|DN-%({*QgUmGoq#q$Z_a4#-4z04P)H*cjXW}TPB zBDmxg4LlOYG1D@=&P!Y}Lh?wWN6hSPvp%jYtDSaj(qe=9d3uJ4Dl9ldSh}7Li_S%z zFr4FgYylN1S0hZ`7IfFn8H;A&{_X}UEs<+VEog;?rFEb_d!k)Yp($^dT|t>-?b@bO zB>c}*(T=P^XK>4Whq@P&>?*=(BRdCcUYnw>`}fRQ71oVc&x>P!1=SaZz}n_c-(^jP zXc}|w;3=DUETPOa#q8+?nyV6q!x3W=^&bUL*cV`hHh)n2Rcd@* z;=@eE>dtCfY?~@oS%#S46tH>mJ{Vq$ex{W)H@|#>b54i^FjrWHb0xSH_43CX zZxwp2Hd}^K+6%AKWRIu*L!q|gMHA1-rz4%L@wO7P{QA_EeyFcquD9u?lWX*oKskvX z*&^TuLuOz1iX5&(3{b@Br#ydMQaQBAs8A89XTl^?Fs=+)OzTM<6}Cr>x+Emdb{pA( zPt&W$;3S}K)Ux@Q@}Y>km1(*@7Ax>Trlp9G-uNR<)KBEXr!uNCU$w>vs>>(a)*QYZ zHWd?Xay@a9L+hnM%&d=(ugA|l3%7zWO1kh$nw{gZczCL((*f<}e$g}Avit^Ax%Iin z4;B2^ES7iDq8Y|P-TLiCY%zVJOTcll`(DL2{Q}-v{_l#P9qrdKu5?28h@qSJ9rU~u zj+I>wDDZ}5Zut@Nw!P~cd}=c8MaaN2&g1({xl(#E68X(c@LH)az{=yhO7!IuLUZj{&Tw3aogUu81`yykuN3w_|&`$$2?_v(e_wCm#FNWxwaj?0_PO zo}qi!Bh>^=poBtA%d6I&mft)^wb%p2C%}sIo7IzVU=S+Gf=!W|`V3c)lTz2s^!c8Y@dt@H`mZdOqFVh>5L^2ezMu?XdOG(@ zlqn0V$!EyavS%zwuN>$_soQ*H2I?A*;m3kpJ<1L~q%PMTTPD~C?w(cupxQhww}>br zYv2jN&TkUhSQ_6xRZ5%`s@Tor{%rk#7y}t8;hFmUN#oN^>S0bp;3|7`Urg~qDX1i% z-+69e+;&8wG82QtGcjM)V9*hzABBlJ96>FB$xxNiE_`3sEZdE#mol8V5QzR{h8s*Q zH|Y`+7c2ah+dn#d5}$e5XwaQ}_pG}c4T;GQspL#`#Q-_4%QNEbkU1ZJG4WRU*Qi6s z^mHOTr@WOLwO1{^xTdL*WN@%ZLV=9uXiD{_i4YLS-waOEoaQFTHa)~#Cn5wTMq^rS ze#7?WdBEHqCKG-dpk%-QdDsDS-7c=VzPT=X&>3~$A)MpoXGn;zE}I#nkQ{a9XiMd= z?qaW;t&3*&fc~IFzjc*j`|-;J*Te|gw^4UzLQo-LdjrS!sj*F)>|GGWa2r)b;nn1~ zMC{x%zV9$Je0+#iA01WJ4^2ro5TNoAY5T5~yac%~Q3Ep<*lyA)8L>3oQx?n(pmpQB zQ4e{w9Q4#rd^>agGm_J!tmry@N<*j?&3C3Me1#7OFv*OneT?6q%R#`UN>qApX#;=QX z7hnp>VSZ--?M0k?sBu5F@_^@_W=(sJmt~4R)|V79)gc>tOVhbwQ@P>yp<1%~MGa*S zxQjfnAU``DMFK1N8GT)jhOY~o!Tk%Ml)R`72xjeVIP9)BeE&Hm8Q2w#FqYC1!+izQ zg?q{1(g@v;@!Ph*xW8`;i~#;~n9*tqtw}*nL7P2~OWh+IH0vTCJ@8T*rIepOx4BK1 zJs&@&S@UIK4rFd8TFFbCa*LY6U9@j9$;IH{`Rk>(-?+4knxy0I5chTRpd~DjZ16ga zIs$AG?vWr?a!hM!R&gPTE~c)T=rNYYl>7ldzm93=!eQsmswgxId#T_se*!&P1-9HY zT%!#`YvG+ikAP&*Zf+(nM(=46^m&$du)k_>`wIG#VsxN~#DHu#6qG!Xf|H>KXWD?m zhx2IX-yB0DphVgnAfhh;3Rx;9D$L{+C>hg8yrfks?3jBxS}y_+L1-YRxEfZ&3KPdI zn`0>^^x*(3^|Zgy1w9kSgS5EnQqb}G>chiNT))`m2R~^3rUOB@pD_2}O<4_6Q?UO5 zRMr8m;{Z31Kkf~qQE>DmqqBk(91d>tUn&uy_6rD|JDRf~HpGW-C)S?b}Fk zQcgcVTQ3Ki3<=5an|woDx;OwsZY<;pD{g%KZ&l8}9N~~(d80?6m{q%JRsxb0AMyux^eu3bRlB>w%X=!y&bxw&NAtvIH+It#K zE+DDm4?rg*?sk6*=gyYD#6KodINOSQ&vrlA=a4%I%QRA5)Xi^|l-d>W%9ITlS-Pql z+PIo)E@0u>|O=YyaY6QesnNq~ADD7PC zh1y^Yb)46y?03Z%SC<7OFWUtSS%}&_9l;S*3!K{t!}4eYuP0kgbvC`vwyf)wsgr5S zxAO?tgAj^NH$zV17M)?zcLzi+@vL#>K_3chK<> zYcXwT#SVJjnQuT%r9Dg8dUGO-S(hoj`>}YM#dfc3t(!oq^_+oKifIglqZ)* zcS3iq3P(3n0$T42ne(6Wnn_M|!TIhi^E!(ts8&mXOdWnWZx2#!M;fd3CH$wkMZPmX zvJzs$p;-`;?tVq8d!h&QzH*zcGQ3~bson@bt;JkL551CWZE9+EKrZFAlxd0KF(ULC z@3`?7i4dT6cVR_N^?>YtH}amryGhKAhZkT zLC#e1n%tN)(W$Jhsp)%6AcW_G!h!*7hY+d||9KVu_DNcdLVEfKtHuTX{o?;$w1c3I z5QL~cZZygS?!~0G zun+`57cpFEIB3LbD&0x`aC?G7!Xzcx3vfS$t2I0ylNM`lynAbLc$&F{^ON!?5M+f7 zo1HWcLO|d}08@2o34;@(ud>YkA%6J-41xTg3i}5}E;!dU&K**z-jXdWTUui{xo3qz zh%-{=kO{w8+^+i|EcqyB`6#l312I-HtEAMPcs^-e2*yY8F!q5@_~j??PSNW4?T}TZk1KW4r5wd5s%3*@cQa%O$bTAu%R7a3Z1r|1N0y zFB^yuL4_1-+X{3%C^Q5aM#*=P%E#~2*R^pjY(Brdb)){^H z(PY*a8L6-_on;N+;JcAJkiVpJf6>}x8PJVQ>WPg@v7C2@9y`5cyN>pRzLb5x>w+64 zy)`Ix+wpEs0C4nXF+e6{&jxoffwb|YOvlUIRLj-y)^H*zXSLR*I^>i$5ZgI^&IcdV zx~BwY-i%w#HKEV-aak#hc~QrGb|c0DQVKtOnefcQ@e z$$ht+7c&whixC!(SoBvR^Y`)-Jl4&VvZImc)f^#Gul#YVANg_maabZYJbPkKAVU)* zwp<#5vKYN6({3GJ_KyAIzEn9&vy4lCPEmrd?RYi`^IoQJojV1re^HcO4#M(>ZSn`o z1wV`oh?Yr4x`?jcvl{-=-sH?+V1@sN~|2(%_L>kZ0ilC!9#uI$$+ zr^}WV>ZgA)Zbl+p2nBKUAluu2M&n>#JlgNQUr(J>78>M3be=Dgz_{PBigM}BVI8$s7Rc4u|F*H7{B z#5|uL_p~Wq<9LPIG$g*o%EH|EDeb%e8{zY1v2ED|k`CRbeH)Fd$j(H@LY&(rP4IYr zw4%%RO|p`x=1fJvt0f#=iQx#4-KhR!tn;7w(f_4r+^j@fR=WzFQ+`S9HFvpi2W73E zXLr(`T~Y_->)Sji=N3FFz!&h4{Q7UFOyPy6Zeh zq#&dyy(F#sT7|ja9605v5m{-E2O5!nBTzBLtt`vO(ZPl@HMqZaD3)?~?4C<~P(mq&mYQJi~>k@Q6^d^})Uv;oAuL1Q}8uwO`rG~yo zM@_fV%ssn>519{ZK3;lJRyuW$u#WU8;#gyESr3-HwF26pVN?QwrAa zwySv*Hi~jW!OWC@FvgUu+olGzyG%c9WGVNX>@qy&w+UI*?OPM$CAlb~u1}~~w#x4# zlMEZfQQfzUT(XE|F3w?QiX^NTw>Ted(UiF&O<3FYn`+jJaIPQBf zas_o%GJNUQhIMRT#8dQTJKmZX$rP`=b7t8*x`>`WKoltkkcnonAh;ibQjnO6$u-f#h2 z3Li4slMVEJqAYdpw1l_1q;}Wy30~~(`v$klrhS$EwB=@y-A$i#89gn~ce&be1uhNy zerg~+yZ%Vw{9BFHQ@gsyA`?S?Zmu9`T&XpP$Xz2D_8hzD;=_3AuLXNby=YFbkc3rZ`HtGRA9SPU}{Ew%Tyb@M;kiG*B0AD1DgelNAN zOTQ$CP~|7#S%U;xBxPxNjizsPHS#kAybxSvsASO8ND#ts zAs}Pl+H|DkS6~t>?rYRb{I$=`_;2?<`-U1$g3~F8{Rv`VG^a2Tb7b z3mG~&yK10A`PT}>s{ zAng?{x_tN%J`>(uyz;}Dd~@F?kK31$=s?NjS=p+aE7t7>Hx8n3cwOWtHLq`$!=6hG zQTD2EVV3oHugU=%>&aezmuszQIp_UOnqNeLRdpuKZz5l&HK*%amL$$cs40e!*Pm6mN}vSd_Mrfe~+;CBRW-eBCEMkPREKqdW}Yt-PgMgM;ko7xCKr^{W!0FE`_M#L2r zT8{6*y{Y|h*f2lb*{6UP%9Oc=)LaGgDJyecXZB`TdgiM5bf5Gi;b-_L&Xv-cZ$TAF z%7Qb#Vlf|AeBI%XG^%n!PtIb-mim```Jjo0U-A5iDHWSKEposOK1%WIvX1*NbKe-rRldRt!avTATCx(?nO$f{gCT0-9s+SyR0H%t?8$Lny=l$ zc&Vev5{80_LD(^J_!~i4Wv=yCF)muyerLjGC$-Z(^^qe-rvnrIOw8ASBU3l=V1sNO z;6&m%JHNIEd}}?6?%+j32K<-T+f-gepFTp zS9nx9c}iXym{-O$76bvz>v#&aU6v+=+Q{|ZGNMTLQD^FA`d6AYO>73M==A%PC}tB) z&4j6t#W@OvI`4!=*QyXi%3IWz;w37TbiY6y0^aVTsw(LXBZ=lZRJf~uOZ7&}U^5EZ zQf~Z4{Hs^gafESReyOX#Nh|*aBHGWfW1|`5B82loW6!!brtc*IX%Z?6BK>iCS1VTO z#a^b5IXLfbr_rtBSgTaoQ)q8A@L4;6w~{{;^%Q-Oq_cR3GGx6{g%rPJc|~VdhwBRe5#$)G-g5PAHoWJ|riBM&@FcQ= zF6i5A#FOeW8501nZzFGLr&?{?U51H5&ZyzP5l$&jDvV`JQw9fV1Ss+&t>QK66vF@P zFoIIPc27_Zs+|%fWSFq2IrYSiMET&|234HDj+;MpyU#Owa`07-8lQ4pn#rCr-`SxW zjWfx*$CMVV$T4BmOLHw&-8@1Lg@kt>b)wdOp0jYl4;VwPi74sFOg=Ai$*R`Oi6-L~r>*=6rGoKnr?Xd;MW04*(xA4TiR+fsSZdCa=2h8}PM&xZ+KX@}l?o*dTC z1q~5=h$6Jvips|G`6oX%Th!_3cDo}DBbWAczMu<|*G2XFX?CZ3X<8$p;elFRajy}k zomBJX^PzI_5mg=wp|V!$pVp2D&}eQBo_Lz-i6q&k3ERo{yo$0fu-Sd@PfZjxMCDE! z^T4dl^^ga9SE_dDuuY(G+WIRoOwoWza|(|IYTP?B&e zCyF9pYj_DnRhU)TiiJlx(Jp&>hwhR|mXxoEDy?ZE&iCF*SErCAxDQkS?4t@y^sIVv zfu1R;(~~*REKSk)V_VVjr`JUbc=bN|Oc16`RaJKvE)}O}rOaRi;5@nwt+Ph_8mtn- zxzJn!KmRaC3n$8~jn!aOo$lf9rb$8%j7LfKLibuw*sZ8)g6@i^ks+Xm%;sVMH*!2kY1}r2a!hIO|D>^UDrRG@Kdiy^xEGqD$8wL%xD4_P0 z5vEvy&zld*4w{ zGHyes)VSIJM_3q~`-T7!PVor|vTUhWF?mcQ*ryh?bNb%_yPAbQ3Z7kvRwd5~_j$E- zg!L14*}RxtDX(+?iB@e`Tl}J;afE>t_MZc*55@p??f(rE7WnVP)j{Sq^*>#6^g1b7 z$I}p3+AMcc(H`f>aE+xlSFh_mK`lCvEg4x;GyB{@QP9S$auS?bq%c`=O>2_K7*23r zxaW&sHEFIDd{aP9a_WChwD}+j!ir?yerRyJ%xW*Zs}F+TgGY5{5fKt)-Aang5F38+ z@zUtp_5wy)Kf&fsRSLiB80xK$c$V0{#8n0zSdGDM$#8=^drsjFc* zUmlyD<8ZV`IRwap$z%)LnYRmSgZU;`GP)mEruhB$C~Y6?OOBB*?RHB*m{2Mqob-DAn#Y9r*zLYOE@@G z)^5EG#Bz3glfVj+QtZhrD5laOasehg?kw_xidL9t6-WY{PpK|?uT?s|FFC)Mfs|%~ z2HGgae6^fR>bj39i52v93CMKSk?-#pbQl2i*iq$JjK&NpVeOqQjI z5X;BuR8SJi&bI}4t9vmN66aTaX;c<{l%9p}!z?)}4yz0~v!$H}J_n;7NR&u29YsLe zV$z|n4(+%xf&%7w-02(a%Uzq@{UX(W9`hc@01>X2+O8FuxS{hz5k8;jPb-*ack?an zTqnNww+tFr_~)@k6}}=F3U`Vexdblkd-nH_idd0%^FP)Q1diC(rn@w~%d2 z6mVlE;pLW@b;SItR`hynCf6e8TK__MW(QL+Ve?G|{u`FRjbMhF+ zuV0V>r+z4JiH541DS6~eq!1$@5VFt6ab{n_ZVH-X)l$_lyZl>Eu%Nkw@e^`JJhQbb z>VtYr@bjpe`2qNyg9ty_gm!gN!&fHNoKTrf&2{nPUId2ziW(HaO07+$b5%Jr#b-r}*azP|uZUMd zVPzgjTihBNRlrq(ia`j~5|i-wA3p`0;IB^ZtgFhqL6y5qhzaE~MFLD!dRX`68XYY} znz3i-l#$xQl)W#!f|n}Ns_q~)Bgm*E`x#rrL!LgdFL$3c#iQns#IFhF2FLA>+hjFo zdY?02gOaKDkX#%wh zyuyp>WD^syDvL58MaW(*|HtC%WV20zDIJ(<`A?d_t_Tu#8ha`VtrlO(b?bD(wlt}c zE7ttq2>niG*b~x0&$e&W2;!9GT}&J5Bb>geMEkaU9z9Us%~lP?cGC(tgphXt?5Pq| z9~MooxT=@Gc2(omzZgV2$p`v&WlCyQ9YPp6C3lqSn{);7SNkT&c=x3yYFbXEEpynF zwIAgVT|5nCnyUEX?d521OLG^r@vC4n@lclKP(5G5N|&0^!o&|@b4J~0Ri{71W)4bt zT>9(HwT3}~hi|7W!gn+d_m~^&&C-ZMoKLDHiTF+{Z<&7xQ^YAiTbe;$Jhflx14!+d z@(*Q~(^uQxmrKb==Vg#e0IyRe&A*Q7f6L=X-XzqOyFFiL)*{X0Q`e09vm>mss7K1| z2Jx%a7iCdL<%)3NSOoNQSF)x&!)pRN!Seh4whs@oHO^jX_-S7j+aKzRK{M#{-w0Q8 zxp(%e;CXr%b$2+0&Los~7dLd5q)=H@^Y~2-K0o;qvva2~Z3f0l%@U_<90l>&_x5t9 zsq8G!2-0g1-W)m|Vbx=!{6jH?BDHGR*IgHxjAWhl2!3^~4xEeTqO+kQs06UfYGN0( zJ&b^zkQJwTL3{0|2eU3~9}G+w<$TC*gngD{^9`ypQ{?M3Wy5AJ&{#%f7zS_W^r$;(*e~kV z-f4~3_t&L>qfR%vKbiE$aY=@8)YgH_`S%-FPu)38E$G~EW(c3b@&%>r(RZ$so8SrA zQP%9TYj)d0LGfp^o!iTD4Td)+h*H-R^+}f8#BZgx&4}Y(u%zJ~X#8C)De-ql#`EHq zuh?pu(k74})J5mWgeMI7CFFq%GT_7v!2G-#sa!9iK@rZW)j&ZyVdrG}HJnnN7_MFk zQHf6+N^0f0f{W5Eg@%+6GpLY0FzZ7G zo+n-kSj2@F^EtQaoFg+G+WwT>!_9DuTeZ`Bk>t!}11ivU7R$Z1vDjmvvRLkkTy;

7L01bklhjQOt5)84Y^pfkdt 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 IpLjz0FKD9KSO5S3 delta 155117 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 ugM?}=h_*UZ@fX1dxLx(Ws{Z-^XH#osv0