目录
1、
2、
3、
4、
5、
6、
7、
8、
9、
10、
11、
12、
13、
14、
1、
package ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener {
private long mNoteId; //文本在数据库存储中的ID号
private String mSnippet; //闹钟提示时出现的文本片段
private static final int SNIPPET_PREW_MAX_LEN = 60;
MediaPlayer mPlayer;
@Override
protected void onCreate(Bundle savedInstanceState) {
(savedInstanceState);
//Bundle类型的数据与Map类型的数据相似，都是以key-value的形式存储数据的
//onsaveInstanceState方法是用来保存Activity的状态的
//能从onCreate的参数savedInsanceState中获得状态数据
requestWindowFeature(Window.FEATURE_NO_TITLE);
//界面显示——无标题
final Window win = getWindow();
(.FLAG_SHOW_WHEN_LOCKED);
if (!isScreenOn()) {
(.FLAG_KEEP_SCREEN_ON
//保持窗体点亮
| .FLAG_TURN_SCREEN_ON
//将窗体点亮
| .FLAG_ALLOW_LOCK_WHILE_SCREEN_ON
//允许窗体点亮时锁屏
| .FLAG_LAYOUT_INSET_DECOR);
}//在手机锁屏后如果到了闹钟提示时间，点亮屏幕
Intent intent = getIntent();
try {
mNoteId = (().getPathSegments().get(1));
mSnippet = ((), mNoteId);
//根据ID从数据库中获取标签的内容；
//getContentResolver（）是实现数据共享，实例存储。
mSnippet = () > SNIPPET_PREW_MAX_LEN ? (0,
SNIPPET_PREW_MAX_LEN) + getResources().getString(.notelist_string_info)
: mSnippet;
//判断标签片段是否达到符合长度
} catch (IllegalArgumentException e) {
();
return;
}
/*
try
{
// 代码区
}
catch(Exception e)
{
// 异常处理
}
代码区如果有错误，就会返回所写异常的处理。*/
mPlayer = new MediaPlayer();
if ((getContentResolver(), mNoteId, Notes.TYPE_NOTE)) {
showActionDialog();
//弹出对话框
playAlarmSound();
//闹钟提示音激发
} else {
finish();
//完成闹钟动作
}
}
private boolean isScreenOn() {
//判断屏幕是否锁屏，调用系统函数判断，最后返回值是布尔类型
PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
return ();
}
private void playAlarmSound() {
//闹钟提示音激发
Uri url = (this, RingtoneManager.TYPE_ALARM);
//调用系统的铃声管理URI，得到闹钟提示音
int silentModeStreams = (getContentResolver(),
.MODE_RINGER_STREAMS_AFFECTED, 0);
if ((silentModeStreams & (1 << AudioManager.STREAM_ALARM)) != 0) {
(silentModeStreams);
} else {
(AudioManager.STREAM_ALARM);
}
try {
(this, url);
//方法：setDataSource(Context context, Uri uri)
//解释：无返回值，设置多媒体数据来源【根据 Uri】
();
//准备同步
(true);
//设置是否循环播放
();
//开始播放
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
();
//()函数功能是抛出异常， 还将显示出更深的调用信息
//(e)，这个方法打印出异常，并且输出在哪里出现的异常
} catch (SecurityException e) {
// TODO Auto-generated catch block
();
} catch (IllegalStateException e) {
// TODO Auto-generated catch block
();
} catch (IOException e) {
// TODO Auto-generated catch block
();
}
}
private void showActionDialog() {
dialog = new (this);
//AlertDialog的构造方法全部是Protected的
//所以不能直接通过new一个AlertDialog来创建出一个AlertDialog。
//要创建一个AlertDialog，就要用到中的create()方法
//如这里的dialog就是新建了一个AlertDialog
(.app_name);
//为对话框设置标题
(mSnippet);
//为对话框设置内容
(.notealert_ok, this);
//给对话框添加"Yes"按钮
if (isScreenOn()) {
(.notealert_enter, this);
}//对话框添加"No"按钮
().setOnDismissListener(this);
}
public void onClick(DialogInterface dialog, int which) {
switch (which) {
//用which来选择click后下一步的操作
case DialogInterface.BUTTON_NEGATIVE:
//这是取消操作
Intent intent = new Intent(this, );
//实现两个类间的数据传输
(Intent.ACTION_VIEW);
//设置动作属性
(Intent.EXTRA_UID, mNoteId);
//实现key-value对
//EXTRA_UID为key；mNoteId为键
startActivity(intent);
//开始动作
break;
default:
//这是确定操作
break;
}
}
public void onDismiss(DialogInterface dialog) {
//忽略
stopAlarmSound();
//停止闹钟声音
finish();
//完成该动作
}
private void stopAlarmSound() {
if (mPlayer != null) {
();
//停止播放
();
//释放MediaPlayer对象
mPlayer = null;
}
}
}
2、
package ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
public class AlarmInitReceiver extends BroadcastReceiver {
private static final String [] PROJECTION = new String [] {
,
NoteColumns.ALERTED_DATE
};
//对数据库的操作，调用标签ID和闹钟时间
private static final int COLUMN_ID = 0;
private static final int COLUMN_ALERTED_DATE = 1;
@Override
public void onReceive(Context context, Intent intent) {
long currentDate = ();
//()产生一个当前的毫秒
//这个毫秒其实就是自1970年1月1日0时起的毫秒数
Cursor c = ().query(Notes.CONTENT_NOTE_URI,
PROJECTION,
NoteColumns.ALERTED_DATE + ">? AND " + + "=" + Notes.TYPE_NOTE,
new String[] { (currentDate) },
//将long变量currentDate转化为字符串
null);
//Cursor在这里的作用是通过查找数据库中的标签内容，找到和当前系统时间相等的标签
if (c != null) {
if (()) {
do {
long alertDate = (COLUMN_ALERTED_DATE);
Intent sender = new Intent(context, );
((Notes.CONTENT_NOTE_URI, (COLUMN_ID)));
PendingIntent pendingIntent = (context, 0, sender, 0);
AlarmManager alermManager = (AlarmManager) context
.getSystemService(Context.ALARM_SERVICE);
(AlarmManager.RTC_WAKEUP, alertDate, pendingIntent);
} while (());
}
();
}
//然而通过网上查找资料发现，对于闹钟机制的启动，通常需要上面的几个步骤
//如新建Intent、PendingIntent以及AlarmManager等
//这里就是根据数据库里的闹钟时间创建一个闹钟机制
}
}
3、
package ;
import ;
import ;
import ;
public class AlarmReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
(context, );
//启动AlarmAlertActivity
(Intent.FLAG_ACTIVITY_NEW_TASK);
//activity要存在于activity的栈中，而非activity的途径启动activity时必然不存在一个activity的栈
//所以要新起一个栈装入启动的activity
(intent);
}
}
//这是实现alarm这个功能最接近用户层的包，基于上面的两个包，
//作用还需要深究但是对于setClass和addFlags的
4、
package ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
public class DateTimePicker extends FrameLayout {
//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;
//NumberPicker是数字选择器
//这里定义的四个变量全部是在设置闹钟时需要选择的变量（如日期、时、分、上午或者下午）
private Calendar mDate;
//定义了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 mOnDateChangedListener = new () {
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
(Calendar.DAY_OF_YEAR, newVal - oldVal);
updateDateControl();
onDateTimeChanged();
}
};//OnValueChangeListener，这是时间改变监听器，这里主要是对日期的监听
//将现在日期的值传递给mDate；updateDateControl是同步操作
private mOnHourChangedListener = new () {
//这里是对 小时（Hour） 的监听
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
boolean isDateChanged = false;
Calendar cal = ();
//声明一个Calendar的变量cal，便于后续的操作
if (!mIs24HourView) {
if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) {
(());
(Calendar.DAY_OF_YEAR, 1);
isDateChanged = true;
//这里是对于12小时制时，晚上11点和12点交替时对日期的更改
} else if (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
(());
(Calendar.DAY_OF_YEAR, -1);
isDateChanged = true;
}
//这里是对于12小时制时，凌晨11点和12点交替时对日期的更改
if (oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY ||
oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
mIsAm = !mIsAm;
updateAmPmControl();
}//这里是对于12小时制时，中午11点和12点交替时对AM和PM的更改
} else {
if (oldVal == HOURS_IN_ALL_DAY - 1 && newVal == 0) {
(());
(Calendar.DAY_OF_YEAR, 1);
isDateChanged = true;
//这里是对于24小时制时，晚上11点和12点交替时对日期的更改
} else if (oldVal == 0 && newVal == HOURS_IN_ALL_DAY - 1) {
(());
(Calendar.DAY_OF_YEAR, -1);
isDateChanged = true;
}
} //这里是对于12小时制时，凌晨11点和12点交替时对日期的更改
int newHour = () % HOURS_IN_HALF_DAY + (mIsAm ? 0 : HOURS_IN_HALF_DAY);
//通过数字选择器对newHour的赋值
(Calendar.HOUR_OF_DAY, newHour);
//通过set函数将新的Hour值传给mDate
onDateTimeChanged();
if (isDateChanged) {
setCurrentYear(());
setCurrentMonth(());
setCurrentDay((Calendar.DAY_OF_MONTH));
}
}
};
private mOnMinuteChangedListener = new () {
@Override
//这里是对 分钟（Minute）改变的监听
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
int minValue = ();
int maxValue = ();
int offset = 0;
//设置offset，作为小时改变的一个记录数据
if (oldVal == maxValue && newVal == minValue) {
offset += 1;
} else if (oldVal == minValue && newVal == maxValue) {
offset -= 1;
}
//如果原值为59，新值为0，则offset加1
//如果原值为0，新值为59，则offset减1
if (offset != 0) {
(Calendar.HOUR_OF_DAY, offset);
(getCurrentHour());
updateDateControl();
int newHour = getCurrentHourOfDay();
if (newHour >= HOURS_IN_HALF_DAY) {
mIsAm = false;
updateAmPmControl();
} else {
mIsAm = true;
updateAmPmControl();
}
}
(, newVal);
onDateTimeChanged();
}
};
private mOnAmPmChangedListener = new () {
//对AM和PM的监听
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
mIsAm = !mIsAm;
if (mIsAm) {
(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY);
} else {
(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, ());
}//通过对数据库的访问，获取当前的系统时间
public DateTimePicker(Context context, long date) {
this(context, date, DateFormat.is24HourFormat(context));
}//上面函数的得到的是一个天文数字（1970至今的秒数），需要DateFormat将其变得有意义
public DateTimePicker(Context context, long date, boolean is24HourView) {
super(context);
//获取系统时间
mDate = ();
mInitialising = true;
mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY;
inflate(context, .datetime_picker, this);
//如果当前Activity里用到别的layout，比如对话框layout
//还要设置这个layout上的其他组件的内容，就必须用inflate()方法先将对话框的layout找出来
//然后再用findViewById()找到它上面的其它组件
mDateSpinner = (NumberPicker) findViewById();
(DATE_SPINNER_MIN_VAL);
(DATE_SPINNER_MAX_VAL);
(mOnDateChangedListener);
mHourSpinner = (NumberPicker) findViewById();
(mOnHourChangedListener);
mMinuteSpinner = (NumberPicker) findViewById();
(MINUT_SPINNER_MIN_VAL);
(MINUT_SPINNER_MAX_VAL);
(100);
(mOnMinuteChangedListener);
String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings();
mAmPmSpinner = (NumberPicker) findViewById();
(AMPM_SPINNER_MIN_VAL);
(AMPM_SPINNER_MAX_VAL);
(stringsForAmPm);
(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;
}
(enabled);
(enabled);
(enabled);
(enabled);
(enabled);
mIsEnabled = enabled;
}
//存在疑问！！！！！！！！！！！！！setEnabled的作用
//下面的代码通过原程序的注释已经比较清晰，另外可以通过函数名来判断
//下面的各函数主要是对上面代码引用到的各函数功能的实现
@Override
public boolean isEnabled() {
return mIsEnabled;
}
/**
* Get the current date in millis
*
* @return the current date in millis
*/
public long getCurrentDateInTimeMillis() {
return ();
}//实现函数——得到当前的秒数
/**
* Set the current date
*
* @param date The current date in millis
*/
public void setCurrentDate(long date) {
Calendar cal = ();
(date);
setCurrentDate((), (), (Calendar.DAY_OF_MONTH),
(Calendar.HOUR_OF_DAY), ());
}//实现函数功能——设置当前的时间，参数是date
/**
* Set the current date
*
* @param year The current year
* @param month The current month
* @param dayOfMonth The current dayOfMonth
* @param hourOfDay The current hourOfDay
* @param minute The current minute
*/
public void setCurrentDate(int year, int month,
int dayOfMonth, int hourOfDay, int minute) {
setCurrentYear(year);
setCurrentMonth(month);
setCurrentDay(dayOfMonth);
setCurrentHour(hourOfDay);
setCurrentMinute(minute);
}//实现函数功能——设置当前的时间，参数是各详细的变量
/**
* Get current year
*
* @return The current year
*/
//下面是得到year、month、day等值
public int getCurrentYear() {
return ();
}
/**
* Set current year
*
* @param year The current year
*/
public void setCurrentYear(int year) {
if (!mInitialising && year == getCurrentYear()) {
return;
}
(, year);
updateDateControl();
onDateTimeChanged();
}
/**
* Get current month in the year
*
* @return The current month in the year
*/
public int getCurrentMonth() {
return ();
}
/**
* Set current month in the year
*
* @param month The month in the year
*/
public void setCurrentMonth(int month) {
if (!mInitialising && month == getCurrentMonth()) {
return;
}
(, month);
updateDateControl();
onDateTimeChanged();
}
/**
* Get current day of the month
*
* @return The day of the month
*/
public int getCurrentDay() {
return (Calendar.DAY_OF_MONTH);
}
/**
* Set current day of the month
*
* @param dayOfMonth The day of the month
*/
public void setCurrentDay(int dayOfMonth) {
if (!mInitialising && dayOfMonth == getCurrentDay()) {
return;
}
(Calendar.DAY_OF_MONTH, dayOfMonth);
updateDateControl();
onDateTimeChanged();
}
/**
* Get current hour in 24 hour mode, in the range (0~23)
* @return The current hour in 24 hour mode
*/
public int getCurrentHourOfDay() {
return (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;
}
}
}
/**
* Set current hour in 24 hour mode, in the range (0~23)
*
* @param hourOfDay
*/
public void setCurrentHour(int hourOfDay) {
if (!mInitialising && hourOfDay == getCurrentHourOfDay()) {
return;
}
(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();
}
(hourOfDay);
onDateTimeChanged();
}
/**
* Get currentMinute
*
* @return The Current Minute
*/
public int getCurrentMinute() {
return ();
}
/**
* Set current minute
*/
public void setCurrentMinute(int minute) {
if (!mInitialising && minute == getCurrentMinute()) {
return;
}
(minute);
(, minute);
onDateTimeChanged();
}
/**
* @return true if this is in 24 hour view else false.
*/
public boolean is24HourView () {
return mIs24HourView;
}
/**
* Set whether in 24 hour or AM/PM mode.
*
* @param is24HourView True for 24 hour mode. False for AM/PM mode.
*/
public void set24HourView(boolean is24HourView) {
if (mIs24HourView == is24HourView) {
return;
}
mIs24HourView = is24HourView;
(is24HourView ? : );
int hour = getCurrentHourOfDay();
updateHourControl();
setCurrentHour(hour);
updateAmPmControl();
}
private void updateDateControl() {
Calendar cal = ();
(());
(Calendar.DAY_OF_YEAR, -DAYS_IN_ALL_WEEK / 2 - 1);
(null);
for (int i = 0; i < DAYS_IN_ALL_WEEK; ++i) {
(Calendar.DAY_OF_YEAR, 1);
mDateDisplayValues[i] = (String) (" EEEE", cal);
}
(mDateDisplayValues);
(DAYS_IN_ALL_WEEK / 2);
();
}// 对于星期几的算法
private void updateAmPmControl() {
if (mIs24HourView) {
();
} else {
int index = mIsAm ? : ;
(index);
();
}// 对于上下午操作的算法
}
private void updateHourControl() {
if (mIs24HourView) {
(HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW);
(HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW);
} else {
(HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW);
(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) {
(this, getCurrentYear(),
getCurrentMonth(), getCurrentDay(), getCurrentHourOfDay(), getCurrentMinute());
}
}
}
5、
package ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
private Calendar mDate = ();
//创建一个Calendar类型的变量 mDate，方便时间的操作
private boolean mIs24HourView;
private OnDateTimeSetListener mOnDateTimeSetListener;
//声明一个时间日期滚动选择控件 mOnDateTimeSetListener
private DateTimePicker mDateTimePicker;
//DateTimePicker控件，控件一般用于让用户可以从日期列表中选择单个值。
//运行时，单击控件边上的下拉箭头，会显示为两个部分：一个下拉列表，一个用于选择日期的
public interface OnDateTimeSetListener {
void OnDateTimeSet(AlertDialog dialog, long date);
}
public DateTimePickerDialog(Context context, long date) {
//对该界面对话框的实例化
super(context);
//对数据库的操作
mDateTimePicker = new DateTimePicker(context);
setView(mDateTimePicker);
//添加一个子视图
(new OnDateTimeChangedListener() {
public void onDateTimeChanged(DateTimePicker view, int year, int month,
int dayOfMonth, int hourOfDay, int minute) {
(, year);
(, month);
(Calendar.DAY_OF_MONTH, dayOfMonth);
(Calendar.HOUR_OF_DAY, hourOfDay);
(, minute);
//将视图中的各选项设置为系统当前时间
updateTitle(());
}
});
(date);
//得到系统时间
(, 0);
//将秒数设置为0
(());
setButton((.datetime_dialog_ok), this);
setButton2((.datetime_dialog_cancel), (OnClickListener)null);
//设置按钮
set24HourView(DateFormat.is24HourFormat(()));
//时间标准化打印
updateTitle(());
}
public void set24HourView(boolean is24HourView) {
mIs24HourView = is24HourView;
}
public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) {
mOnDateTimeSetListener = callBack;
}//将时间日期滚动选择控件实例化
private void updateTitle(long date) {
int flag =
DateUtils.FORMAT_SHOW_YEAR |
DateUtils.FORMAT_SHOW_DATE |
DateUtils.FORMAT_SHOW_TIME;
flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_24HOUR;
setTitle(((), date, flag));
}//android开发中常见日期管理工具类（API）——DateUtils：按照上下午显示时间
public void onClick(DialogInterface arg0, int arg1) {
if (mOnDateTimeSetListener != null) {
(this, ());
}
}//第一个参数arg0是接收到点击事件的对话框
//第二个参数arg1是该对话框上的按钮
}6、
package ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
public class DropdownMenu {
private Button mButton;
private PopupMenu mPopupMenu;
//声明一个下拉菜单
private Menu mMenu;
public DropdownMenu(Context context, Button button, int menuId) {
mButton = button;
(.dropdown_icon);
//设置这个view的背景
mPopupMenu = new PopupMenu(context, mButton);
mMenu = ();
().inflate(menuId, mMenu);
//MenuInflater是用来实例化Menu目录下的Menu布局文件
//根据ID来确认menu的内容选项
(new OnClickListener() {
public void onClick(View v) {
();
}
});
}
public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {
if (mPopupMenu != null) {
(listener);
}//设置菜单的监听
}
public MenuItem findItem(int id) {
return (id);
}//对于菜单选项的初始化，根据索引搜索菜单需要的选项
public void setTitle(CharSequence title) {
(title);
}//布局文件，设置标题
}
7、
package ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
public class FoldersListAdapter extends CursorAdapter {
//CursorAdapter是Cursor和ListView的接口
//FoldersListAdapter继承了CursorAdapter的类
//主要作用是便签数据库和用户的交互
//这里就是用folder（文件夹）的形式展现给用户
public static final String [] PROJECTION = {
,
};//调用数据库中便签的ID和片段
public static final int ID_COLUMN = 0;
public static final int NAME_COLUMN = 1;
public FoldersListAdapter(Context context, Cursor c) {
super(context, c);
// TODO Auto-generated constructor stub
}//数据库操作
@Override
public View newView(Context context, Cursor cursor, ViewGroup parent) {
//ViewGroup是容器
return new FolderListItem(context);
}//创建一个文件夹，对于各文件夹中子标签的初始化
@Override
public void bindView(View view, Context context, Cursor cursor) {
if (view instanceof FolderListItem) {
String folderName = ((ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
.getString(.menu_move_parent_folder) : (NAME_COLUMN);
((FolderListItem) view).bind(folderName);
}
}//将各个布局文件绑定起来
public String getFolderName(Context context, int position) {
Cursor cursor = (Cursor) getItem(position);
return ((ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
.getString(.menu_move_parent_folder) : (NAME_COLUMN);
}//根据数据库中标签的ID得到标签的各项内容
private class FolderListItem extends LinearLayout {
private TextView mName;
public FolderListItem(Context context) {
super(context);
//操作数据库
inflate(context, .folder_list_item, this);
//根据布局文件的名字等信息将其找出来
mName = (TextView) findViewById(.tv_folder_name);
}
public void bind(String name) {
(name);
}
}
}
8、
package ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import .NoteWidgetProvider_2x;
import .NoteWidgetProvider_4x;
import ;
import ;
import ;
import ;
import ;
public class NoteEditActivity extends Activity implements OnClickListener,
NoteSettingChangedListener, OnTextViewChangeListener {
//该类主要是针对标签的编辑
//继承了系统内部许多和监听有关的类
private class HeadViewHolder {
public TextView tvModified;
public ImageView ivAlertIcon;
public TextView tvAlertDate;
public ImageView ibSetBgColor;
}
//使用Map实现数据存储
private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<Integer, Integer>();
static {
(.iv_bg_yellow, );
(.iv_bg_red, );
(.iv_bg_blue, );
(.iv_bg_green, );
(.iv_bg_white, );
//put函数是将指定值和指定键相连
}
private static final Map<Integer, Integer> sBgSelectorSelectionMap = new HashMap<Integer, Integer>();
static {
(, .iv_bg_yellow_select);
(, .iv_bg_red_select);
(, .iv_bg_blue_select);
(, .iv_bg_green_select);
(, .iv_bg_white_select);
//put函数是将指定值和指定键相连
}
private static final Map<Integer, Integer> sFontSizeBtnsMap = new HashMap<Integer, Integer>();
static {
(.ll_font_large, ResourceParser.TEXT_LARGE);
(.ll_font_small, ResourceParser.TEXT_SMALL);
(.ll_font_normal, ResourceParser.TEXT_MEDIUM);
(.ll_font_super, ResourceParser.TEXT_SUPER);
//put函数是将指定值和指定键相连
}
private static final Map<Integer, Integer> sFontSelectorSelectionMap = new HashMap<Integer, Integer>();
static {
(ResourceParser.TEXT_LARGE, .iv_large_select);
(ResourceParser.TEXT_SMALL, .iv_small_select);
(ResourceParser.TEXT_MEDIUM, .iv_medium_select);
(ResourceParser.TEXT_SUPER, .iv_super_select);
//put函数是将指定值和指定键相连
}
private static final String TAG = "NoteEditActivity";
private HeadViewHolder mNoteHeaderHolder;
private View mHeadViewPanel;
//私有化一个界面操作mHeadViewPanel，对表头的操作
private View mNoteBgColorSelector;
//私有化一个界面操作mNoteBgColorSelector，对背景颜色的操作
private View mFontSizeSelector;
//私有化一个界面操作mFontSizeSelector，对标签字体的操作
private EditText mNoteEditor;
//声明编辑控件，对文本操作
private View mNoteEditorPanel;
//私有化一个界面操作mNoteEditorPanel，文本编辑的控制板
//private WorkingNote mWorkingNote;
public WorkingNote mWorkingNote;
//对模板WorkingNote的初始化
private SharedPreferences mSharedPrefs;
//私有化SharedPreferences的数据存储方式
//它的本质是基于XML文件存储key-value键值对数据
private int mFontSizeId;
//用于操作字体的大小
private static final String PREFERENCE_FONT_SIZE = "pref_font_size";
private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10;
public static final String TAG_CHECKED = ('\u221A');
public static final String TAG_UNCHECKED = ('\u25A1');
private LinearLayout mEditTextList;
//线性布局
private String mUserQuery;
private Pattern mPattern;
@Override
protected void onCreate(Bundle savedInstanceState) {
(savedInstanceState);
(.note_edit);
//对数据库的访问操作
if (savedInstanceState == null && !initActivityState(getIntent())) {
finish();
return;
}
initResources();
}
/**
* Current activity may be killed when the memory is low. Once it is killed, for another time
* user load this activity, we should restore the former state
*/
@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
(savedInstanceState);
if (savedInstanceState != null && (Intent.EXTRA_UID)) {
Intent intent = new Intent(Intent.ACTION_VIEW);
(Intent.EXTRA_UID, (Intent.EXTRA_UID));
if (!initActivityState(intent)) {
finish();
return;
}
(TAG, "Restoring from killed activity");
}//为防止内存不足时程序的终止，在这里有一个保存现场的函数
}
private boolean initActivityState(Intent intent) {
/**
* If the user specified the {@link Intent#ACTION_VIEW} but not provided with id,
* then jump to the NotesListActivity
*/
mWorkingNote = null;
if ((Intent.ACTION_VIEW, ())) {
long noteId = (Intent.EXTRA_UID, 0);
mUserQuery = "";
//如果用户实例化标签时，系统并未给出标签ID
/**
* Starting from the searched result
*/
//根据键值查找ID
if ((SearchManager.EXTRA_DATA_KEY)) {
noteId = ((SearchManager.EXTRA_DATA_KEY));
mUserQuery = (SearchManager.USER_QUERY);
}
//如果ID在数据库中未找到
if (!(getContentResolver(), noteId, Notes.TYPE_NOTE)) {
Intent jump = new Intent(this, );
startActivity(jump);
//程序将跳转到上面声明的intent——jump
showToast(.error_note_not_exist);
finish();
return false;
}
//ID在数据库中找到
else {
mWorkingNote = (this, noteId);
if (mWorkingNote == null) {
(TAG, "load note failed with note id" + noteId);
//打印出红色的错误信息
finish();
return false;
}
}
//setSoftInputMode——软键盘输入模式
getWindow().setSoftInputMode(
.SOFT_INPUT_STATE_HIDDEN
| .SOFT_INPUT_ADJUST_RESIZE);
} else if((Intent.ACTION_INSERT_OR_EDIT, ())) {
// ()
// 大多用于broadcast发送广播时给机制（intent）设置一个action，就是一个字符串
// 用户可以通过receive（接受）intent，通过 getAction得到的字符串，来决定做什么
long folderId = (Notes.INTENT_EXTRA_FOLDER_ID, 0);
int widgetId = (Notes.INTENT_EXTRA_WIDGET_ID,
AppWidgetManager.INVALID_APPWIDGET_ID);
int widgetType = (Notes.INTENT_EXTRA_WIDGET_TYPE,
Notes.TYPE_WIDGET_INVALIDE);
int bgResId = (Notes.INTENT_EXTRA_BACKGROUND_ID,
(this));
// （Long、String）Extra是对各变量的语法分析
// Parse call-record note
String phoneNumber = (Intent.EXTRA_PHONE_NUMBER);
long callDate = (Notes.INTENT_EXTRA_CALL_DATE, 0);
if (callDate != 0 && phoneNumber != null) {
if ((phoneNumber)) {
(TAG, "The call record number is null");
}
long noteId = 0;
if ((noteId = (getContentResolver(),
phoneNumber, callDate)) > 0) {
mWorkingNote = (this, noteId);
if (mWorkingNote == null) {
(TAG, "load call note failed with note id" + noteId);
finish();
return false;
}
//将电话号码与手机的号码簿相关
} else {
mWorkingNote = (this, folderId, widgetId,
widgetType, bgResId);
(phoneNumber, callDate);
//
}
} else {
mWorkingNote = (this, folderId, widgetId, widgetType,
bgResId);
}//创建一个新的WorkingNote
getWindow().setSoftInputMode(
.SOFT_INPUT_ADJUST_RESIZE
| .SOFT_INPUT_STATE_VISIBLE);
} else {
(TAG, "Intent not specified action, should not support");
finish();
return false;
}
(this);
return true;
}
@Override
protected void onResume() {
();
initNoteScreen();
}
private void initNoteScreen() {
//对界面的初始化操作
(this, TextAppearanceResources
.getTexAppearanceResource(mFontSizeId));
//设置外观
if (() == TextNote.MODE_CHECK_LIST) {
switchToListMode(());
} else {
(getHighlightQueryResult((), mUserQuery));
(().length());
}
for (Integer id : ()) {
findViewById((id)).setVisibility();
}
(());
(());
((this,
(), DateUtils.FORMAT_SHOW_DATE
| DateUtils.FORMAT_NUMERIC_DATE | DateUtils.FORMAT_SHOW_TIME
| DateUtils.FORMAT_SHOW_YEAR));
/**
* TODO: Add the menu for setting alert. Currently disable it because the DateTimePicker
* is not ready
*/
showAlertHeader();
}
//设置闹钟的显示
private void showAlertHeader() {
if (()) {
long time = ();
if (time > ()) {
(.note_alert_expired);
}
//如果系统时间大于了闹钟设置的时间，那么闹钟失效
else {
((
(), time, DateUtils.MINUTE_IN_MILLIS));
}
();
();
//显示闹钟开启的图标
} else {
();
();
};
}
@Override
protected void onNewIntent(Intent intent) {
(intent);
initActivityState(intent);
}
@Override
protected void onSaveInstanceState(Bundle outState) {
(outState);
/**
* For new note without note id, we should firstly save it to
* generate a id. If the editing note is not worth saving, there
* is no id which is equivalent to create new note
*/
if (!()) {
saveNote();
}
//在创建一个新的标签时，先在数据库中匹配
//如果不存在，那么先在数据库中存储
(Intent.EXTRA_UID, ());
(TAG, "Save working note id: " + () + " onSaveInstanceState");
}
@Override
//MotionEvent是对屏幕触控的传递机制
public boolean dispatchTouchEvent(MotionEvent ev) {
if (() ==
&& !inRangeOfView(mNoteBgColorSelector, ev)) {
();
return true;
}//颜色选择器在屏幕上可见
if (() ==
&& !inRangeOfView(mFontSizeSelector, ev)) {
();
return true;
}//字体大小选择器在屏幕上可见
return (ev);
}
//对屏幕触控的坐标进行操作
private boolean inRangeOfView(View view, MotionEvent ev) {
int []location = new int[2];
(location);
int x = location[0];
int y = location[1];
if (() < x
|| () > (x + ())
|| () < y
|| () > (y + ()))
//如果触控的位置超出了给定的范围，返回false
{
return false;
}
return true;
}
private void initResources() {
mHeadViewPanel = findViewById(.note_title);
mNoteHeaderHolder = new HeadViewHolder();
= (TextView) findViewById(.tv_modified_date);
= (ImageView) findViewById(.iv_alert_icon);
= (TextView) findViewById(.tv_alert_date);
= (ImageView) findViewById(.btn_set_bg_color);
(this);
mNoteEditor = (EditText) findViewById(.note_edit_view);
mNoteEditorPanel = findViewById(.sv_note_edit);
mNoteBgColorSelector = findViewById(.note_bg_color_selector);
for (int id : ()) {
ImageView iv = (ImageView) findViewById(id);
(this);
}//对标签各项属性内容的初始化
mFontSizeSelector = findViewById(.font_size_selector);
for (int id : ()) {
View view = findViewById(id);
(this);
};//对字体大小的选择
mSharedPrefs = (this);
mFontSizeId = (PREFERENCE_FONT_SIZE, ResourceParser.BG_DEFAULT_FONT_SIZE);
/**
* HACKME: Fix bug of store the resource id in shared preference.
* The id may larger than the length of resources, in this case,
* return the {@link ResourceParser#BG_DEFAULT_FONT_SIZE}
*/
if(mFontSizeId >= ()) {
mFontSizeId = ResourceParser.BG_DEFAULT_FONT_SIZE;
}
mEditTextList = (LinearLayout) findViewById(.note_edit_list);
}
@Override
protected void onPause() {
();
if(saveNote()) {
(TAG, "Note data was saved with length:" + ().length());
}
clearSettingState();
}
//和桌面小工具的同步
private void updateWidget() {
Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
if (() == Notes.TYPE_WIDGET_2X) {
(this, NoteWidgetProvider_2x.class);
} else if (() == Notes.TYPE_WIDGET_4X) {
(this, NoteWidgetProvider_4x.class);
} else {
(TAG, "Unspported widget type");
return;
}
(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] {
()
});
sendBroadcast(intent);
setResult(RESULT_OK, intent);
}
public void onClick(View v) {
int id = ();
if (id == .btn_set_bg_color) {
();
findViewById((())).setVisibility(
- );
} else if ((id)) {
findViewById((())).setVisibility(
);
((id));
();
} else if ((id)) {
findViewById((mFontSizeId)).setVisibility();
mFontSizeId = (id);
().putInt(PREFERENCE_FONT_SIZE, mFontSizeId).commit();
findViewById((mFontSizeId)).setVisibility();
if (() == TextNote.MODE_CHECK_LIST) {
getWorkingText();
switchToListMode(());
} else {
(this,
(mFontSizeId));
}
();
}
}//************************存在问题
@Override
public void onBackPressed() {
if(clearSettingState()) {
return;
}
saveNote();
();
}
private boolean clearSettingState() {
if (() == ) {
();
return true;
} else if (() == ) {
();
return true;
}
return false;
}
public void onBackgroundColorChanged() {
findViewById((())).setVisibility(
);
(());
(());
}
@Override
//对选择菜单的准备
public boolean onPrepareOptionsMenu(Menu menu) {
if (isFinishing()) {
return true;
}
clearSettingState();
();
if (() == Notes.ID_CALL_RECORD_FOLDER) {
getMenuInflater().inflate(.call_note_edit, menu);
// MenuInflater是用来实例化Menu目录下的Menu布局文件的
} else {
getMenuInflater().inflate(.note_edit, menu);
}
if (() == TextNote.MODE_CHECK_LIST) {
(.menu_list_mode).setTitle(.menu_normal_mode);
} else {
(.menu_list_mode).setTitle(.menu_list_mode);
}
if (()) {
(.menu_alert).setVisible(false);
} else {
(.menu_delete_remind).setVisible(false);
}
return true;
}
@Override
/*
* 函数功能：动态改变菜单选项内容
* 函数实现：如下注释
*/
public boolean onOptionsItemSelected(MenuItem item) {
switch (()) {
//根据菜单的id来编剧相关项目
case .menu_new_note:
//创建一个新的便签
createNewNote();
break;
case .menu_delete:
//删除便签
builder = new (this);
//创建关于删除操作的对话框
(getString(.alert_title_delete));
// 设置标签的标题为alert_title_delete
(.ic_dialog_alert);
//设置对话框图标
(getString(.alert_message_delete_note));
//设置对话框内容
(,
new () {
//建立按键监听器
public void onClick(DialogInterface dialog, int which) {
//点击所触发事件
deleteCurrentNote();
// 删除单签便签
finish();
}
});
//添加“YES”按钮
(, null);
//添加“NO”的按钮
();
//显示对话框
break;
case .menu_font_size:
//字体大小的编辑
();
// 将字体选择器置为可见
findViewById((mFontSizeId)).setVisibility();
// 通过id找到相应的大小
break;
case .menu_list_mode:
//选择列表模式
(() == 0 ?
TextNote.MODE_CHECK_LIST : 0);
break;
case .menu_share:
//菜单共享
getWorkingText();
sendTo(this, ());
// 用sendto函数将运行文本发送到遍历的本文内
break;
case .menu_send_to_desktop:
//发送到桌面
sendToDesktop();
break;
case .menu_alert:
//创建提醒器
setReminder();
break;
case .menu_delete_remind:
//删除日期提醒
(0, false);
break;
default:
break;
}
return true;
}
/*
* 函数功能：建立事件提醒器
* 函数实现：如下注释
*/
private void setReminder() {
DateTimePickerDialog d = new DateTimePickerDialog(this, ());
// 建立修改时间日期的对话框
(new OnDateTimeSetListener() {
public void OnDateTimeSet(AlertDialog dialog, long date) {
(date , true);
//选择提醒的日期
}
});
//建立时间日期的监听器
();
//显示对话框
}
/**
* Share note to apps that support {@link Intent#ACTION_SEND} action
* and {@text/plain} type
*/
/*
* 函数功能：共享便签
* 函数实现：如下注释
*/
private void sendTo(Context context, String info) {
Intent intent = new Intent(Intent.ACTION_SEND);
//建立intent链接选项
(Intent.EXTRA_TEXT, info);
//将需要传递的便签信息放入text文件中
("text/plain");
//编辑连接器的类型
(intent);
//在acti中进行链接
}
/*
* 函数功能：创建一个新的便签
* 函数实现：如下注释
*/
private void createNewNote() {
// Firstly, save current editing notes
//保存当前便签
saveNote();
// For safety, start a new NoteEditActivity
finish();
Intent intent = new Intent(this, );
//设置链接器
(Intent.ACTION_INSERT_OR_EDIT);
//该活动定义为创建或编辑
(Notes.INTENT_EXTRA_FOLDER_ID, ());
//将运行便签的id添加到INTENT_EXTRA_FOLDER_ID标记中
startActivity(intent);
//开始activity并链接
}
/*
* 函数功能：删除当前便签
* 函数实现：如下注释
*/
private void deleteCurrentNote() {
if (()) {
//假如当前运行的便签内存有数据
HashSet<Long> ids = new HashSet<Long>();
long id = ();
if (id != Notes.ID_ROOT_FOLDER) {
(id);
//如果不是头文件夹建立一个hash表把便签id存起来
} else {
(TAG, "Wrong note id, should not happen");
//否则报错
}
if (!isSyncMode()) {
//在非同步模式情况下
//删除操作
if (!(getContentResolver(), ids)) {
(TAG, "Delete Note error");
}
} else {
//同步模式
//移动至垃圾文件夹的操作
if (!(getContentResolver(), ids, Notes.ID_TRASH_FOLER)) {
(TAG, "Move notes to trash folder error, should not happens");
}
}
}
(true);
//将这些标签的删除标记置为true
}
/*
* 函数功能：判断是否为同步模式
* 函数实现：直接看NotesPreferenceActivity中同步名称是否为空
*/
private boolean isSyncMode() {
return (this).trim().length() > 0;
}
/*
* 函数功能：设置提醒时间
* 函数实现：如下注释
*/
public void onClockAlertChanged(long date, boolean set) {
/**
* User could set clock to an unsaved note, so before setting the
* alert clock, we should save the note first
*/
if (!()) {
//首先保存已有的便签
saveNote();
}
if (() > 0) {
Intent intent = new Intent(this, );
((Notes.CONTENT_NOTE_URI, ()));
//若有有运行的便签就是建立一个链接器将标签id都存在uri中
PendingIntent pendingIntent = (this, 0, intent, 0);
AlarmManager alarmManager = ((AlarmManager) getSystemService(ALARM_SERVICE));
//设置提醒管理器
showAlertHeader();
if(!set) {
(pendingIntent);
} else {
(AlarmManager.RTC_WAKEUP, date, pendingIntent);
}
//如果用户设置了时间，就通过提醒管理器设置一个监听事项
} else {
/**
* There is the condition that user has input nothing (the note is
* not worthy saving), we have no note id, remind the user that he
* should input something
*/
//没有运行的便签就报错
(TAG, "Clock alert setting error");
showToast(.error_note_empty_for_clock);
}
}
/*
* 函数功能：Widget发生改变的所触发的事件
*/
public void onWidgetChanged() {
updateWidget();//更新Widget
}
/*
* 函数功能： 删除编辑文本框所触发的事件
* 函数实现：如下注释
*/
public void onEditTextDelete(int index, String text) {
int childCount = ();
if (childCount == 1) {
return;
}
//没有编辑框的话直接返回
for (int i = index + 1; i < childCount; i++) {
((NoteEditText) (i).findViewById(.et_edit_text))
.setIndex(i - 1);
//通过id把编辑框存在便签编辑框中
}
(index);
//删除特定位置的视图
NoteEditText edit = null;
if(index == 0) {
edit = (NoteEditText) (0).findViewById(
.et_edit_text);
} else {
edit = (NoteEditText) (index - 1).findViewById(
.et_edit_text);
}
//通过id把编辑框存在空的NoteEditText中
int length = ();
(text);
();//请求优先完成该此 编辑
(length);//定位到length位置处的条目
}
/*
* 函数功能：进入编辑文本框所触发的事件
* 函数实现：如下注释
*/
public void onEditTextEnter(int index, String text) {
/**
* Should not happen, check for debug
*/
if(index > ()) {
(TAG, "Index out of mEditTextList boundrary, should not happen");
//越界把偶偶
}
View view = getListItem(text, index);
(view, index);
//建立一个新的视图并添加到编辑文本框内
NoteEditText edit = (NoteEditText) (.et_edit_text);
();//请求优先操作
(0);//定位到起始位置
for (int i = index + 1; i < (); i++) {
((NoteEditText) (i).findViewById(.et_edit_text))
.setIndex(i);
//遍历子文本框并设置对应对下标
}
}
/*
* 函数功能：切换至列表模式
* 函数实现：如下注释
*/
private void switchToListMode(String text) {
();
String[] items = ("\n");
int index = 0;
//清空所有视图，初始化下标
for (String item : items) {
if(!(item)) {
(getListItem(item, index));
index++;
//遍历所有文本单元并添加到文本框中
}
}
(getListItem("", index));
(index).findViewById(.et_edit_text).requestFocus();
//优先请求此操作
();
//便签编辑器不可见
();
//将文本编辑框置为可见
}
/*
* 函数功能：获取高亮效果的反馈情况
* 函数实现：如下注释
*/
private Spannable getHighlightQueryResult(String fullText, String userQuery) {
SpannableString spannable = new SpannableString(fullText == null ? "" : fullText);
//新建一个效果选项
if (!(userQuery)) {
mPattern = (userQuery);
//将用户的询问进行解析
Matcher m = (fullText);
//建立一个状态机检查Pattern并进行匹配
int start = 0;
while ((start)) {
(
new BackgroundColorSpan(().getColor(
.user_query_highlight)), (), (),
Spannable.SPAN_INCLUSIVE_EXCLUSIVE);
//设置背景颜色
start = ();
//跟新起始位置
}
}
return spannable;
}
/*
* 函数功能：获取列表项
* 函数实现：如下注释
*/
private View getListItem(String item, int index) {
View view = (this).inflate(.note_edit_list_item, null);
//创建一个视图
final NoteEditText edit = (NoteEditText) (.et_edit_text);
(this, (mFontSizeId));
//创建一个文本编辑框并设置可见性
CheckBox cb = ((CheckBox) (.cb_edit_item));
(new OnCheckedChangeListener() {
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
if (isChecked) {
(() | Paint.STRIKE_THRU_TEXT_FLAG);
} else {
(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG);
}
}
});
//建立一个打钩框并设置监听器
if ((TAG_CHECKED)) {
//选择勾选
(true);
(() | Paint.STRIKE_THRU_TEXT_FLAG);
item = (TAG_CHECKED.length(), ()).trim();
} else if ((TAG_UNCHECKED)) {
//选择不勾选
(false);
(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG);
item = (TAG_UNCHECKED.length(), ()).trim();
}
(this);
(index);
(getHighlightQueryResult(item, mUserQuery));
//运行编辑框的监听器对该行为作出反应，并设置下标及文本内容
return view;
}
/*
* 函数功能：便签内容发生改变所 触发的事件
* 函数实现：如下注释
*/
public void onTextChange(int index, boolean hasText) {
if (index >= ()) {
(TAG, "Wrong index, should not happen");
return;
//越界报错
}
if(hasText) {
(index).findViewById(.cb_edit_item).setVisibility();
} else {
(index).findViewById(.cb_edit_item).setVisibility();
}
//如果内容不为空则将其子编辑框可见性置为可见，否则不可见
}
/*
* 函数功能：检查模式和列表模式的切换
* 函数实现：如下注释
*/
public void onCheckListModeChanged(int oldMode, int newMode) {
if (newMode == TextNote.MODE_CHECK_LIST) {
switchToListMode(().toString());
//检查模式切换到列表模式
} else {
if (!getWorkingText()) {
(().replace(TAG_UNCHECKED + " ",
""));
}
//若是获取到文本就改变其检查标记
(getHighlightQueryResult((), mUserQuery));
();
();
//修改文本编辑器的内容和可见性
}
}
/*
* 函数功能：设置勾选选项表并返回是否勾选的标记
* 函数实现：如下注释
*/
private boolean getWorkingText() {
boolean hasChecked = false;
//初始化check标记
if (() == TextNote.MODE_CHECK_LIST) {
// 若模式为CHECK_LIST
StringBuilder sb = new StringBuilder();
//创建可变字符串
for (int i = 0; i < (); i++) {
View view = (i);
//遍历所有子编辑框的视图
NoteEditText edit = (NoteEditText) (.et_edit_text);
if (!(())) {
//若文本不为空
if (((CheckBox) (.cb_edit_item)).isChecked()) {
//该选项框已打钩
(TAG_CHECKED).append(" ").append(()).append("\n");
hasChecked = true;
//扩展字符串为已打钩并把标记置true
} else {
(TAG_UNCHECKED).append(" ").append(()).append("\n");
//扩展字符串添加未打钩
}
}
}
(());
//利用编辑好的字符串设置运行便签的内容
} else {
(().toString());
// 若不是该模式直接用编辑器中的内容设置运行中标签的内容
}
return hasChecked;
}
/*
* 函数功能：保存便签
* 函数实现：如下注释
*/
private boolean saveNote() {
getWorkingText();
boolean saved = ();
//运行 getWorkingText()之后保存
if (saved) {
/**
* There are two modes from List view to edit view, open one note,
* create/edit a node. Opening node requires to the original
* position in the list when back from edit view, while creating a
* new node requires to the top of the list. This code
* {@link #RESULT_OK} is used to identify the create/edit state
*/
//如英文注释所说链接RESULT_OK是为了识别保存的2种情况，一是创建后保存，二是修改后保存
setResult(RESULT_OK);
}
return saved;
}
/*
* 函数功能：将便签发送至桌面
* 函数实现：如下注释
*/
private void sendToDesktop() {
/**
* Before send message to home, we should make sure that current
* editing note is exists in databases. So, for new note, firstly
* save it
*/
if (!()) {
saveNote();
//若不存在数据也就是新的标签就保存起来先
}
if (() > 0) {
//若是有内容
Intent sender = new Intent();
Intent shortcutIntent = new Intent(this, );
//建立发送到桌面的连接器
(Intent.ACTION_VIEW);
//链接为一个视图
(Intent.EXTRA_UID, ());
(Intent.EXTRA_SHORTCUT_INTENT, shortcutIntent);
(Intent.EXTRA_SHORTCUT_NAME,
makeShortcutIconTitle(()));
(Intent.EXTRA_SHORTCUT_ICON_RESOURCE,
(this, .icon_app));
("duplicate", true);
//将便签的相关信息都添加到要发送的文件里
(".INSTALL_SHORTCUT");
//设置sneder的行为是发送
showToast(.info_note_enter_desktop);
sendBroadcast(sender);
//显示到桌面
} else {
/**
* There is the condition that user has input nothing (the note is
* not worthy saving), we have no note id, remind the user that he
* should input something
*/
(TAG, "Send to desktop error");
showToast(.error_note_empty_for_send_to_desktop);
//空便签直接报错
}
}
/*
* 函数功能：编辑小图标的标题
* 函数实现：如下注释
*/
private String makeShortcutIconTitle(String content) {
content = (TAG_CHECKED, "");
content = (TAG_UNCHECKED, "");
return () > SHORTCUT_ICON_TITLE_MAX_LEN ? (0,
SHORTCUT_ICON_TITLE_MAX_LEN) : content;
//直接设置为content中的内容并返回，有勾选和未勾选2种
}
/*
* 函数功能：显示提示的视图
* 函数实现：根据下标显示对应的提示
*/
private void showToast(int resId) {
showToast(resId, Toast.LENGTH_SHORT);
}
/*
* 函数功能：持续显示提示的视图
* 函数实现：根据下标和持续的时间（duration）编辑提示视图并显示
*/
private void showToast(int resId, int duration) {
(this, resId, duration).show();
}
}
9、
package ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
//继承edittext，设置便签设置文本框
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:" ;
///建立一个字符和整数的hash表，用于链接电话，网站，还有邮箱
private static final Map<String, Integer> sSchemaActionResMap = new HashMap<String, Integer>();
static {
(SCHEME_TEL, .note_link_tel);
(SCHEME_HTTP, .note_link_web);
(SCHEME_EMAIL, .note_link_email);
}
/**
* Call by the {@link NoteEditActivity} to delete or add edit text
*/
//在NoteEditActivity中删除或添加文本的操作，可以看做是一个文本是否被变的标记，英文注释已说明的很清楚
public interface OnTextViewChangeListener {
/**
* Delete current edit text when {@link KeyEvent#KEYCODE_DEL} happens
* and the text is null
*/
//处理删除按键时的操作
void onEditTextDelete(int index, String text);
/**
* Add edit text after current edit text when {@link KeyEvent#KEYCODE_ENTER}
* happen
*/
//处理进入按键时的操作
void onEditTextEnter(int index, String text);
/**
* Hide or show item option when text change
*/
void onTextChange(int index, boolean hasText);
}
private OnTextViewChangeListener mOnTextViewChangeListener;
//根据context设置文本
public NoteEditText(Context context) {
super(context, null);//用super引用父类变量
mIndex = 0;
}
//设置当前光标
public void setIndex(int index) {
mIndex = index;
}
//初始化文本修改标记
public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
mOnTextViewChangeListener = listener;
}
//AttributeSet 百度了一下是自定义空控件属性，用于维护便签动态变化的属性
//初始化便签
public NoteEditText(Context context, AttributeSet attrs) {
super(context, attrs, );
}
// 根据defstyle自动初始化
public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
// TODO Auto-generated construct or stub
}
@Override
//view里的函数，处理手机屏幕的所有事件
/*参数event为手机屏幕触摸事件封装类的对象，其中封装了该事件的所有信息，
例如触摸的位置、触摸的类型以及触摸的时间等。该对象会在用户触摸手机屏幕时被创建。*/
public boolean onTouchEvent(MotionEvent event) {
switch (()) {
//重写了需要处理屏幕被按下的事件
case MotionEvent.ACTION_DOWN:
//跟新当前坐标值
int x = (int) ();
int y = (int) ();
x -= getTotalPaddingLeft();
y -= getTotalPaddingTop();
x += getScrollX();
y += getScrollY();
//用布局控件layout根据x,y的新值设置新的位置
Layout layout = getLayout();
int line = (y);
int off = (line, x);
//更新光标新的位置
(getText(), off);
break;
}
return (event);
}
@Override
/*
* 函数功能：处理用户按下一个键盘按键时会触发 的事件
* 实现过程：如下注释
*/
public boolean onKeyDown(int keyCode, KeyEvent event) {
switch (keyCode) {
//根据按键的 Unicode 编码值来处理
case KeyEvent.KEYCODE_ENTER:
//“进入”按键
if (mOnTextViewChangeListener != null) {
return false;
}
break;
case KeyEvent.KEYCODE_DEL:
//“删除”按键
mSelectionStartBeforeDelete = getSelectionStart();
break;
default:
break;
}
//继续执行父类的其他点击事件
return (keyCode, event);
}
@Override
/*
* 函数功能：处理用户松开一个键盘按键时会触发 的事件
* 实现方式：如下注释
*/
public boolean onKeyUp(int keyCode, KeyEvent event) {
switch(keyCode) {
//根据按键的 Unicode 编码值来处理，有删除和进入2种操作
case KeyEvent.KEYCODE_DEL:
if (mOnTextViewChangeListener != null) {
//若是被修改过
if (0 == mSelectionStartBeforeDelete && mIndex != 0) {
//若之前有被修改并且文档不为空
(mIndex, getText().toString());
//利用上文OnTextViewChangeListener对KEYCODE_DEL按键情况的删除函数进行删除
return true;
}
} else {
(TAG, "OnTextViewChangeListener was not seted");
//其他情况报错，文档的改动监听器并没有建立
}
break;
case KeyEvent.KEYCODE_ENTER:
//同上也是分为监听器是否建立2种情况
if (mOnTextViewChangeListener != null) {
int selectionStart = getSelectionStart();
//获取当前位置
String text = getText().subSequence(selectionStart, length()).toString();
//获取当前文本
setText(getText().subSequence(0, selectionStart));
//根据获取的文本设置当前文本
(mIndex + 1, text);
//当{@link KeyEvent#KEYCODE_ENTER}添加新文本
} else {
(TAG, "OnTextViewChangeListener was not seted");
//其他情况报错，文档的改动监听器并没有建立
}
break;
default:
break;
}
//继续执行父类的其他按键弹起的事件
return (keyCode, event);
}
@Override
/*
* 函数功能：当焦点发生变化时，会自动调用该方法来处理焦点改变的事件
* 实现方式：如下注释
* 参数：focused表示触发该事件的View是否获得了焦点，当该控件获得焦点时，Focused等于true，否则等于false。
direction表示焦点移动的方向，用数值表示
Rect：表示在触发事件的View的坐标系中，前一个获得焦点的矩形区域，即表示焦点是从哪里来的。如果不可用则为null
*/
protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
if (mOnTextViewChangeListener != null) {
//若监听器已经建立
if (!focused && (getText())) {
//获取到焦点并且文本不为空
(mIndex, false);
//mOnTextViewChangeListener子函数，置false隐藏事件选项
} else {
(mIndex, true);
//mOnTextViewChangeListener子函数，置true显示事件选项
}
}
//继续执行父类的其他焦点变化的事件
(focused, direction, previouslyFocusedRect);
}
@Override
/*
* 函数功能：生成上下文菜单
* 函数实现：如下注释
*/
protected void onCreateContextMenu(ContextMenu menu) {
if (getText() instanceof Spanned) {
//有文本存在
int selStart = getSelectionStart();
int selEnd = getSelectionEnd();
//获取文本开始和结尾位置
int min = (selStart, selEnd);
int max = (selStart, selEnd);
//获取开始到结尾的最大值和最小值
final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, );
//设置url的信息的范围值
if ( == 1) {
int defaultResId = 0;
for(String schema: ()) {
//获取计划表中所有的key值
if(urls[0].getURL().indexOf(schema) >= 0) {
//若url可以添加则在添加后将defaultResId置为key所映射的值
defaultResId = (schema);
break;
}
}
if (defaultResId == 0) {
//defaultResId == 0则说明url并没有添加任何东西，所以置为连接其他SchemaActionResMap的值
defaultResId = .note_link_other;
}
//建立菜单
(0, 0, 0, defaultResId).setOnMenuItemClickListener(
new OnMenuItemClickListener() {
//新建按键监听器
public boolean onMenuItemClick(MenuItem item) {
// goto a new intent
urls[0].onClick();
//根据相应的文本设置菜单的按键
return true;
}
});
}
}
//继续执行父类的其他菜单创建的事件
(menu);
}
}10、
package ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
public class NoteItemData {
static final String [] PROJECTION = new String [] {
,
NoteColumns.ALERTED_DATE,
NoteColumns.BG_COLOR_ID,
NoteColumns.CREATED_DATE,
NoteColumns.HAS_ATTACHMENT,
NoteColumns.MODIFIED_DATE,
NoteColumns.NOTES_COUNT,
NoteColumns.PARENT_ID,
,
,
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;
//初始化NoteItemData，主要利用光标cursor获取的东西
public NoteItemData(Context context, Cursor cursor) {
//getxxx为转换格式
mId = (ID_COLUMN);
mAlertDate = (ALERTED_DATE_COLUMN);
mBgColorId = (BG_COLOR_ID_COLUMN);
mCreatedDate = (CREATED_DATE_COLUMN);
mHasAttachment = ((HAS_ATTACHMENT_COLUMN) > 0) ? true : false;
mModifiedDate = (MODIFIED_DATE_COLUMN);
mNotesCount = (NOTES_COUNT_COLUMN);
mParentId = (PARENT_ID_COLUMN);
mSnippet = (SNIPPET_COLUMN);
mSnippet = (NoteEditActivity.TAG_CHECKED, "").replace(
NoteEditActivity.TAG_UNCHECKED, "");
mType = (TYPE_COLUMN);
mWidgetId = (WIDGET_ID_COLUMN);
mWidgetType = (WIDGET_TYPE_COLUMN);
//初始化电话号码的信息
mPhoneNumber = "";
if (mParentId == Notes.ID_CALL_RECORD_FOLDER) {
mPhoneNumber = ((), mId);
if (!(mPhoneNumber)) {//mphonenumber里有符合字符串，则用contart功能连接
mName = (context, mPhoneNumber);
if (mName == null) {
mName = mPhoneNumber;
}
}
}
if (mName == null) {
mName = "";
}
checkPostion(cursor);
}
///根据鼠标的位置设置标记，和位置
private void checkPostion(Cursor cursor) {
//初始化几个标记，cursor具体功能笔记中已提到，不一一叙述
mIsLastItem = () ? true : false;
mIsFirstItem = () ? true : false;
mIsOnlyOneItem = (() == 1);
//初始化“多重子文件”“单一子文件”2个标记
mIsMultiNotesFollowingFolder = false;
mIsOneNoteFollowingFolder = false;
//主要是设置上诉2标记
if (mType == Notes.TYPE_NOTE && !mIsFirstItem) {//若是note格式并且不是第一个元素
int position = ();
if (()) {//获取光标位置后看上一行
if ((TYPE_COLUMN) == Notes.TYPE_FOLDER
|| (TYPE_COLUMN) == Notes.TYPE_SYSTEM) {//若光标满足系统或note格式
if (() > (position + 1)) {
mIsMultiNotesFollowingFolder = true;//若是数据行数大于但前位置+1则设置成正确
} else {
mIsOneNoteFollowingFolder = true;//否则单一文件夹标记为true
}
}
if (!()) {//若不能再往下走则报错
throw new IllegalStateException("cursor move to previous but can't move back");
}
}
}
}
///以下都是获取标记没什么好说的，不过倒数第二个需要说明下，很具体看下面
public boolean isOneFollowingFolder() {
return mIsOneNoteFollowingFolder;
}
public boolean isMultiFollowingFolder() {
return mIsMultiNotesFollowingFolder;
}
public boolean isLast() {
return mIsLastItem;
}
public String getCallName() {
return mName;
}
public boolean isFirst() {
return mIsFirstItem;
}
public boolean isSingle() {
return mIsOnlyOneItem;
}
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);
}
//若数据父id为保存至文件夹模式的id且满足电话号码单元不为空，则isCallRecord为true
public boolean isCallRecord() {
return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !(mPhoneNumber));
}
public static int getNoteType(Cursor cursor) {
return (TYPE_COLUMN);
}
}
11、
package ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import .NoteWidgetProvider_2x;
import .NoteWidgetProvider_4x;
import ;
import ;
import ;
import ;
import ;
//主界面，一进入就是这个界面
/**
* @author k
*
*/
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 = ""; //单行超过80个字符
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;
private int mOriginY;
private int mDispatchY;
private TextView mTitleBar;
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 = "(" + + "<>"
+ Notes.TYPE_SYSTEM + " AND " + NoteColumns.PARENT_ID + "=?)" + " OR ("
+ + "=" + Notes.ID_CALL_RECORD_FOLDER + " AND "
+ NoteColumns.NOTES_COUNT + ">0)";
private final static int REQUEST_CODE_OPEN_NODE = 102;
private final static int REQUEST_CODE_NEW_NODE = 103;
@Override
// 创建类
protected void onCreate(final Bundle savedInstanceState) { //需要是final类型 根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。
// final类不能被继承，没有子类，final类中的方法默认是final的。
//final方法不能被子类的方法覆盖，但可以被继承。
//final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
//final不能用于修饰构造方法。
(savedInstanceState); // 调用父类的onCreate函数
setContentView(.note_list);
initResources();
/**
* Insert an introduction when user firstly use this application
*/
setAppInfoFromRawRes();
}
@Override
// 返回一些子模块完成的数据交给主Activity处理
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
// 结果值 和 要求值 符合要求
if (resultCode == RESULT_OK
&& (requestCode == REQUEST_CODE_OPEN_NODE || requestCode == REQUEST_CODE_NEW_NODE)) {
(null);
} else {
(requestCode, resultCode, data);
// 调用 Activity 的onActivityResult（）
}
}
private void setAppInfoFromRawRes() {
// Android平台给我们提供了一个SharedPreferences类，它是一个轻量级的存储类，特别适合用于保存软件配置参数。
SharedPreferences sp = (this);
if (!(PREFERENCE_ADD_INTRODUCTION, false)) {
StringBuilder sb = new StringBuilder();
InputStream in = null;
try {
// 把资源文件放到应用程序的/raw/raw下，那么就可以在应用中使用getResources获取资源后,
// 以openRawResource方法（不带后缀的资源文件名）打开这个文件。
in = getResources().openRawResource();
if (in != null) {
InputStreamReader isr = new InputStreamReader(in);
BufferedReader br = new BufferedReader(isr);
char [] buf = new char[1024]; // 自行定义的数值，使用者不知道有什么意义
int len = 0;
while ((len = (buf)) > 0) {
(buf, 0, len);
}
} else {
(TAG, "Read introduction file error");
return;
}
} catch (IOException e) {
();
return;
} finally {
if (in != null) {
try {
();
} catch (IOException e) {
// TODO Auto-generated catch block
();
}
}
}
// 创建空的WorkingNote
WorkingNote note = (this, Notes.ID_ROOT_FOLDER,
AppWidgetManager.INVALID_APPWIDGET_ID, Notes.TYPE_WIDGET_INVALIDE,
);
(());
if (()) {
// 更新保存note的信息
().putBoolean(PREFERENCE_ADD_INTRODUCTION, true).commit();
} else {
(TAG, "Save introduction note error");
return;
}
}
}
@Override
protected void onStart() {
();
startAsyncNotesListQuery();
}
// 初始化资源
private void initResources() {
mContentResolver = (); // 获取应用程序的数据，得到类似数据表的东西
mBackgroundQueryHandler = new BackgroundQueryHandler(());
mCurrentFolderId = Notes.ID_ROOT_FOLDER;
// findViewById 是安卓编程的定位函数，主要是引用.R文件里的引用名
mNotesListView = (ListView) findViewById(.notes_list); // 绑定XML中的ListView，作为Item的容器
((this).inflate(.note_list_footer, null),
null, false);
(new OnListItemClickListener());
(this);
mNotesListAdapter = new NotesListAdapter(this);
(mNotesListAdapter);
mAddNewNote = (Button) findViewById(.btn_new_note);// 在activity中要获取该按钮
(this);
(new NewNoteOnTouchListener());
mDispatch = false;
mDispatchY = 0;
mOriginY = 0;
mTitleBar = (TextView) findViewById(.tv_title_bar);
mState = ListEditState.NOTE_LIST;
mModeCallBack = new ModeCallback();
}
// 继承自 和 OnMenuItemClickListener
private class ModeCallback implements , OnMenuItemClickListener {
private DropdownMenu mDropDownMenu;
private ActionMode mActionMode;
private MenuItem mMoveMenu;
public boolean onCreateActionMode(ActionMode mode, Menu menu) {
getMenuInflater().inflate(.note_list_options, menu);
().setOnMenuItemClickListener(this);
mMoveMenu = ();
if (() == Notes.ID_CALL_RECORD_FOLDER
|| (mContentResolver) == 0) {
(false);
} else {
(true);
(this);
}
mActionMode = mode;
(true);
(false);
();
View customView = ().inflate(
.note_list_dropdown_menu, null);
(customView);
mDropDownMenu = new DropdownMenu(,
(Button) (.selection_menu),
.note_list_dropdown);
(new (){
public boolean onMenuItemClick(final MenuItem item) {
(!());
updateMenu();
return true;
}
});
return true;
}
// 更新菜单
private void updateMenu() {
int selectedCount = ();
// Update dropdown menu
String format = getResources().getString(.menu_select_title, selectedCount);
(format); // 更改标题
MenuItem item = (.action_select_all);
if (item != null) {
if (()) {
(true);
(.menu_deselect_all);
} else {
(false);
(.menu_select_all);
}
}
}
public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
// TODO Auto-generated method stub
return false;
}
public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
// TODO Auto-generated method stub
return false;
}
public void onDestroyActionMode(ActionMode mode) {
(false);
(true);
();
}
public void finishActionMode() {
();
}
public void onItemCheckedStateChanged(ActionMode mode, int position, long id,
boolean checked) {
(position, checked);
updateMenu();
}
public boolean onMenuItemClick(MenuItem item) {
if (() == 0) {
(, getString(.menu_select_none),
Toast.LENGTH_SHORT).show();
return true;
}
switch (()) {
case :
builder = new ();
(getString(.alert_title_delete));
(.ic_dialog_alert);
(getString(.alert_message_delete_notes,
()));
(,
new () {
public void onClick(DialogInterface dialog,
int which) {
batchDelete();
}
});
(, null);
();
break;
case :
startQueryDestinationFolders();
break;
default:
return false;
}
return true;
}
}
private class NewNoteOnTouchListener implements OnTouchListener {
public boolean onTouch(View v, MotionEvent event) {
switch (()) {
case MotionEvent.ACTION_DOWN: {
Display display = getWindowManager().getDefaultDisplay();
int screenHeight = ();
int newNoteViewHeight = ();
int start = screenHeight - newNoteViewHeight;
int eventY = start + (int) ();
/**
* Minus TitleBar's height
*/
if (mState == ListEditState.SUB_FOLDER) {
eventY -= ();
start -= ();
}
/**
* HACKME:When click the transparent part of "New Note" button, dispatch
* the event to the list view behind this button. The transparent part of
* "New Note" button could be expressed by formula y=-0.12x+94锛圲nit:pixel锛�
* and the line top of the button. The coordinate based on left of the "New
* Note" button. The 94 represents maximum height of the transparent part.
* Notice that, if the background of the button changes, the formula should
* also change. This is very bad, just for the UI designer's strong requirement.
*/
if (() < (() * (-0.12) + 94)) {
View view = (() - 1
- ());
if (view != null && () > start
&& (() < (start + 94))) {
mOriginY = (int) ();
mDispatchY = eventY;
((), mDispatchY);
mDispatch = true;
return (event);
}
}
break;
}
case MotionEvent.ACTION_MOVE: {
if (mDispatch) {
mDispatchY += (int) () - mOriginY;
((), mDispatchY);
return (event);
}
break;
}
default: {
if (mDispatch) {
((), mDispatchY);
mDispatch = false;
return (event);
}
break;
}
}
return false;
}
};
private void startAsyncNotesListQuery() {
String selection = (mCurrentFolderId == Notes.ID_ROOT_FOLDER) ? ROOT_FOLDER_SELECTION
: NORMAL_SELECTION;
(FOLDER_NOTE_LIST_QUERY_TOKEN, null,
Notes.CONTENT_NOTE_URI, , selection, new String[] {
(mCurrentFolderId)
}, + " DESC," + NoteColumns.MODIFIED_DATE + " DESC");
}
private final class BackgroundQueryHandler extends AsyncQueryHandler {
public BackgroundQueryHandler(ContentResolver contentResolver) {
super(contentResolver);
}
@Override
protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
switch (token) {
case FOLDER_NOTE_LIST_QUERY_TOKEN:
(cursor);
break;
case FOLDER_LIST_QUERY_TOKEN:
if (cursor != null && () > 0) {
showFolderListMenu(cursor);
} else {
(TAG, "Query folder failed");
}
break;
default:
return;
}
}
}
private void showFolderListMenu(Cursor cursor) {
builder = new ();
(.menu_title_select_folder);
final FoldersListAdapter adapter = new FoldersListAdapter(this, cursor);
(adapter, new () {
public void onClick(DialogInterface dialog, int which) {
(mContentResolver,
(), (which));
(
,
getString(.format_move_notes_to_folder,
(),
(, which)),
Toast.LENGTH_SHORT).show();
();
}
});
();
}
private void createNewNote() {
Intent intent = new Intent(this, );
(Intent.ACTION_INSERT_OR_EDIT);
(Notes.INTENT_EXTRA_FOLDER_ID, mCurrentFolderId);
(intent, REQUEST_CODE_NEW_NODE);
}
private void batchDelete() {
new AsyncTask<Void, Void, HashSet<AppWidgetAttribute>>() {
protected HashSet<AppWidgetAttribute> doInBackground(Void... unused) {
HashSet<AppWidgetAttribute> widgets = ();
if (!isSyncMode()) {
// if not synced, delete notes directly
if ((mContentResolver, mNotesListAdapter
.getSelectedItemIds())) {
} else {
(TAG, "Delete notes error, should not happens");
}
} else {
// in sync mode, we'll move the deleted note into the trash
// folder
if (!(mContentResolver, mNotesListAdapter
.getSelectedItemIds(), Notes.ID_TRASH_FOLER)) {
(TAG, "Move notes to trash folder error, should not happens");
}
}
return widgets;
}
@Override
protected void onPostExecute(HashSet<AppWidgetAttribute> widgets) {
if (widgets != null) {
for (AppWidgetAttribute widget : widgets) {
if ( != AppWidgetManager.INVALID_APPWIDGET_ID
&& != Notes.TYPE_WIDGET_INVALIDE) {
updateWidget(, );
}
}
}
();
}
}.execute();
}
private void deleteFolder(long folderId) {
if (folderId == Notes.ID_ROOT_FOLDER) {
(TAG, "Wrong folder id, should not happen " + folderId);
return;
}
HashSet<Long> ids = new HashSet<Long>();
(folderId);
HashSet<AppWidgetAttribute> widgets = (mContentResolver,
folderId);
if (!isSyncMode()) {
// if not synced, delete folder directly
(mContentResolver, ids);
} else {
// in sync mode, we'll move the deleted folder into the trash folder
(mContentResolver, ids, Notes.ID_TRASH_FOLER);
}
if (widgets != null) {
for (AppWidgetAttribute widget : widgets) {
if ( != AppWidgetManager.INVALID_APPWIDGET_ID
&& != Notes.TYPE_WIDGET_INVALIDE) {
updateWidget(, );
}
}
}
}
private void openNode(NoteItemData data) {
Intent intent = new Intent(this, );
(Intent.ACTION_VIEW);
(Intent.EXTRA_UID, ());
(intent, REQUEST_CODE_OPEN_NODE);
}
private void openFolder(NoteItemData data) {
mCurrentFolderId = ();
startAsyncNotesListQuery();
if (() == Notes.ID_CALL_RECORD_FOLDER) {
mState = ListEditState.CALL_RECORD_FOLDER;
();
} else {
mState = ListEditState.SUB_FOLDER;
}
if (() == Notes.ID_CALL_RECORD_FOLDER) {
(.call_record_folder_name);
} else {
(());
}
();
}
public void onClick(View v) {
switch (()) {
case .btn_new_note:
createNewNote();
break;
default:
break;
}
}
private void showSoftInput() {
InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
if (inputMethodManager != null) {
(InputMethodManager.SHOW_FORCED, 0);
}
}
private void hideSoftInput(View view) {
InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
((), 0);
}
private void showCreateOrModifyFolderDialog(final boolean create) {
final builder = new (this);
View view = (this).inflate(.dialog_edit_text, null);
final EditText etName = (EditText) (.et_foler_name);
showSoftInput();
if (!create) {
if (mFocusNoteDataItem != null) {
(());
(getString(.menu_folder_change_name));
} else {
(TAG, "The long click data item is null");
return;
}
} else {
("");
((.menu_create_folder));
}
(, null);
(, new () {
public void onClick(DialogInterface dialog, int which) {
hideSoftInput(etName);
}
});
final Dialog dialog = (view).show();
final Button positive = (Button)(.button1);
(new OnClickListener() {
public void onClick(View v) {
hideSoftInput(etName);
String name = ().toString();
if ((mContentResolver, name)) {
(, getString(.folder_exist, name),
Toast.LENGTH_LONG).show();
(0, ());
return;
}
if (!create) {
if (!(name)) {
ContentValues values = new ContentValues();
(, name);
(, Notes.TYPE_FOLDER);
(NoteColumns.LOCAL_MODIFIED, 1);
(Notes.CONTENT_NOTE_URI, values,
+ "=?", new String[] {
(())
});
}
} else if (!(name)) {
ContentValues values = new ContentValues();
(, name);
(, Notes.TYPE_FOLDER);
(Notes.CONTENT_NOTE_URI, values);
}
();
}
});
if ((())) {
(false);
}
/**
* When the name edit text is null, disable the positive button
*/
(new TextWatcher() {
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
// TODO Auto-generated method stub
}
public void onTextChanged(CharSequence s, int start, int before, int count) {
if ((())) {
(false);
} else {
(true);
}
}
public void afterTextChanged(Editable s) {
// TODO Auto-generated method stub
}
});
}
/* (non-Javadoc)
* @see #onBackPressed()
* 按返回键时根据情况更改类中的数据
*/
@Override
public void onBackPressed() { switch (mState) {
case SUB_FOLDER:
mCurrentFolderId = Notes.ID_ROOT_FOLDER;
mState = ListEditState.NOTE_LIST;
startAsyncNotesListQuery();
();
break;
case CALL_RECORD_FOLDER:
mCurrentFolderId = Notes.ID_ROOT_FOLDER;
mState = ListEditState.NOTE_LIST;
();
();
startAsyncNotesListQuery();
break;
case NOTE_LIST:
();
break;
default:
break;
}
}
/**
* @param appWidgetId
* @param appWidgetType
* 根据不同类型的widget更新插件，通过intent传送数据
*/
private void updateWidget(int appWidgetId, int appWidgetType) {
Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
if (appWidgetType == Notes.TYPE_WIDGET_2X) {
(this, NoteWidgetProvider_2x.class);
} else if (appWidgetType == Notes.TYPE_WIDGET_4X) {
(this, NoteWidgetProvider_4x.class);
} else {
(TAG, "Unspported widget type");
return;
}
(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) {
(());
(0, MENU_FOLDER_VIEW, 0, .menu_folder_view);
(0, MENU_FOLDER_DELETE, 0, .menu_folder_delete);
(0, MENU_FOLDER_CHANGE_NAME, 0, .menu_folder_change_name);
}
}
};
@Override
public void onContextMenuClosed(Menu menu) {
if (mNotesListView != null) {
(null);
}
(menu);
}
/* (non-Javadoc)
* @see #onContextItemSelected()
* 针对menu中不同的选择进行不同的处理，里面详细注释
*/
@Override
public boolean onContextItemSelected(MenuItem item) {
if (mFocusNoteDataItem == null) {
(TAG, "The long click data item is null");
return false;
}
switch (()) {
case MENU_FOLDER_VIEW:
openFolder(mFocusNoteDataItem);//打开对应文件
break;
case MENU_FOLDER_DELETE:
builder = new (this);//设置确认是否删除的对话框
(getString(.alert_title_delete));
(.ic_dialog_alert);
(getString(.alert_message_delete_folder));
(,
new () {
public void onClick(DialogInterface dialog, int which) {
deleteFolder(());
}
});
(, null);
();//显示对话框
break;
case MENU_FOLDER_CHANGE_NAME:
showCreateOrModifyFolderDialog(false);
break;
default:
break;
}
return true;
}
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
();
if (mState == ListEditState.NOTE_LIST) {
getMenuInflater().inflate(.note_list, menu);
// set sync or sync_cancel
(.menu_sync).setTitle(
() ? .menu_sync_cancel : .menu_sync);
} else if (mState == ListEditState.SUB_FOLDER) {
getMenuInflater().inflate(.sub_folder, menu);
} else if (mState == ListEditState.CALL_RECORD_FOLDER) {
getMenuInflater().inflate(.call_record_folder, menu);
} else {
(TAG, "Wrong state:" + mState);
}
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (()) {
case .menu_new_folder: {
showCreateOrModifyFolderDialog(true);
break;
}
case .menu_export_text: {
exportNoteToText();
break;
}
case .menu_sync: {
if (isSyncMode()) {
if (((), getString(.menu_sync))) {
(this);
} else {
(this);
}
} else {
startPreferenceActivity();
}
break;
}
case .menu_setting: {
startPreferenceActivity();
break;
}
case .menu_new_note: {
createNewNote();
break;
}
case .menu_search:
onSearchRequested();
break;
default:
break;
}
return true;
}
/* (non-Javadoc)
* @see #onSearchRequested()
* 直接调用startSearch函数
*/
@Override
public boolean onSearchRequested() {
startSearch(null, false, null /* appData */, false);
return true;
}
/**
* 函数功能：实现将便签导出到文本功能
*/
private void exportNoteToText() {
final BackupUtils backup = ();
new AsyncTask<Void, Void, Integer>() {
@Override
protected Integer doInBackground(Void... unused) {
return ();
}
@Override
protected void onPostExecute(Integer result) {
if (result == BackupUtils.STATE_SD_CARD_UNMOUONTED) {
builder = new ();
(
.getString(.failed_sdcard_export));
(
.getString(.error_sdcard_unmounted));
(, null);
();
} else if (result == BackupUtils.STATE_SUCCESS) {
builder = new ();
(
.getString(.success_sdcard_export));
((
.format_exported_file_location, backup
.getExportedTextFileName(), ()));
(, null);
();
} else if (result == BackupUtils.STATE_SYSTEM_ERROR) {
builder = new ();
(
.getString(.failed_sdcard_export));
(
.getString(.error_sdcard_export));
(, null);
();
}
}
}.execute();
}
/**
* @return
* 功能：判断是否正在同步
*/
private boolean isSyncMode() {
return (this).trim().length() > 0;
}
/**
* 功能：跳转到PreferenceActivity界面
*/
private void startPreferenceActivity() {
Activity from = getParent() != null ? getParent() : this;
Intent intent = new Intent(from, );
(intent, -1);
}
/**
* @author k
* 函数功能：实现对便签列表项的点击事件（短按）
*/
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 (()) {
if (() == Notes.TYPE_NOTE) {
position = position - ();
(null, position, id,
!(position));
}
return;
}
switch (mState) {
case NOTE_LIST:
if (() == Notes.TYPE_FOLDER
|| () == Notes.TYPE_SYSTEM) {
openFolder(item);
} else if (() == Notes.TYPE_NOTE) {
openNode(item);
} else {
(TAG, "Wrong note type in NOTE_LIST");
}
break;
case SUB_FOLDER:
case CALL_RECORD_FOLDER:
if (() == Notes.TYPE_NOTE) {
openNode(item);
} else {
(TAG, "Wrong note type in SUB_FOLDER");
}
break;
default:
break;
}
}
}
}
/**
* 查询目标文件
*/
private void startQueryDestinationFolders() {
String selection = + "=? AND " + NoteColumns.PARENT_ID + "<>? AND " + + "<>?";
selection = (mState == ListEditState.NOTE_LIST) ? selection:
"(" + selection + ") OR (" + + "=" + Notes.ID_ROOT_FOLDER + ")";
(FOLDER_LIST_QUERY_TOKEN,
null,
Notes.CONTENT_NOTE_URI,
,
selection,
new String[] {
(Notes.TYPE_FOLDER),
(Notes.ID_TRASH_FOLER),
(mCurrentFolderId)
},
NoteColumns.MODIFIED_DATE + " DESC");
}
/* (non-Javadoc)
* @see #onItemLongClick(, , int, long)
* 长按某一项时进行的操作
* 如果长按的是便签，则通过ActionMode菜单实现；如果长按的是文件夹，则通过ContextMenu菜单实现；
* 具体ActionMOde菜单和ContextMenu菜单的详细见精度笔记
*/
public boolean onItemLongClick(AdapterView<?> parent, View view, int position, long id) {
if (view instanceof NotesListItem) {
mFocusNoteDataItem = ((NotesListItem) view).getItemData();
if (() == Notes.TYPE_NOTE && !()) {
if ((mModeCallBack) != null) {
(null, position, id, true);
(HapticFeedbackConstants.LONG_PRESS);
} else {
(TAG, "startActionMode fails");
}
} else if (() == Notes.TYPE_FOLDER) {
(mFolderOnCreateContextMenuListener);
}
}
return false;
}
}
12、
package ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
/*
* 功能：直译为便签表连接器，继承了CursorAdapter，它为cursor和ListView提供了连接的桥梁。
* 所以NotesListAdapter实现的是鼠标和编辑便签链接的桥梁
*/
public class NotesListAdapter extends CursorAdapter {
private static final String TAG = "NotesListAdapter";
private Context mContext;
private HashMap<Integer, Boolean> mSelectedIndex;
private int mNotesCount; //便签数
private boolean mChoiceMode; //选择模式标记
/*
* 桌面widget的属性，包括编号和类型
*/
public static class AppWidgetAttribute {
public int widgetId;
public int widgetType;
};
/*
* 函数功能：初始化便签链接器
* 函数实现：根据传进来的内容设置相关变量
*/
public NotesListAdapter(Context context) {
super(context, null); //父类对象置空
mSelectedIndex = new HashMap<Integer, Boolean>(); //新建选项下标的hash表
mContext = context;
mNotesCount = 0;
}
@Override
/*
* 函数功能：新建一个视图来存储光标所指向的数据
* 函数实现：使用兄弟类NotesListItem新建一个项目选项
*/
public View newView(Context context, Cursor cursor, ViewGroup parent) {
return new NotesListItem(context);
}
/*
* 函数功能：将已经存在的视图和鼠标指向的数据进行捆绑
* 函数实现：如下注释
*/
@Override
public void bindView(View view, Context context, Cursor cursor) {
if (view instanceof NotesListItem) {
//若view是NotesListItem的一个实例
NoteItemData itemData = new NoteItemData(context, cursor);
((NotesListItem) view).bind(context, itemData, mChoiceMode,
isSelectedItem(()));
//则新建一个项目选项并且用bind跟将view和鼠标，内容，便签数据捆绑在一起
}
}
/*
* 函数功能：设置勾选框
* 函数实现：如下注释
*/
public void setCheckedItem(final int position, final boolean checked) {
(position, checked);
//根据定位和是否勾选设置下标
notifyDataSetChanged();
//在修改后刷新activity
}
/*
* 函数功能：判断单选按钮是否勾选
*/
public boolean isInChoiceMode() {
return mChoiceMode;
}
/*
* 函数功能：设置单项选项框
* 函数实现：重置下标并且根据参数mode设置选项
*/
public void setChoiceMode(boolean mode) {
();
mChoiceMode = mode;
}
/*
* 函数功能：选择全部选项
* 函数实现：如下注释
*/
public void selectAll(boolean checked) {
Cursor cursor = getCursor();
//获取光标位置
for (int i = 0; i < getCount(); i++) {
if ((i)) {
if ((cursor) == Notes.TYPE_NOTE) {
setCheckedItem(i, checked);
}
}
}
//遍历所有光标可用的位置在判断为便签类型之后勾选单项框
}
/*
* 函数功能：建立选择项的下标列表
* 函数实现：如下注释
*/
public HashSet<Long> getSelectedItemIds() {
HashSet<Long> itemSet = new HashSet<Long>();
//建立hash表
for (Integer position : ()) {
//遍历所有的关键
if ((position) == true) {
//若光标位置可用
Long id = getItemId(position);
if (id == Notes.ID_ROOT_FOLDER) {
//原文件不需要添加
(TAG, "Wrong item id, should not happen");
} else {
(id);
}
//则将id该下标假如选项集合中
}
}
return itemSet;
}
/*
* 函数功能：建立桌面Widget的选项表
* 函数实现：如下注释
*/
public HashSet<AppWidgetAttribute> getSelectedWidget() {
HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>();
for (Integer position : ()) {
if ((position) == true) {
Cursor c = (Cursor) getItem(position);
//以上4句和getSelectedItemIds一样，不再重复
if (c != null) {
//光标位置可用的话就建立新的Widget属性并编辑下标和类型，最后添加到选项集中
AppWidgetAttribute widget = new AppWidgetAttribute();
NoteItemData item = new NoteItemData(mContext, c);
= ();
= ();
(widget);
/**
* Don't close cursor here, only the adapter could close it
*/
} else {
(TAG, "Invalid cursor");
return null;
}
}
}
return itemSet;
}
/*
* 函数功能：获取选项个数
* 函数实现：如下注释
*/
public int getSelectedCount() {
Collection<Boolean> values = ();
//首先获取选项下标的值
if (null == values) {
return 0;
}
Iterator<Boolean> iter = ();
//初始化叠加器
int count = 0;
while (()) {
if (true == ()) {
//若value值为真计数+1
count++;
}
}
return count;
}
/*
* 函数功能：判断是否全部选中
* 函数实现：如下注释
*/
public boolean isAllSelected() {
int checkedCount = getSelectedCount();
return (checkedCount != 0 && checkedCount == mNotesCount);
//获取选项数看是否等于便签的个数
}
/*
* 函数功能：判断是否为选项表
* 函数实现：通过传递的下标来确定
*/
public boolean isSelectedItem(final int position) {
if (null == (position)) {
return false;
}
return (position);
}
@Override
/*
* 函数功能：在activity内容发生局部变动的时候回调该函数计算便签的数量
* 函数实现：如下注释
*/
protected void onContentChanged() {
();
//执行基类函数
calcNotesCount();
}
@Override
/*
* 函数功能：在activity光标发生局部变动的时候回调该函数计算便签的数量
*/
public void changeCursor(Cursor cursor) {
(cursor);
//执行基类函数
calcNotesCount();
}
/*
* 函数功能：计算便签数量
*
*/
private void calcNotesCount() {
mNotesCount = 0;
for (int i = 0; i < getCount(); i++) {
//获取总数同时遍历
Cursor c = (Cursor) getItem(i);
if (c != null) {
if ((c) == Notes.TYPE_NOTE) {
mNotesCount++;
//若该位置不为空并且文本类型为便签就+1
}
} else {
(TAG, "Invalid cursor");
return;
}
//否则报错
}
}
}
13、
package ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
//创建便签列表项目选项
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); //super()它的主要作用是调整调用父类构造函数的顺序
inflate(context, .note_item, this);//Inflate可用于将一个xml中定义的布局控件找出来,这里的xml是r。layout
//findViewById用于从contentView中查找指定ID的View，转换出来的形式根据需要而定;
mAlert = (ImageView) findViewById(.iv_alert_icon);
mTitle = (TextView) findViewById(.tv_title);
mTime = (TextView) findViewById(.tv_time);
mCallName = (TextView) findViewById(.tv_name);
mCheckBox = (CheckBox) findViewById();
}
///根据data的属性对各个控件的属性的控制，主要是可见性Visibility，内容setText，格式setTextAppearance
public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
if (choiceMode && () == Notes.TYPE_NOTE) {
(); ///设置可见行为可见
(checked); ///格子打钩
} else {
();
}
mItemData = data;
///设置控件属性，一共三种情况，由data的id和父id是否与保存到文件夹的id一致来决定
if (() == Notes.ID_CALL_RECORD_FOLDER) {
();
();
//设置该textview的style
(context, );
//settext为设置内容
((.call_record_folder_name)
+ (.format_folder_files_count, ()));
(.call_record);
} else if (() == Notes.ID_CALL_RECORD_FOLDER) {
();
(());
(context,);
((()));
///关于闹钟的设置
if (()) {
();//图片来源的设置
();
} else {
();
}
} else {
();
(context, );
///设置title格式
if (() == Notes.TYPE_FOLDER) {
(()
+ (.format_folder_files_count,
()));
();
} else {
((()));
if (()) {
();///设置图片来源
();
} else {
();
}
}
}
///设置内容，获取相关时间，从data里编辑的日期中获取
mTime. setText((()));
setBackground(data);
}
//根据data的文件属性来设置背景
private void setBackground(NoteItemData data) {
int id = ();
//，若是note型文件，则4种情况，对于4种不同情况的背景来源
if (() == Notes.TYPE_NOTE) {
//单个数据并且只有一个子文件夹
if (() || ()) {
setBackgroundResource((id));
} else if (()) {//是最后一个数据
setBackgroundResource((id));
} else if (() || ()) {//是一个数据并有多个子文件夹
setBackgroundResource((id));
} else {
setBackgroundResource((id));
}
} else {
//若不是note直接调用文件夹的背景来源
setBackgroundResource(());
}
}
public NoteItemData getItemData() {
return mItemData;
}
}
14、
package ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
/*
*该类功能：NotesPreferenceActivity，在小米便签中主要实现的是对背景颜色和字体大小的数据储存。
* 继承了PreferenceActivity主要功能为对系统信息和配置进行自动保存的Activity
*/
public class NotesPreferenceActivity extends PreferenceActivity {
public static final String PREFERENCE_NAME = "notes_preferences";
//优先名
public static final String PREFERENCE_SYNC_ACCOUNT_NAME = "pref_key_account_name";
//同步账号
public static final String PREFERENCE_LAST_SYNC_TIME = "pref_last_sync_time";
//同步时间
public static final String PREFERENCE_SET_BG_COLOR_KEY = "pref_key_bg_random_appear";
private static final String PREFERENCE_SYNC_ACCOUNT_KEY = "pref_sync_account_key";
//同步密码
private static final String AUTHORITIES_FILTER_KEY = "authorities";
//本地密码
private PreferenceCategory mAccountCategory;
//账户分组
private GTaskReceiver mReceiver;
//同步任务接收器
private Account[] mOriAccounts;
//账户
private boolean mHasAddedAccount;
//账户的hash标记
@Override
/*
*函数功能：创建一个activity，在函数里要完成所有的正常静态设置
*参数：Bundle icicle：存放了 activity 当前的状态
*函数实现：如下注释
*/
protected void onCreate(Bundle icicle) {
//先执行父类的创建函数
(icicle);
/* using the app icon for navigation */
getActionBar().setDisplayHomeAsUpEnabled(true);
//给左上角图标的左边加上一个返回的图标
addPreferencesFromResource();
//添加xml来源并显示 xml
mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);
//根据同步账户关键码来初始化分组
mReceiver = new GTaskReceiver();
IntentFilter filter = new IntentFilter();
(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME);
registerReceiver(mReceiver, filter);
//初始化同步组件
mOriAccounts = null;
View header = (this).inflate(.settings_header, null);
//获取listvivew，ListView的作用:用于列出所有选择
getListView().addHeaderView(header, null, true);
//在listview组件上方添加其他组件
}
@Override
/*
* 函数功能：activity交互功能的实现，用于接受用户的输入
* 函数实现：如下注释
*/
protected void onResume() {
//先执行父类 的交互实现
();
// need to set sync account automatically if user has added a new
// account
if (mHasAddedAccount) {
//若用户新加了账户则自动设置同步账户
Account[] accounts = getGoogleAccounts();
//获取google同步账户
if (mOriAccounts != null && > ) {
//若原账户不为空且当前账户有增加
for (Account accountNew : accounts) {
boolean found = false;
for (Account accountOld : mOriAccounts) {
if ((, )) {
//更新账户
found = true;
break;
}
}
if (!found) {
setSyncAccount();
//若是没有找到旧的账户，那么同步账号中就只添加新账户
break;
}
}
}
}
refreshUI();
//刷新标签界面
}
@Override
/*
* 函数功能：销毁一个activity
* 函数实现：如下注释
*/
protected void onDestroy() {
if (mReceiver != null) {
unregisterReceiver(mReceiver);
//注销接收器
}
();
//执行父类的销毁动作
}
/*
* 函数功能：重新设置账户信息
* 函数实现：如下注释
*/
private void loadAccountPreference() {
();
//销毁所有的分组
Preference accountPref = new Preference(this);
//建立首选项
final String defaultAccount = getSyncAccountName(this);
(getString(.preferences_account_title));
(getString(.preferences_account_summary));
//设置首选项的大标题和小标题
(new OnPreferenceClickListener() {
public boolean onPreferenceClick(Preference preference) {
//建立监听器
if (!()) {
if ((defaultAccount)) {
// the first time to set account
//若是第一次建立账户显示选择账户提示对话框
showSelectAccountAlertDialog();
} else {
// if the account has already been set, we need to promp
// user about the risk
//若是已经建立则显示修改对话框并进行修改操作
showChangeAccountConfirmAlertDialog();
}
} else {
//若在没有同步的情况下，则在toast中显示不能修改
(,
.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
.show();
}
return true;
}
});
//根据新建首选项编辑新的账户分组
(accountPref);
}
/*
*函数功能：设置按键的状态和最后同步的时间
*函数实现：如下注释
*/
private void loadSyncButton() {
Button syncButton = (Button) findViewById(.preference_sync_button);
TextView lastSyncTimeView = (TextView) findViewById(.prefenerece_sync_status_textview);
//获取同步按钮控件和最终同步时间的的窗口
// set button state
//设置按钮的状态
if (()) {
//若是在同步状态下
(getString(.preferences_button_sync_cancel));
(new () {
public void onClick(View v) {
();
}
});
//设置按钮显示的文本为“取消同步”以及监听器
} else {
(getString(.preferences_button_sync_immediately));
(new () {
public void onClick(View v) {
();
}
});
//若是不同步则设置按钮显示的文本为“立即同步”以及对应监听器
}
(!(getSyncAccountName(this)));
//设置按键可用还是不可用
// set last sync time
// 设置最终同步时间
if (()) {
//若是在同步的情况下
(());
();
// 根据当前同步服务器设置时间显示框的文本以及可见性
} else {
//若是非同步情况
long lastSyncTime = getLastSyncTime(this);
if (lastSyncTime != 0) {
(getString(.preferences_last_sync_time,
(getString(.preferences_last_sync_time_format),
lastSyncTime)));
();
//则根据最后同步时间的信息来编辑时间显示框的文本内容和可见性
} else {
//若时间为空直接设置为不可见状态
();
}
}
}
/*
*函数功能：刷新标签界面
*函数实现：调用上文设置账号和设置按键两个函数来实现
*/
private void refreshUI() {
loadAccountPreference();
loadSyncButton();
}
/*
* 函数功能：显示账户选择的对话框并进行账户的设置
* 函数实现：如下注释
*/
private void showSelectAccountAlertDialog() {
dialogBuilder = new (this);
//创建一个新的对话框
View titleView = (this).inflate(.account_dialog_title, null);
TextView titleTextView = (TextView) (.account_dialog_title);
(getString(.preferences_dialog_select_account_title));
TextView subtitleTextView = (TextView) (.account_dialog_subtitle);
(getString(.preferences_dialog_select_account_tips));
//设置标题以及子标题的内容
(titleView);
(null, null);
//设置对话框的自定义标题，建立一个YES的按钮
Account[] accounts = getGoogleAccounts();
String defAccount = getSyncAccountName(this);
//获取同步账户信息
mOriAccounts = accounts;
mHasAddedAccount = false;
if ( > 0) {
//若账户不为空
CharSequence[] items = new CharSequence[];
final CharSequence[] itemMapping = items;
int checkedItem = -1;
int index = 0;
for (Account account : accounts) {
if ((, defAccount)) {
checkedItem = index;
//在账户列表中查询到所需账户
}
items[index++] = ;
}
(items, checkedItem,
//在对话框建立一个单选的复选框
new () {
public void onClick(DialogInterface dialog, int which) {
setSyncAccount(itemMapping[which].toString());
();
//取消对话框
refreshUI();
}
//设置点击后执行的事件，包括检录新同步账户和刷新标签界面
});
//建立对话框网络版的监听器
}
View addAccountView = (this).inflate(.add_account_text, null);
(addAccountView);
//给新加账户对话框设置自定义样式
final AlertDialog dialog = ();
//显示对话框
(new () {
public void onClick(View v) {
mHasAddedAccount = true;
//将新加账户的hash置true
Intent intent = new Intent(".ADD_ACCOUNT_SETTINGS");
//建立网络建立组件
(AUTHORITIES_FILTER_KEY, new String[] {
"gmail-ls"
});
startActivityForResult(intent, -1);
//跳回上一个选项
();
}
});
//建立新加账户对话框的监听器
}
/*
* 函数功能：显示账户选择对话框和相关账户操作
* 函数实现：如下注释
*/
private void showChangeAccountConfirmAlertDialog() {
dialogBuilder = new (this);
//创建一个新的对话框
View titleView = (this).inflate(.account_dialog_title, null);
TextView titleTextView = (TextView) (.account_dialog_title);
(getString(.preferences_dialog_change_account_title,
getSyncAccountName(this)));
TextView subtitleTextView = (TextView) (.account_dialog_subtitle);
(getString(.preferences_dialog_change_account_warn_msg));
//根据同步修改的账户信息设置标题以及子标题的内容
(titleView);
//设置对话框的自定义标题
CharSequence[] menuItemArray = new CharSequence[] {
getString(.preferences_menu_change_account),
getString(.preferences_menu_remove_account),
getString(.preferences_menu_cancel)
};
//定义一些标记字符串
(menuItemArray, new () {
//设置对话框要显示的一个list，用于显示几个命令时,即change，remove，cancel
public void onClick(DialogInterface dialog, int which) {
//按键功能，由which来决定
if (which == 0) {
//进入账户选择对话框
showSelectAccountAlertDialog();
} else if (which == 1) {
//删除账户并且跟新便签界面
removeSyncAccount();
refreshUI();
}
}
});
();
//显示对话框
}
/*
*函数功能：获取谷歌账户
*函数实现：通过账户管理器直接获取
*/
private Account[] getGoogleAccounts() {
AccountManager accountManager = (this);
return ("");
}
/*
* 函数功能：设置同步账户
* 函数实现：如下注释：
*/
private void setSyncAccount(String account) {
if (!getSyncAccountName(this).equals(account)) {
//假如该账号不在同步账号列表中
SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
editor = ();
//编辑共享的首选项
if (account != null) {
(PREFERENCE_SYNC_ACCOUNT_NAME, account);
} else {
(PREFERENCE_SYNC_ACCOUNT_NAME, "");
}
//将该账号加入到首选项中
();
//提交修改的数据
setLastSyncTime(this, 0);
//将最后同步时间清零
// clean up local gtask related info
new Thread(new Runnable() {
public void run() {
ContentValues values = new ContentValues();
(NoteColumns.GTASK_ID, "");
(NoteColumns.SYNC_ID, 0);
getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
}
}).start();
//重置当地同步任务的信息
(,
getString(.preferences_toast_success_set_accout, account),
Toast.LENGTH_SHORT).show();
//将toast的文本信息置为“设置账户成功”并显示出来
}
}
/*
* 函数功能：删除同步账户
* 函数实现：如下注释：
*/
private void removeSyncAccount() {
SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
editor = ();
//设置共享首选项
if ((PREFERENCE_SYNC_ACCOUNT_NAME)) {
(PREFERENCE_SYNC_ACCOUNT_NAME);
//假如当前首选项中有账户就删除
}
if ((PREFERENCE_LAST_SYNC_TIME)) {
(PREFERENCE_LAST_SYNC_TIME);
//删除当前首选项中有账户时间
}
();
//提交更新后的数据
// clean up local gtask related info
new Thread(new Runnable() {
public void run() {
ContentValues values = new ContentValues();
(NoteColumns.GTASK_ID, "");
(NoteColumns.SYNC_ID, 0);
getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
}
}).start();
//重置当地同步任务的信息
}
/*
* 函数功能：获取同步账户名称
* 函数实现：通过共享的首选项里的信息直接获取
*/
public static String getSyncAccountName(Context context) {
SharedPreferences settings = (PREFERENCE_NAME,
Context.MODE_PRIVATE);
return (PREFERENCE_SYNC_ACCOUNT_NAME, "");
}
/*
* 函数功能：设置最终同步的时间
* 函数实现：如下注释
*/
public static void setLastSyncTime(Context context, long time) {
SharedPreferences settings = (PREFERENCE_NAME,
Context.MODE_PRIVATE);
editor = ();
// 从共享首选项中找到相关账户并获取其编辑器
(PREFERENCE_LAST_SYNC_TIME, time);
();
//编辑最终同步时间并提交更新
}
/*
* 函数功能：获取最终同步时间
* 函数实现：通过共享的首选项里的信息直接获取
*/
public static long getLastSyncTime(Context context) {
SharedPreferences settings = (PREFERENCE_NAME,
Context.MODE_PRIVATE);
return (PREFERENCE_LAST_SYNC_TIME, 0);
}
/*
* 函数功能：接受同步信息
* 函数实现：继承BroadcastReceiver
*/
private class GTaskReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
refreshUI();
if ((GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {
//获取随广播而来的Intent中的同步服务的数据
TextView syncStatus = (TextView) findViewById(.prefenerece_sync_status_textview);
(intent
.getStringExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_PROGRESS_MSG));
//通过获取的数据在设置系统的状态
}
}
}
/*
* 函数功能：处理菜单的选项
* 函数实现：如下注释
* 参数:MenuItem菜单选项
*/
public boolean onOptionsItemSelected(MenuItem item) {
switch (()) {
//根据选项的id选择，这里只有一个主页
case :
Intent intent = new Intent(this, );
(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);
return true;
//在主页情况下在创建连接组件intent，发出清空的信号并开始一个相应的activity
default:
return false;
}
}
}