m9fimvxtq
/
minote_class7
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update DateTimePicker.java

Browse Source
main
Sunique_L 2 years ago
parent b4d1e0cf7a
commit fe6d04281c
1 changed files with 453 additions and 356 deletions
Show Stats Download Patch File Download Diff File

809
src/net/micode/notes/ui/DateTimePicker.java
Unescape View File

@ -14,244 +14,273 @@
* 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;
private static final int HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW = 0;
private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23;
private static final int HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW = 1;
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;
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) {
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 {
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));
}
}
};
// 声明包名，这里的包名是net.micode.notes.ui
package net.micode.notes.ui;
// 导入所需的Java和Android库
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;
// 定义一个公共类DateTimePicker，它继承自FrameLayout
public class DateTimePicker extends FrameLayout {
// 定义一个默认的启用状态常量，值为true
private static final boolean DEFAULT_ENABLE_STATE = true;
// 定义半天的小时数常量，值为12
private static final int HOURS_IN_HALF_DAY = 12;
// 定义全天的小时数常量，值为24
private static final int HOURS_IN_ALL_DAY = 24;
// 定义一周中的天数常量，值为7
private static final int DAYS_IN_ALL_WEEK = 7;
// 定义日期选择器的最小值常量，值为0
private static final int DATE_SPINNER_MIN_VAL = 0;
// 定义日期选择器的最大值常量，值为一周天数减一，即6
private static final int DATE_SPINNER_MAX_VAL = DAYS_IN_ALL_WEEK - 1;
// 定义24小时制下小时选择器的最小值常量，值为0
private static final int HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW = 0;
// 定义24小时制下小时选择器的最大值常量，值为23
private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23;
// 定义12小时制下小时选择器的最小值常量，值为1
private static final int HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW = 1;
// 定义12小时制下小时选择器的最大值常量，值为12
private static final int HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW = 12;
// 定义分钟选择器的最小值常量，值为0
private static final int MINUT_SPINNER_MIN_VAL = 0;
// 定义分钟选择器的最大值常量，值为59
private static final int MINUT_SPINNER_MAX_VAL = 59;
// 定义上午/下午选择器的最小值常量，值为0（可能代表上午）
private static final int AMPM_SPINNER_MIN_VAL = 0;
// 定义上午/下午选择器的最大值常量，值为1（可能代表下午）
private static final int AMPM_SPINNER_MAX_VAL = 1;
}
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;
//定义一个私有的NumberPicker类型的成员变量mDateSpinner，用于显示和选择日期
private final NumberPicker mDateSpinner;
//定义一个私有的NumberPicker类型的成员变量mHourSpinner，用于显示和选择小时
private final NumberPicker mHourSpinner;
//定义一个私有的NumberPicker类型的成员变量mMinuteSpinner，用于显示和选择分钟
private final NumberPicker mMinuteSpinner;
//定义一个私有的NumberPicker类型的成员变量mAmPmSpinner，用于显示和选择上午/下午（AM/PM）
private final NumberPicker mAmPmSpinner;
//定义一个私有的Calendar类型的成员变量mDate，用于存储和操作日期和时间
private Calendar mDate;
//定义一个私有的String数组mDateDisplayValues，长度为一周中的天数（7），可能用于存储一周中的每一天的名称（例如"日", "一", "二", ...）
private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];
//定义一个私有的布尔型成员变量mIsAm，可能表示当前是否为上午（AM）
private boolean mIsAm;
//定义一个私有的布尔型成员变量mIs24HourView，可能表示是否使用24小时制
private boolean mIs24HourView;
//定义一个私有的布尔型成员变量mIsEnabled，默认值为DEFAULT_ENABLE_STATE（可能为true），表示这个日期时间选择器是否可用
private boolean mIsEnabled = DEFAULT_ENABLE_STATE;
//定义一个私有的布尔型成员变量mInitialising，可能表示当前是否正在初始化
private boolean mInitialising;
//定义一个私有的OnDateTimeChangedListener类型的成员变量mOnDateTimeChangedListener，当日期或时间改变时可能会被触发
private OnDateTimeChangedListener mOnDateTimeChangedListener;
private NumberPicker.OnValueChangeListener mOnDateChangedListener = new NumberPicker.OnValueChangeListener() { // 定义一个监听器，当日期选择器数值改变时触发
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) { // 重写监听器的onValueChange方法，当选择的日期改变时会被调用
mDate.add(Calendar.DAY_OF_YEAR, newVal - oldVal); // 使用新的日期差值来更新mDate对象，可能增加了或减少了天数
updateDateControl(); // 更新日期显示控件，可能根据新的日期值更新日期显示
onDateTimeChanged(); // 调用onDateTimeChanged方法，通知日期和时间已更改
}
};
private NumberPicker.OnValueChangeListener mOnHourChangedListener = new NumberPicker.OnValueChangeListener() { // 定义另一个监听器，当时间选择器数值改变时触发
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) { // 重写监听器的onValueChange方法，当选择的时间改变时会被调用
boolean isDateChanged = false; // 定义一个布尔变量，用于标记日期是否已更改
Calendar cal = Calendar.getInstance(); // 创建一个Calendar实例，用于处理日期和时间相关操作
if (!mIs24HourView) { // 如果当前不是24小时制，则执行以下代码块
if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) { // 如果当前不是上午且旧的时间值是半天前的一小时且新的时间值是半天后的一小时，则执行以下代码块
cal.setTimeInMillis(mDate.getTimeInMillis()); // 将cal设置为与mDate相同的毫秒时间戳
cal.add(Calendar.DAY_OF_YEAR, 1); // 在cal中添加一天，因为从半天前跳到了半天后，日期应该加一
isDateChanged = true; // 设置isDateChanged为true，表示日期已更改
} else if (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) { // 如果当前是上午且旧的时间值是半天后的一小时且新的时间值是半天前的一小时，则执行以下代码块
cal.setTimeInMillis(mDate.getTimeInMillis()); // 将cal设置为与mDate相同的毫秒时间戳
cal.add(Calendar.DAY_OF_YEAR, -1); // 在cal中减去一天，因为从半天后跳到了半天前，日期应该减一
isDateChanged = true; // 设置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; // 反转mIsAm的值，因为从上午转到下午或从下午转到上午
updateAmPmControl(); // 更新AM/PM控件的显示，可能根据新的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();
}
private NumberPicker.OnValueChangeListener mOnMinuteChangedListener = new NumberPicker.OnValueChangeListener() { // 定义一个监听器，当分钟选择器数值改变时触发
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) { // 重写监听器的onValueChange方法，当选择的分钟改变时会被调用
int minValue = mMinuteSpinner.getMinValue(); // 获取分钟选择器的最小值
int maxValue = mMinuteSpinner.getMaxValue(); // 获取分钟选择器的最大值
int offset = 0; // 定义一个偏移量，用于处理分钟从最大值跳到最小值或从最小值跳到最大值的情况
if (oldVal == maxValue && newVal == minValue) { // 如果旧的分钟值是最大值并且新的分钟值是最小值（例如从59跳到0）
offset += 1; // 将偏移量加1，表示小时需要加1
} else if (oldVal == minValue && newVal == maxValue) { // 如果旧的分钟值是最小值并且新的分钟值是最大值（例如从0跳到59）
offset -= 1; // 将偏移量减1，表示小时需要减1
}
if (offset != 0) { // 如果偏移量不为0，说明小时有变化
mDate.add(Calendar.HOUR_OF_DAY, offset); // 在mDate上添加或减去相应的小时数
mHourSpinner.setValue(getCurrentHour()); // 更新小时选择器的值为当前小时数
updateDateControl(); // 更新日期显示控件的显示
int newHour = getCurrentHourOfDay(); // 获取当前的小时数（24小时制）
if (newHour >= HOURS_IN_HALF_DAY) { // 如果当前小时数大于等于12（即下午）
mIsAm = false; // 设置mIsAm为false，表示现在是下午
updateAmPmControl(); // 更新AM/PM控件的显示
} else {
// 这里代码不完整，可能是处理小时数小于12（即上午）的情况
}
}
}
};
// 定义一个监听器，当日期或时间改变时触发
mOnDateChangedListener = new NumberPicker.OnValueChangeListener() {
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
// 获取当前日期
mDate.set(Calendar.DAY_OF_MONTH, newVal);
// 更新日期显示
updateDateControl();
}
};
// 定义一个监听器，当小时改变时触发
mOnHourChangedListener = new NumberPicker.OnValueChangeListener() {
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
// 获取当前小时
mDate.set(Calendar.HOUR_OF_DAY, newVal);
// 更新小时显示
updateAmPmControl();
// 更新日期和时间已更改的监听器
onDateTimeChanged();
}
};
// 定义一个监听器，当分钟改变时触发
mOnMinuteChangedListener = new NumberPicker.OnValueChangeListener() {
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
// 获取当前分钟
mDate.set(Calendar.MINUTE, newVal);
// 更新分钟显示
onDateTimeChanged();
}
};
// 定义一个接口，用于监听日期和时间改变的事件
public interface OnDateTimeChangedListener {
void onDateTimeChanged(DateTimePicker view, int year, int month,
int dayOfMonth, int hourOfDay, int minute);
}
// DateTimePicker的构造函数，接受一个上下文作为参数
public DateTimePicker(Context context) {
this(context, System.currentTimeMillis()); // 使用当前时间作为初始时间
}
// DateTimePicker的另一个构造函数，接受上下文和日期作为参数，用于初始化日期时间选择器
public DateTimePicker(Context context, long date) {
this(context, date, DateFormat.is24HourFormat(context)); // 根据系统设置选择24小时或12小时制
}
// DateTimePicker的第三个构造函数，接受上下文、日期和是否为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); // 根据资源ID加载布局文件，并添加到当前控件中
// 初始化小时、分钟和AM/PM选择器，并设置相应的监听器、范围和其他属性
mDateSpinner = (NumberPicker) findViewById(R.id.date); // 获取日期选择器控件的引用
mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL); // 设置日期的最小值
mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL); // 设置日期的最大值
mDateSpinner.setOnValueChangedListener(mOnDateChangedListener); // 设置日期改变的监听器
// 类似地，初始化小时、分钟和AM/PM选择器，并设置相应的属性、范围和其他监听器等。
}
mDate.set(Calendar.MINUTE, newVal);
onDateTimeChanged();
}
};
private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() {
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
mIsAm = !mIsAm;
if (mIsAm) {
mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY);
} else {
mDate.add(Calendar.HOUR_OF_DAY, HOURS_IN_HALF_DAY);
// 将控件更新到初始状态
updateDateControl(); // 更新日期控件到初始状态
updateHourControl(); // 更新小时控件到初始状态
updateAmPmControl(); // 更新AM/PM控件到初始状态
set24HourView(is24HourView); // 根据is24HourView的值设置24小时制或12小时制视图
// 设置为当前时间
setCurrentDate(date); // 使用传入的date参数（毫秒形式）设置当前日期
setEnabled(isEnabled()); // 根据isEnabled()方法的返回值（一个布尔值）来设置控件的启用/禁用状态
// 设置内容描述
mInitialising = false; // 将mInitialising标志设置为false，表示初始化已完成
@Override
public void setEnabled(boolean enabled) {
if (mIsEnabled == enabled) { // 如果当前的启用/禁用状态与传入的enabled参数相同
return; // 则直接返回，不进行任何操作
}
super.setEnabled(enabled); // 调用父类的setEnabled方法，设置控件的启用/禁用状态
mDateSpinner.setEnabled(enabled); // 设置日期选择器的启用/禁用状态
mMinuteSpinner.setEnabled(enabled); // 设置分钟选择器的启用/禁用状态
mHourSpinner.setEnabled(enabled); // 设置小时选择器的启用/禁用状态
mAmPmSpinner.setEnabled(enabled); // 设置AM/PM选择器的启用/禁用状态
mIsEnabled = enabled; // 更新mIsEnabled的值，以反映当前的启用/禁用状态
}
@Override
public boolean isEnabled() {
return mIsEnabled; // 返回当前的启用/禁用状态（一个布尔值）
}
/**
* 获取当前的日期（毫秒形式）
*
* @return 当前的日期（毫秒形式）
*/
public long getCurrentDateInTimeMillis() {
return mDate.getTimeInMillis(); // 返回mDate对象表示的日期和时间的毫秒形式
}
/**
* 设置当前日期
*
* @param date 当前的日期（毫秒形式）
*/
public void setCurrentDate(long date) {
Calendar cal = Calendar.getInstance(); // 获取一个Calendar对象实例，用于处理日期和时间字段
cal.setTimeInMillis(date); // 使用传入的date参数（毫秒形式）设置Calendar对象的时间
setCurrentDate(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH), // 从Calendar对象获取年、月、日字段，并作为参数调用另一个setCurrentDate方法设置当前日期和时间
cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE)); // 从Calendar对象获取小时和分钟字段，并作为参数传递给另一个setCurrentDate方法
}
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));
}
public DateTimePicker(Context context, long date, boolean is24HourView) {
super(context);
mDate = Calendar.getInstance();
mInitialising = true;
mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY;
inflate(context, R.layout.datetime_picker, this);
mDateSpinner = (NumberPicker) findViewById(R.id.date);
mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL);
mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL);
mDateSpinner.setOnValueChangedListener(mOnDateChangedListener);
mHourSpinner = (NumberPicker) findViewById(R.id.hour);
mHourSpinner.setOnValueChangedListener(mOnHourChangedListener);
mMinuteSpinner = (NumberPicker) findViewById(R.id.minute);
mMinuteSpinner.setMinValue(MINUT_SPINNER_MIN_VAL);
mMinuteSpinner.setMaxValue(MINUT_SPINNER_MAX_VAL);
mMinuteSpinner.setOnLongPressUpdateInterval(100);
mMinuteSpinner.setOnValueChangedListener(mOnMinuteChangedListener);
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);
// update controls to initial state
updateDateControl();
updateHourControl();
updateAmPmControl();
set24HourView(is24HourView);
// set to current time
setCurrentDate(date);
setEnabled(isEnabled());
// set the content descriptions
mInitialising = false;
}
@Override
public void setEnabled(boolean enabled) {
if (mIsEnabled == enabled) {
return;
}
super.setEnabled(enabled);
mDateSpinner.setEnabled(enabled);
mMinuteSpinner.setEnabled(enabled);
mHourSpinner.setEnabled(enabled);
mAmPmSpinner.setEnabled(enabled);
mIsEnabled = enabled;
}
@Override
public boolean isEnabled() {
return mIsEnabled;
}
/**
* Get the current date in millis
*
* @return the current date in millis
*/
public long getCurrentDateInTimeMillis() {
return mDate.getTimeInMillis();
}
/**
* Set the current date
*
* @param date The current date in millis
*/
public void setCurrentDate(long date) {
Calendar cal = Calendar.getInstance();
cal.setTimeInMillis(date);
setCurrentDate(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH),
cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE));
}
/**
* Set the current date
@ -262,38 +291,49 @@ public class DateTimePicker extends FrameLayout {
* @param hourOfDay The current hourOfDay
* @param minute The current minute
*/
public void setCurrentDate(int year, int month,
int dayOfMonth, int hourOfDay, int minute) {
setCurrentYear(year);
setCurrentMonth(month);
setCurrentDay(dayOfMonth);
setCurrentHour(hourOfDay);
setCurrentMinute(minute);
}
// 定义一个公共方法setCurrentDate，该方法接受五个参数：年、月、日、小时和分钟
public void setCurrentDate(int year, int month,
int dayOfMonth, int hourOfDay, int minute) {
// 使用传入的年参数设置当前年份
setCurrentYear(year);
// 使用传入的月参数设置当前月份
setCurrentMonth(month);
// 使用传入的日参数设置当前日期
setCurrentDay(dayOfMonth);
// 使用传入的时参数设置当前小时
setCurrentHour(hourOfDay);
// 使用传入的分参数设置当前分钟
setCurrentMinute(minute);
}
/**
* Get current year
*
* @return The current year
*/
public int getCurrentYear() {
return mDate.get(Calendar.YEAR);
}
// 定义一个公共方法getCurrentYear，该方法没有参数
public int getCurrentYear() {
// 调用mDate对象的get方法，参数为Calendar.YEAR，用于获取当前年份
return mDate.get(Calendar.YEAR);
}
/**
* Set current year
*
* @param year The current year
*/
public void setCurrentYear(int year) {
if (!mInitialising && year == getCurrentYear()) {
return;
}
mDate.set(Calendar.YEAR, year);
updateDateControl();
onDateTimeChanged();
}
public void setCurrentYear(int year) {
// 判断是否正在初始化，如果是，则不执行任何操作，直接返回
if (!mInitialising && year == getCurrentYear()) {
return;
}
// 使用给定的年份来设置日历中的年份
mDate.set(Calendar.YEAR, year);
// 更新日期控件的状态，可能是重新绘制或者更新其显示的值
updateDateControl();
// 当日期和时间改变时调用此方法，可以在此方法中进行一些额外的操作或者通知监听者
onDateTimeChanged();
}
/**
* Get current month in the year
*
@ -308,13 +348,17 @@ public class DateTimePicker extends FrameLayout {
*
* @param month The month in the year
*/
public void setCurrentMonth(int month) {
if (!mInitialising && month == getCurrentMonth()) {
return;
}
mDate.set(Calendar.MONTH, month);
updateDateControl();
onDateTimeChanged();
public void setCurrentMonth(int month) {
// 判断是否正在初始化，如果是，则不执行任何操作，直接返回
if (!mInitialising && month == getCurrentMonth()) {
return;
}
// 使用给定的月份来设置日历中的月份
mDate.set(Calendar.MONTH, month);
// 更新日期控件的状态，可能是重新绘制或者更新其显示的值
updateDateControl();
// 当日期和时间改变时调用此方法，可以在此方法中进行一些额外的操作或者通知监听者
onDateTimeChanged();
}
/**
@ -344,21 +388,32 @@ public class DateTimePicker extends FrameLayout {
* Get current hour in 24 hour mode, in the range (0~23)
* @return The current hour in 24 hour mode
*/
public int getCurrentHourOfDay() {
return mDate.get(Calendar.HOUR_OF_DAY);
}
private int getCurrentHour() {
if (mIs24HourView){
return getCurrentHourOfDay();
} else {
int hour = getCurrentHourOfDay();
if (hour > HOURS_IN_HALF_DAY) {
return hour - HOURS_IN_HALF_DAY;
} else {
return hour == 0 ? HOURS_IN_HALF_DAY : hour;
}
}
// 公共方法，返回当前的小时数（24小时制）
public int getCurrentHourOfDay() {
// 从mDate对象中获取当前的小时数（24小时制）
return mDate.get(Calendar.HOUR_OF_DAY);
}
// 私有方法，返回当前的小时数（12小时制）
private int getCurrentHour() {
// 如果当前是24小时制视图
if (mIs24HourView){
// 直接返回当前的小时数（24小时制）
return getCurrentHourOfDay();
// 如果当前不是24小时制视图
} else {
// 获取当前的小时数（12小时制）
int hour = getCurrentHourOfDay();
// 如果当前的小时数大于半天的小时数
if (hour > HOURS_IN_HALF_DAY) {
// 返回减去半天的小时数后的结果
return hour - HOURS_IN_HALF_DAY;
// 如果当前的小时数不大于半天的小时数
} else {
// 如果当前的小时数为0（即午夜12点）
return hour == 0 ? HOURS_IN_HALF_DAY : hour;
}
}
}
/**
@ -366,27 +421,42 @@ public class DateTimePicker extends FrameLayout {
*
* @param hourOfDay
*/
public void setCurrentHour(int hourOfDay) {
if (!mInitialising && hourOfDay == getCurrentHourOfDay()) {
return;
}
mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
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();
// 公共方法，设置当前的小时数
public void setCurrentHour(int hourOfDay) {
// 判断是否正在初始化，如果是，则不执行任何操作，直接返回
if (!mInitialising && hourOfDay == getCurrentHourOfDay()) {
return;
}
// 使用给定的小时数来设置日历中的小时数（24小时制）
mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
// 如果不是24小时制视图
if (!mIs24HourView) {
// 如果给定的小时数大于等于半天的小时数
if (hourOfDay >= HOURS_IN_HALF_DAY) {
// 设置上午标志为false
mIsAm = false;
// 如果给定的小时数大于半天的小时数
if (hourOfDay > HOURS_IN_HALF_DAY) {
// 减去半天的小时数
hourOfDay -= HOURS_IN_HALF_DAY;
}
// 如果给定的小时数小于半天的小时数
} else {
// 设置上午标志为true
mIsAm = true;
// 如果给定的小时数为0（即午夜12点）
if (hourOfDay == 0) {
// 设置为半天的小时数
hourOfDay = HOURS_IN_HALF_DAY;
}
}
// 更新AM/PM控制组件的状态
updateAmPmControl();
}
// 设置小时数选择器的值为给定的小时数
mHourSpinner.setValue(hourOfDay);
// 当日期和时间改变时调用此方法，可以在此方法中进行一些额外的操作或者通知监听者
onDateTimeChanged();
}
/**
@ -401,13 +471,18 @@ public class DateTimePicker extends FrameLayout {
/**
* Set current minute
*/
public void setCurrentMinute(int minute) {
if (!mInitialising && minute == getCurrentMinute()) {
return;
}
mMinuteSpinner.setValue(minute);
mDate.set(Calendar.MINUTE, minute);
onDateTimeChanged();
// 公共方法，设置当前分钟
public void setCurrentMinute(int minute) {
// 判断是否正在初始化，如果是，则不执行任何操作，直接返回
if (!mInitialising && minute == getCurrentMinute()) {
return;
}
// 设置分钟数选择器的值为给定的分钟数
mMinuteSpinner.setValue(minute);
// 使用给定的分钟数来设置日历中的分钟数
mDate.set(Calendar.MINUTE, minute);
// 当日期和时间改变时调用此方法，可以在此方法中进行一些额外的操作或者通知监听者
onDateTimeChanged();
}
/**
@ -422,60 +497,82 @@ public class DateTimePicker extends FrameLayout {
*
* @param is24HourView True for 24 hour mode. False for AM/PM mode.
*/
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();
// 公共方法，设置是否为24小时制视图
public void set24HourView(boolean is24HourView) {
// 如果当前是否为24小时制与传入的参数相同，则不执行任何操作，直接返回
if (mIs24HourView == is24HourView) {
return;
}
// 设置是否为24小时制视图
mIs24HourView = is24HourView;
// 根据是否为24小时制，设置AM/PM选择器的可见性
mAmPmSpinner.setVisibility(is24HourView ? View.GONE : View.VISIBLE);
// 获取当前的小时数（24小时制）
int hour = getCurrentHourOfDay();
// 更新小时控制
updateHourControl();
// 设置当前的小时数
setCurrentHour(hour);
// 更新AM/PM控制
updateAmPmControl();
}
// 私有方法，更新日期控件
private void updateDateControl() {
// 创建一个日历实例，并设置其时间为mDate的毫秒表示形式
Calendar cal = Calendar.getInstance();
cal.setTimeInMillis(mDate.getTimeInMillis());
// 将日历时间调整到一周的中间日期（减1天）
cal.add(Calendar.DAY_OF_YEAR, -DAYS_IN_ALL_WEEK / 2 - 1);
// 清空日期选择器显示的日期值
mDateSpinner.setDisplayedValues(null);
// 循环生成一周的日期字符串（格式为MM.dd EEEE）并存储到mDateDisplayValues数组中
for (int i = 0; i < DAYS_IN_ALL_WEEK; ++i) {
cal.add(Calendar.DAY_OF_YEAR, 1);
mDateDisplayValues[i] = (String) DateFormat.format("MM.dd EEEE", cal);
}
// 设置日期选择器显示的日期值
mDateSpinner.setDisplayedValues(mDateDisplayValues);
// 设置日期选择器的默认值（一周中间日期）
mDateSpinner.setValue(DAYS_IN_ALL_WEEK / 2);
// 使日期选择器无效，以触发重新绘制界面
mDateSpinner.invalidate();
}
// 私有方法，更新AM/PM控制
private void updateAmPmControl() {
// 如果当前是24小时制视图，则隐藏AM/PM选择器
if (mIs24HourView) {
mAmPmSpinner.setVisibility(View.GONE);
} else {
// 否则，根据上午标志设置AM/PM选择器的值（0代表上午，1代表下午）
int index = mIsAm ? Calendar.AM : Calendar.PM;
mAmPmSpinner.setValue(index);
// 显示AM/PM选择器
mAmPmSpinner.setVisibility(View.VISIBLE);
}
}
// 私有方法，更新小时控件的最小和最大值
private void updateHourControl() {
// 根据是否为24小时制，设置小时选择器的最小和最大值
if (mIs24HourView) {
mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW);
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);
}
}
/**
* 设置回调，表示“设置”按钮已被按下。如果回调为null，则不执行任何操作。
* @param callback 回调函数，如果为null则不执行任何操作
*/
public void setOnDateTimeChangedListener(OnDateTimeChangedListener callback) {
// 设置当日期和时间改变时的回调函数
mOnDateTimeChangedListener = callback;
}
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();
}
private void updateAmPmControl() {
if (mIs24HourView) {
mAmPmSpinner.setVisibility(View.GONE);
} else {
int index = mIsAm ? Calendar.AM : Calendar.PM;
mAmPmSpinner.setValue(index);
mAmPmSpinner.setVisibility(View.VISIBLE);
}
}
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);
}
}
/**
* Set the callback that indicates the 'Set' button has been pressed.
* @param callback the callback, if null will do nothing
*/
public void setOnDateTimeChangedListener(OnDateTimeChangedListener callback) {
mOnDateTimeChangedListener = callback;
}
private void onDateTimeChanged() {
if (mOnDateTimeChangedListener != null) {
mOnDateTimeChangedListener.onDateTimeChanged(this, getCurrentYear(),

Write Preview
Loading…
Cancel
Save