mvpola2e5
/
gitProject
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

210340161孙庆斌

Browse Source
pull/4/head
sunqingbin 2 years ago
parent dce0f14416
commit 423cf64d98
4 changed files with 319 additions and 302 deletions
Show Stats Download Patch File Download Diff File

244
src/main/java/net/micode/notes/ui/NoteEditActivity.java
Unescape View File

@ -74,7 +74,7 @@ import java.util.regex.Pattern;
public class NoteEditActivity extends Activity implements OnClickListener,
NoteSettingChangedListener, OnTextViewChangeListener {
private class HeadViewHolder {
private class HeadViewHolder {//创建一个私有类HeadViewHolder用于对界面进行设置，包括文本内容，图片内容等
public TextView tvModified;
public ImageView ivAlertIcon;
@ -82,10 +82,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
public TextView tvAlertDate;
public ImageView ibSetBgColor;
}
}//该类实现了对当前便签界面进行编辑功能，继承了父类Activity并实现了接口，封装有方法39个
//声明Hashmap类，将按钮和对应的资源解析器中的各个属性关联。
private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<Integer, Integer>();
static {
static {//对HashMap进行初始化，主要是颜色的对应
sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW);
sBgSelectorBtnsMap.put(R.id.iv_bg_red, ResourceParser.RED);
sBgSelectorBtnsMap.put(R.id.iv_bg_blue, ResourceParser.BLUE);
@ -94,6 +94,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
private static final Map<Integer, Integer> sBgSelectorSelectionMap = new HashMap<Integer, Integer>();
//代码块：运用Hashmap,将资源解析器中的对应颜色与已选择的颜色按钮关联起来。
static {
sBgSelectorSelectionMap.put(ResourceParser.YELLOW, R.id.iv_bg_yellow_select);
sBgSelectorSelectionMap.put(ResourceParser.RED, R.id.iv_bg_red_select);
@ -103,7 +104,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
private static final Map<Integer, Integer> sFontSizeBtnsMap = new HashMap<Integer, Integer>();
static {
//将字体的大小与相对应的选择相连接
static {// 提供各种大小字体的选择
sFontSizeBtnsMap.put(R.id.ll_font_large, ResourceParser.TEXT_LARGE);
sFontSizeBtnsMap.put(R.id.ll_font_small, ResourceParser.TEXT_SMALL);
sFontSizeBtnsMap.put(R.id.ll_font_normal, ResourceParser.TEXT_MEDIUM);
@ -111,46 +113,48 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
private static final Map<Integer, Integer> sFontSelectorSelectionMap = new HashMap<Integer, Integer>();
static {
//常量，实现资源解析器中字号ID与字体大小按钮（已选择）对应
static {//选择字体大小的界面
sFontSelectorSelectionMap.put(ResourceParser.TEXT_LARGE, R.id.iv_large_select);
sFontSelectorSelectionMap.put(ResourceParser.TEXT_SMALL, R.id.iv_small_select);
sFontSelectorSelectionMap.put(ResourceParser.TEXT_MEDIUM, R.id.iv_medium_select);
sFontSelectorSelectionMap.put(ResourceParser.TEXT_SUPER, R.id.iv_super_select);
}
private static final String TAG = "NoteEditActivity";
private static final String TAG = "NoteEditActivity";//为本模块进行标签设置“NoteEditActivity"
private HeadViewHolder mNoteHeaderHolder;
private HeadViewHolder mNoteHeaderHolder;//.头部布局
private View mHeadViewPanel;
private View mHeadViewPanel;//操作表头
private View mNoteBgColorSelector;
private View mNoteBgColorSelector;//背景颜色
private View mFontSizeSelector;
private View mFontSizeSelector;//私有化一个界面操作mFontSizeSelector，对标签字体的操作
private EditText mNoteEditor;
private EditText mNoteEditor;//文本操作
private View mNoteEditorPanel;
private View mNoteEditorPanel;//.文本编辑控制板
private WorkingNote mWorkingNote;
private WorkingNote mWorkingNote;//对模板WorkingNote的初始化
private SharedPreferences mSharedPrefs;
private int mFontSizeId;
private SharedPreferences mSharedPrefs;//私有化SharedPreferences的数据存储方式
private int mFontSizeId;//.操作字体大小
private static final String PREFERENCE_FONT_SIZE = "pref_font_size";
private static final String PREFERENCE_FONT_SIZE = "pref_font_size";//定义常量 字体大小设置
private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10;
private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10;//设置标题最大长度为10
public static final String TAG_CHECKED = String.valueOf('\u221A');
public static final String TAG_UNCHECKED = String.valueOf('\u25A1');
public static final String TAG_CHECKED = String.valueOf('\u221A');//定义字符串常量 已标记
public static final String TAG_UNCHECKED = String.valueOf('\u25A1');//定义字符串常量 未标记
private LinearLayout mEditTextList;
private LinearLayout mEditTextList;//线性布局
private String mUserQuery;
private Pattern mPattern;
private String mUserQuery;//用户请求
private Pattern mPattern;//正则表达式模式
@Override
protected void onCreate(Bundle savedInstanceState) {
@Override//重写Activity类的onCreate方法
//@param savedInstanceState 已保存的便签实例状态
protected void onCreate(Bundle savedInstanceState) {//创建该activity，然后对content进行设置。通过对State的相关信息判断是否返回
super.onCreate(savedInstanceState);
this.setContentView(R.layout.note_edit);
@ -166,7 +170,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
* user load this activity, we should restore the former state
*/
@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
protected void onRestoreInstanceState(Bundle savedInstanceState) {//为防止内存不足时程序的终止，在这里有一个保存现场的函数
super.onRestoreInstanceState(savedInstanceState);
if (savedInstanceState != null && savedInstanceState.containsKey(Intent.EXTRA_UID)) {
Intent intent = new Intent(Intent.ACTION_VIEW);
@ -179,13 +183,13 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
private boolean initActivityState(Intent intent) {
private boolean initActivityState(Intent intent) {//初始化Activity的状态
/**
* If the user specified the {@link Intent#ACTION_VIEW} but not provided with id,
* then jump to the NotesListActivity
*/
mWorkingNote = null;
if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) {
if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) {//判断初始化该Activity的Intent所包含的action是ACTION_VIEW还是ACTION_INSERT_OR_EDIT，然后进行不同的操作
long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0);
mUserQuery = "";
@ -214,7 +218,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN
| WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
} else if(TextUtils.equals(Intent.ACTION_INSERT_OR_EDIT, intent.getAction())) {
} else if(TextUtils.equals(Intent.ACTION_INSERT_OR_EDIT, intent.getAction())) {//通过 getAction得到的字符串，来决定做什么
// New note
long folderId = intent.getLongExtra(Notes.INTENT_EXTRA_FOLDER_ID, 0);
int widgetId = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_ID,
@ -263,21 +267,21 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
@Override
protected void onResume() {
protected void onResume() {//进行重新返回的函数
super.onResume();
initNoteScreen();
}
private void initNoteScreen() {
private void initNoteScreen() {//对界面进行初始化的操作
mNoteEditor.setTextAppearance(this, TextAppearanceResources
.getTexAppearanceResource(mFontSizeId));
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {//判断是否为清单列表界面，是则切换到清单列表的处理过程，否则继续执行
switchToListMode(mWorkingNote.getContent());
} else {
mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));
mNoteEditor.setSelection(mNoteEditor.getText().length());
}
for (Integer id : sBgSelectorSelectionMap.keySet()) {
for (Integer id : sBgSelectorSelectionMap.keySet()) {//循环遍历所有sBgSelectorSelectionMap中id对应的资源文件，使其不可见且不占用空间
findViewById(sBgSelectorSelectionMap.get(id)).setVisibility(View.GONE);
}
mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
@ -295,7 +299,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
showAlertHeader();
}
private void showAlertHeader() {
private void showAlertHeader() {//设置闹钟的显示
if (mWorkingNote.hasClockAlert()) {
long time = System.currentTimeMillis();
if (time > mWorkingNote.getAlertDate()) {
@ -313,20 +317,20 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
@Override
protected void onNewIntent(Intent intent) {
protected void onNewIntent(Intent intent) {//新建一个传值对象
super.onNewIntent(intent);
initActivityState(intent);
}
@Override
protected void onSaveInstanceState(Bundle outState) {
protected void onSaveInstanceState(Bundle outState) {//用于保存数据
super.onSaveInstanceState(outState);
/**
* For new note without note id, we should firstly save it to
* generate a id. If the editing note is not worth saving, there
* is no id which is equivalent to create new note
*/
if (!mWorkingNote.existInDatabase()) {
if (!mWorkingNote.existInDatabase()) {//如果该workingnote实例无法在数据库中找到，即为新建的便签，则先将其存储
saveNote();
}
outState.putLong(Intent.EXTRA_UID, mWorkingNote.getNoteId());
@ -334,8 +338,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
if (mNoteBgColorSelector.getVisibility() == View.VISIBLE
public boolean dispatchTouchEvent(MotionEvent ev) {//MotionEvent是对屏幕触控的传递机制
if (mNoteBgColorSelector.getVisibility() == View.VISIBLE//背景颜色选择器是否可见
&& !inRangeOfView(mNoteBgColorSelector, ev)) {
mNoteBgColorSelector.setVisibility(View.GONE);
return true;
@ -349,7 +353,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return super.dispatchTouchEvent(ev);
}
private boolean inRangeOfView(View view, MotionEvent ev) {
private boolean inRangeOfView(View view, MotionEvent ev) {//对屏幕触控的坐标进行操作
int []location = new int[2];
view.getLocationOnScreen(location);
int x = location[0];
@ -363,7 +367,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return true;
}
private void initResources() {
private void initResources() {//对标签各项属性内容的初始化
mHeadViewPanel = findViewById(R.id.note_title);
mNoteHeaderHolder = new HeadViewHolder();
mNoteHeaderHolder.tvModified = (TextView) findViewById(R.id.tv_modified_date);
@ -374,46 +378,46 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mNoteEditor = (EditText) findViewById(R.id.note_edit_view);
mNoteEditorPanel = findViewById(R.id.sv_note_edit);
mNoteBgColorSelector = findViewById(R.id.note_bg_color_selector);
for (int id : sBgSelectorBtnsMap.keySet()) {
for (int id : sBgSelectorBtnsMap.keySet()) {//对所有颜色选择按钮设置监听器
ImageView iv = (ImageView) findViewById(id);
iv.setOnClickListener(this);
}
mFontSizeSelector = findViewById(R.id.font_size_selector);
for (int id : sFontSizeBtnsMap.keySet()) {
for (int id : sFontSizeBtnsMap.keySet()) {//对于每一个字体大小的选择按钮都设置监听器
View view = findViewById(id);
view.setOnClickListener(this);
};
mSharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);
mFontSizeId = mSharedPrefs.getInt(PREFERENCE_FONT_SIZE, ResourceParser.BG_DEFAULT_FONT_SIZE);
mSharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);//初始化共享设置
mFontSizeId = mSharedPrefs.getInt(PREFERENCE_FONT_SIZE, ResourceParser.BG_DEFAULT_FONT_SIZE);//从偏好设置中得到设置字体大小的ID
/**
* HACKME: Fix bug of store the resource id in shared preference.
* The id may larger than the length of resources, in this case,
* return the {@link ResourceParser#BG_DEFAULT_FONT_SIZE}
*/
if(mFontSizeId >= TextAppearanceResources.getResourcesSize()) {
if(mFontSizeId >= TextAppearanceResources.getResourcesSize()) {//如果获取到的字体大小值的长度大于资源文件应有长度，则将其设置为默认长度，缺省值为1.
mFontSizeId = ResourceParser.BG_DEFAULT_FONT_SIZE;
}
mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list);
}
@Override
protected void onPause() {
protected void onPause() {//onPause()在activity退出前想保存用户重要数据的，必须在onPause中处理，调用父类的界面暂停操作，并输出对应信息。
super.onPause();
if(saveNote()) {
if(saveNote()) {//保存便签
Log.d(TAG, "Note data was saved with length:" + mWorkingNote.getContent().length());
}
clearSettingState();
}
private void updateWidget() {
Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_2X) {
private void updateWidget() {//更新窗口与桌面小窗口同步
Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);//新建一个包含改变widget动作的intent实例
if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_2X) {//根据workingnote的widget类型大小，设置intent中映射的类
intent.setClass(this, NoteWidgetProvider_2x.class);
} else if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_4X) {
} else if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_4X) {//如果是4倍大小
intent.setClass(this, NoteWidgetProvider_4x.class);
} else {
Log.e(TAG, "Unspported widget type");
Log.e(TAG, "Unspported widget type");//Log输出error信息，不支持的widget类型
return;
}
@ -427,16 +431,15 @@ public class NoteEditActivity extends Activity implements OnClickListener,
public void onClick(View v) {
int id = v.getId();
if (id == R.id.btn_set_bg_color) {
if (id == R.id.btn_set_bg_color) {//如果点击的是 设置背景颜色，执行下面的函数。
mNoteBgColorSelector.setVisibility(View.VISIBLE);
findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
- View.VISIBLE);
} else if (sBgSelectorBtnsMap.containsKey(id)) {
findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(View.VISIBLE);
} else if (sBgSelectorBtnsMap.containsKey(id)) {//如果点击的是背景颜色设置器中的背景颜色选项按钮，执行下面的函数
findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
View.GONE);
mWorkingNote.setBgColorId(sBgSelectorBtnsMap.get(id));
mNoteBgColorSelector.setVisibility(View.GONE);
} else if (sFontSizeBtnsMap.containsKey(id)) {
} else if (sFontSizeBtnsMap.containsKey(id)) {//如果点击的是文字大小设置器中的文字大小选项按钮
findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.GONE);
mFontSizeId = sFontSizeBtnsMap.get(id);
mSharedPrefs.edit().putInt(PREFERENCE_FONT_SIZE, mFontSizeId).commit();
@ -453,7 +456,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
@Override
public void onBackPressed() {
public void onBackPressed() {//监听按下返回键的操作。
if(clearSettingState()) {
return;
}
@ -462,18 +465,18 @@ public class NoteEditActivity extends Activity implements OnClickListener,
super.onBackPressed();
}
private boolean clearSettingState() {
if (mNoteBgColorSelector.getVisibility() == View.VISIBLE) {
private boolean clearSettingState() {//清除设置状态
if (mNoteBgColorSelector.getVisibility() == View.VISIBLE) {//如果背景色选择器可见，设置为不可见
mNoteBgColorSelector.setVisibility(View.GONE);
return true;
} else if (mFontSizeSelector.getVisibility() == View.VISIBLE) {
} else if (mFontSizeSelector.getVisibility() == View.VISIBLE) {//如果字体选择菜单可见，设置为不可见
mFontSizeSelector.setVisibility(View.GONE);
return true;
}
return false;
}
public void onBackgroundColorChanged() {
public void onBackgroundColorChanged() {//背景颜色改变
findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
View.VISIBLE);
mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());
@ -481,23 +484,23 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
if (isFinishing()) {
public boolean onPrepareOptionsMenu(Menu menu) {//准备菜单内容
if (isFinishing()) {//如果窗口正在关闭，则不做处理
return true;
}
clearSettingState();
menu.clear();
if (mWorkingNote.getFolderId() == Notes.ID_CALL_RECORD_FOLDER) {
clearSettingState();//清除设置状态
menu.clear();//清除菜单项
if (mWorkingNote.getFolderId() == Notes.ID_CALL_RECORD_FOLDER) {//如果便签所在的文件夹为便签的通话记录文件夹，执行下面函数
getMenuInflater().inflate(R.menu.call_note_edit, menu);
} else {
getMenuInflater().inflate(R.menu.note_edit, menu);
}
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {//如果workingNote模式为核对列表模式，则执行下面函数
menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_normal_mode);
} else {
menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_list_mode);
}
if (mWorkingNote.hasClockAlert()) {
if (mWorkingNote.hasClockAlert()) {//如果workingNote对象中有时钟提醒事项，则执行下面函数。
menu.findItem(R.id.menu_alert).setVisible(false);
} else {
menu.findItem(R.id.menu_delete_remind).setVisible(false);
@ -506,8 +509,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
public boolean onOptionsItemSelected(MenuItem item) {//动态改变菜单选项内容
switch (item.getItemId()) {//判断选择项
case R.id.menu_new_note:
createNewNote();
break;
@ -553,7 +556,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return true;
}
private void setReminder() {
private void setReminder() {//建立事件提醒器
DateTimePickerDialog d = new DateTimePickerDialog(this, System.currentTimeMillis());
d.setOnDateTimeSetListener(new OnDateTimeSetListener() {
public void OnDateTimeSet(AlertDialog dialog, long date) {
@ -567,14 +570,14 @@ public class NoteEditActivity extends Activity implements OnClickListener,
* Share note to apps that support {@link Intent#ACTION_SEND} action
* and {@text/plain} type
*/
private void sendTo(Context context, String info) {
private void sendTo(Context context, String info) {//共享便签
Intent intent = new Intent(Intent.ACTION_SEND);
intent.putExtra(Intent.EXTRA_TEXT, info);
intent.setType("text/plain");
context.startActivity(intent);
}
private void createNewNote() {
private void createNewNote() {//创建新的便签
// Firstly, save current editing notes
saveNote();
@ -586,16 +589,16 @@ public class NoteEditActivity extends Activity implements OnClickListener,
startActivity(intent);
}
private void deleteCurrentNote() {
if (mWorkingNote.existInDatabase()) {
private void deleteCurrentNote() {//删除当前便签
if (mWorkingNote.existInDatabase()) {//先判断便签是否在数据库中
HashSet<Long> ids = new HashSet<Long>();
long id = mWorkingNote.getNoteId();
if (id != Notes.ID_ROOT_FOLDER) {
if (id != Notes.ID_ROOT_FOLDER) {//如果不是头文件夹建立一个hash表把便签id存起来
ids.add(id);
} else {
Log.d(TAG, "Wrong note id, should not happen");
}
if (!isSyncMode()) {
if (!isSyncMode()) {//如果不是同步模式，则执行下面函数
if (!DataUtils.batchDeleteNotes(getContentResolver(), ids)) {
Log.e(TAG, "Delete Note error");
}
@ -608,19 +611,19 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mWorkingNote.markDeleted(true);
}
private boolean isSyncMode() {
private boolean isSyncMode() {//判断是否为同步模式
return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
}
public void onClockAlertChanged(long date, boolean set) {
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 (!mWorkingNote.existInDatabase()) {
if (!mWorkingNote.existInDatabase()) {//如果设置提醒的便签未保存，则先保存
saveNote();
}
if (mWorkingNote.getNoteId() > 0) {
if (mWorkingNote.getNoteId() > 0) {//数据库中有该提醒的id,执行下面操作。否则，报错。
Intent intent = new Intent(this, AlarmReceiver.class);
intent.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mWorkingNote.getNoteId()));
PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, intent, 0);
@ -645,24 +648,25 @@ public class NoteEditActivity extends Activity implements OnClickListener,
public void onWidgetChanged() {
updateWidget();
}
//当widget变化时，执行更新widget这个函数
public void onEditTextDelete(int index, String text) {
public void onEditTextDelete(int index, String text) {//当删除编辑文本时，执行这个函数
int childCount = mEditTextList.getChildCount();
if (childCount == 1) {
if (childCount == 1) {//当删除编辑文本时，执行这个函数
return;
}
for (int i = index + 1; i < childCount; i++) {
for (int i = index + 1; i < childCount; i++) {//将index后面的每一个项覆盖前面的项，即将index的项删除，后面补上去
((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text))
.setIndex(i - 1);
}
mEditTextList.removeViewAt(index);
NoteEditText edit = null;
if(index == 0) {
if(index == 0) {//如果index为0，则将edit定位到第一个EditText项
edit = (NoteEditText) mEditTextList.getChildAt(0).findViewById(
R.id.et_edit_text);
} else {
} else {//index不为0，则将edit定位到index-1对应的EditText项
edit = (NoteEditText) mEditTextList.getChildAt(index - 1).findViewById(
R.id.et_edit_text);
}
@ -672,11 +676,11 @@ public class NoteEditActivity extends Activity implements OnClickListener,
edit.setSelection(length);
}
public void onEditTextEnter(int index, String text) {
public void onEditTextEnter(int index, String text) {//当编辑便签中输入enter时执行该函数
/**
* Should not happen, check for debug
*/
if(index > mEditTextList.getChildCount()) {
if(index > mEditTextList.getChildCount()) {//如果越界就报错
Log.e(TAG, "Index out of mEditTextList boundrary, should not happen");
}
@ -685,17 +689,17 @@ public class NoteEditActivity extends Activity implements OnClickListener,
NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
edit.requestFocus();
edit.setSelection(0);
for (int i = index + 1; i < mEditTextList.getChildCount(); i++) {
for (int i = index + 1; i < mEditTextList.getChildCount(); i++) {//遍历子文本框并设置对应对下标
((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text))
.setIndex(i);
}
}
private void switchToListMode(String text) {
private void switchToListMode(String text) {//该函数转到列表模式
mEditTextList.removeAllViews();
String[] items = text.split("\n");
int index = 0;
for (String item : items) {
for (String item : items) {//清空所有视图，初始化下标
if(!TextUtils.isEmpty(item)) {
mEditTextList.addView(getListItem(item, index));
index++;
@ -708,13 +712,13 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mEditTextList.setVisibility(View.VISIBLE);
}
private Spannable getHighlightQueryResult(String fullText, String userQuery) {
private Spannable getHighlightQueryResult(String fullText, String userQuery) {//获取高亮效果的反馈结果
SpannableString spannable = new SpannableString(fullText == null ? "" : fullText);
if (!TextUtils.isEmpty(userQuery)) {
if (!TextUtils.isEmpty(userQuery)) {//将用户的询问进行解析，如果搜索结果不为空，执行下面函数
mPattern = Pattern.compile(userQuery);
Matcher m = mPattern.matcher(fullText);
int start = 0;
while (m.find(start)) {
while (m.find(start)) {//将匹配到的内容设置为高亮。
spannable.setSpan(
new BackgroundColorSpan(this.getResources().getColor(
R.color.user_query_highlight)), m.start(), m.end(),
@ -725,13 +729,13 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return spannable;
}
private View getListItem(String item, int index) {
private View getListItem(String item, int index) {//获取列表项
View view = LayoutInflater.from(this).inflate(R.layout.note_edit_list_item, null);
final NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
edit.setTextAppearance(this, TextAppearanceResources.getTexAppearanceResource(mFontSizeId));
CheckBox cb = ((CheckBox) view.findViewById(R.id.cb_edit_item));
cb.setOnCheckedChangeListener(new OnCheckedChangeListener() {
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {//如果CheckBox已勾选，则执行下面函数，设置显示方式。
if (isChecked) {
edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
} else {
@ -740,11 +744,11 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
});
if (item.startsWith(TAG_CHECKED)) {
if (item.startsWith(TAG_CHECKED)) {//判断是否勾选
cb.setChecked(true);
edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
item = item.substring(TAG_CHECKED.length(), item.length()).trim();
} else if (item.startsWith(TAG_UNCHECKED)) {
} else if (item.startsWith(TAG_UNCHECKED)) {//选择不勾选项
cb.setChecked(false);
edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG);
item = item.substring(TAG_UNCHECKED.length(), item.length()).trim();
@ -756,20 +760,20 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return view;
}
public void onTextChange(int index, boolean hasText) {
if (index >= mEditTextList.getChildCount()) {
public void onTextChange(int index, boolean hasText) {//便签内容发生改变所 触发的事件
if (index >= mEditTextList.getChildCount()) {//越界报错
Log.e(TAG, "Wrong index, should not happen");
return;
}
if(hasText) {
if(hasText) {//如果内容不为空则将其子编辑框可见性置为可见，否则不可见
mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.VISIBLE);
} else {
} else {//选择框不可见
mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.GONE);
}
}
public void onCheckListModeChanged(int oldMode, int newMode) {
if (newMode == TextNote.MODE_CHECK_LIST) {
public void onCheckListModeChanged(int oldMode, int newMode) {//检查模式和列表模式的切换
if (newMode == TextNote.MODE_CHECK_LIST) {// 如果是变为清单模式
switchToListMode(mNoteEditor.getText().toString());
} else {
if (!getWorkingText()) {
@ -782,11 +786,11 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
private boolean getWorkingText() {
private boolean getWorkingText() {//设置勾选选项表并返回是否勾选的标记
boolean hasChecked = false;
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {//判断是否是清单模式
StringBuilder sb = new StringBuilder();
for (int i = 0; i < mEditTextList.getChildCount(); i++) {
for (int i = 0; i < mEditTextList.getChildCount(); i++) {//for循环遍历EditTextList的项
View view = mEditTextList.getChildAt(i);
NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
if (!TextUtils.isEmpty(edit.getText())) {
@ -799,16 +803,16 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
mWorkingNote.setWorkingText(sb.toString());
} else {
} else {//若不是该模式直接用编辑器中的内容设置运行中标签的内容
mWorkingNote.setWorkingText(mNoteEditor.getText().toString());
}
return hasChecked;
}
private boolean saveNote() {
private boolean saveNote() {//保存便签
getWorkingText();
boolean saved = mWorkingNote.saveNote();
if (saved) {
if (saved) {//如果workingNote已经保存，则将结果设置为ok。
/**
* There are two modes from List view to edit view, open one note,
* create/edit a node. Opening node requires to the original
@ -821,17 +825,17 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return saved;
}
private void sendToDesktop() {
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 (!mWorkingNote.existInDatabase()) {
if (!mWorkingNote.existInDatabase()) {//若不存在数据也就是新的标签就先保存
saveNote();
}
if (mWorkingNote.getNoteId() > 0) {
if (mWorkingNote.getNoteId() > 0) {//若便签的id大于0，则执行以下程序
Intent sender = new Intent();
Intent shortcutIntent = new Intent(this, NoteEditActivity.class);
shortcutIntent.setAction(Intent.ACTION_VIEW);
@ -845,7 +849,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sender.setAction("com.android.launcher.action.INSTALL_SHORTCUT");
showToast(R.string.info_note_enter_desktop);
sendBroadcast(sender);
} else {
} else {//如果便签的id错误，则保存提醒用户
/**
* 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
@ -856,18 +860,20 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
private String makeShortcutIconTitle(String content) {
private String makeShortcutIconTitle(String content) {//编辑小图标的标题
content = content.replace(TAG_CHECKED, "");
content = content.replace(TAG_UNCHECKED, "");
return content.length() > SHORTCUT_ICON_TITLE_MAX_LEN ? content.substring(0,
SHORTCUT_ICON_TITLE_MAX_LEN) : content;
SHORTCUT_ICON_TITLE_MAX_LEN) : content;//直接设置为content中的内容并返回，有勾选和未勾选2种
}
private void showToast(int resId) {
private void showToast(int resId) {//显示提示的视图 函数实现：根据下标显示对应的提示
showToast(resId, Toast.LENGTH_SHORT);
}
private void showToast(int resId, int duration) {
//持续显示提示的视图 函数实现：根据下标和持续的时间（duration）编辑提示视图并显示
Toast.makeText(this, resId, duration).show();
}
}

52
src/main/java/net/micode/notes/ui/NoteEditText.java
Unescape View File

@ -37,17 +37,17 @@ import net.micode.notes.R;
import java.util.HashMap;
import java.util.Map;
public class NoteEditText extends EditText {
private static final String TAG = "NoteEditText";
public class NoteEditText extends EditText {//声明了一个公有类NoteEditText,它继承了EditText
private static final String TAG = "NoteEditText";//标志为字符串"NoteEditText"
private int mIndex;
private int mSelectionStartBeforeDelete;
private static final String SCHEME_TEL = "tel:" ;
private static final String SCHEME_TEL = "tel:" ;//声明字符串常量，标志电话、网址、邮件
private static final String SCHEME_HTTP = "http:" ;
private static final String SCHEME_EMAIL = "mailto:" ;
private static final Map<String, Integer> sSchemaActionResMap = new HashMap<String, Integer>();
static {
private static final Map<String, Integer> sSchemaActionResMap = new HashMap<String, Integer>();//设置映射，将文本内容（电话、网址、邮件）做链接处理
static {//这个接口将会被NoteEditActivity实现来删除或添加编辑文本
sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel);
sSchemaActionResMap.put(SCHEME_HTTP, R.string.note_link_web);
sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email);
@ -56,52 +56,52 @@ public class NoteEditText extends EditText {
/**
* Call by the {@link NoteEditActivity} to delete or add edit text
*/
public interface OnTextViewChangeListener {
public interface OnTextViewChangeListener {//该接口用于实现对TextView组件中的文字信息进行修改
/**
* Delete current edit text when {@link KeyEvent#KEYCODE_DEL} happens
* and the text is null
*/
void onEditTextDelete(int index, String text);
void onEditTextDelete(int index, String text);//当触发删除文本KeyEvent时删除文本
/**
* Add edit text after current edit text when {@link KeyEvent#KEYCODE_ENTER}
* happen
*/
void onEditTextEnter(int index, String text);
void onEditTextEnter(int index, String text);//当触发输入文本KeyEvent时增添文本
/**
* Hide or show item option when text change
*/
void onTextChange(int index, boolean hasText);
void onTextChange(int index, boolean hasText);//文字更改时隐藏或显示项目选项
}
private OnTextViewChangeListener mOnTextViewChangeListener;
public NoteEditText(Context context) {
public NoteEditText(Context context) {//这个函数是NoteEditText的构造函数,直接借用了父类的构造函数
super(context, null);
mIndex = 0;
}
public void setIndex(int index) {
mIndex = index;
public void setIndex(int index){//这个函数设置了针对textview的监听器
mIndex = index;
}
public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {//置文本视图变化监听器
mOnTextViewChangeListener = listener;
}
public NoteEditText(Context context, AttributeSet attrs) {
public NoteEditText(Context context, AttributeSet attrs) {//便签初始化
super(context, attrs, android.R.attr.editTextStyle);
}
public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
public NoteEditText(Context context, AttributeSet attrs, int defStyle) {//自动初始化
super(context, attrs, defStyle);
// TODO Auto-generated constructor stub
}
@Override
public boolean onTouchEvent(MotionEvent event) {
switch (event.getAction()) {
public boolean onTouchEvent(MotionEvent event) {//我们打开一个便签后触碰它的文本内容时,该便签就会跳转到响应的编辑状态.这个函数设计了当我们在便签文本编辑视图中触碰文本后系统的响应方式
switch (event.getAction()) {//根据按键的KeyCode来处理
case MotionEvent.ACTION_DOWN:
int x = (int) event.getX();
@ -123,7 +123,7 @@ public class NoteEditText extends EditText {
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
switch (keyCode) {
switch (keyCode) {//根据按键的KeyCode来处理
case KeyEvent.KEYCODE_ENTER:
if (mOnTextViewChangeListener != null) {
return false;
@ -139,8 +139,8 @@ public class NoteEditText extends EditText {
}
@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
switch(keyCode) {
public boolean onKeyUp(int keyCode, KeyEvent event) {//这个函数规定了当用户松开按键瞬间系统的响应
switch(keyCode) {//根据按键的 Unicode 编码值来处理，有删除和进入2种操作
case KeyEvent.KEYCODE_DEL:
if (mOnTextViewChangeListener != null) {
if (0 == mSelectionStartBeforeDelete && mIndex != 0) {
@ -168,7 +168,7 @@ public class NoteEditText extends EditText {
}
@Override
protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {//这个函数规定了编辑文本焦点改变时的系统响应
if (mOnTextViewChangeListener != null) {
if (!focused && TextUtils.isEmpty(getText())) {
mOnTextViewChangeListener.onTextChange(mIndex, false);
@ -180,8 +180,8 @@ public class NoteEditText extends EditText {
}
@Override
protected void onCreateContextMenu(ContextMenu menu) {
if (getText() instanceof Spanned) {
protected void onCreateContextMenu(ContextMenu menu) {//这个重载函数定义了新建文本菜单的过程
if (getText() instanceof Spanned) {//如果有文本存在
int selStart = getSelectionStart();
int selEnd = getSelectionEnd();
@ -189,16 +189,16 @@ public class NoteEditText extends EditText {
int max = Math.max(selStart, selEnd);
final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class);
if (urls.length == 1) {
if (urls.length == 1) {//设置url的信息的范围值
int defaultResId = 0;
for(String schema: sSchemaActionResMap.keySet()) {
for(String schema: sSchemaActionResMap.keySet()) {//获取计划表中所有的key值
if(urls[0].getURL().indexOf(schema) >= 0) {
defaultResId = sSchemaActionResMap.get(schema);
break;
}
}
if (defaultResId == 0) {
if (defaultResId == 0) {//defaultResId == 0则说明url并没有添加任何东西，所以置为连接其他SchemaActionResMap的值
defaultResId = R.string.note_link_other;
}

29
src/main/java/net/micode/notes/ui/NoteItemData.java
Unescape View File

@ -26,8 +26,8 @@ import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.tool.DataUtils;
public class NoteItemData {
static final String [] PROJECTION = new String [] {
public class NoteItemData {//提供便签的项目数据
static final String [] PROJECTION = new String [] {//常量标记和数据
NoteColumns.ID,
NoteColumns.ALERTED_DATE,
NoteColumns.BG_COLOR_ID,
@ -42,7 +42,7 @@ public class NoteItemData {
NoteColumns.WIDGET_TYPE,
};
private static final int ID_COLUMN = 0;
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;
@ -76,51 +76,52 @@ public class NoteItemData {
private boolean mIsOneNoteFollowingFolder;
private boolean mIsMultiNotesFollowingFolder;
public NoteItemData(Context context, Cursor cursor) {
mId = cursor.getLong(ID_COLUMN);
public NoteItemData(Context context, Cursor cursor) {//初始化NoteItemData利用光标和context获取的内容
mId = cursor.getLong(ID_COLUMN);//调用getxxxx（）的函数，是指 数据库游标通过把参数索引获得数据
mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN);
mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN);
mCreatedDate = cursor.getLong(CREATED_DATE_COLUMN);
mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0) ? true : false;
mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0) ? true : false;//判断行列
mModifiedDate = cursor.getLong(MODIFIED_DATE_COLUMN);
mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN);
mParentId = cursor.getLong(PARENT_ID_COLUMN);
mSnippet = cursor.getString(SNIPPET_COLUMN);
mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(
mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(//把每项前的方框符号和✔符号去掉
NoteEditActivity.TAG_UNCHECKED, "");
mType = cursor.getInt(TYPE_COLUMN);
mWidgetId = cursor.getInt(WIDGET_ID_COLUMN);
mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN);
mPhoneNumber = "";
if (mParentId == Notes.ID_CALL_RECORD_FOLDER) {
if (mParentId == Notes.ID_CALL_RECORD_FOLDER) {//初始化电话号码的信息
mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId);
if (!TextUtils.isEmpty(mPhoneNumber)) {
mName = Contact.getContact(context, mPhoneNumber);
if (mName == null) {
mName = mPhoneNumber;
}
}
}
if (mName == null) {
if (mName == null) {//如果没有对name复制成功，则把name设置为空值
mName = "";
}
checkPostion(cursor);
}
private void checkPostion(Cursor cursor) {
private void checkPostion(Cursor cursor) {//通过光标所处位置设置标记
mIsLastItem = cursor.isLast() ? true : false;
mIsFirstItem = cursor.isFirst() ? true : false;
mIsOnlyOneItem = (cursor.getCount() == 1);
mIsMultiNotesFollowingFolder = false;
mIsOneNoteFollowingFolder = false;
if (mType == Notes.TYPE_NOTE && !mIsFirstItem) {
if (mType == Notes.TYPE_NOTE && !mIsFirstItem) {//如果是note格式并且不是第一个元素，则获取光标位置并根据上一行信息更改标记
int position = cursor.getPosition();
if (cursor.moveToPrevious()) {
if (cursor.moveToPrevious()) {//获取光标位置后看上一行
if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER
|| cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) {
|| cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) {//若光标满足SYSTEM或FOLDER格式
if (cursor.getCount() > (position + 1)) {
mIsMultiNotesFollowingFolder = true;
} else {
@ -136,7 +137,7 @@ public class NoteItemData {
public boolean isOneFollowingFolder() {
return mIsOneNoteFollowingFolder;
}
}//以下都是获取标记的函数
public boolean isMultiFollowingFolder() {
return mIsMultiNotesFollowingFolder;

296
src/main/java/net/micode/notes/ui/NotesListActivity.java
Unescape View File

@ -79,65 +79,66 @@ import java.io.InputStreamReader;
import java.util.HashSet;
public class NotesListActivity extends Activity implements OnClickListener, OnItemLongClickListener {
private static final int FOLDER_NOTE_LIST_QUERY_TOKEN = 0;
//这个类继承于Activity类，实现了两个接口，分别是点击监听器，和长按监听器，即在这个类的界面实现对这两种操作的响应，这是整个project的主类
private static final int FOLDER_NOTE_LIST_QUERY_TOKEN = 0;//声明并赋值一些不可更改的私有属性
private static final int FOLDER_LIST_QUERY_TOKEN = 1;
private static final int FOLDER_LIST_QUERY_TOKEN = 1;//查询记号
private static final int MENU_FOLDER_DELETE = 0;
private static final int MENU_FOLDER_DELETE = 0;//删除菜单文件
private static final int MENU_FOLDER_VIEW = 1;
private static final int MENU_FOLDER_VIEW = 1;// 阅读菜单文件
private static final int MENU_FOLDER_CHANGE_NAME = 2;
private static final int MENU_FOLDER_CHANGE_NAME = 2;//更改菜单文件名称
private static final String PREFERENCE_ADD_INTRODUCTION = "net.micode.notes.introduction";
private static final String PREFERENCE_ADD_INTRODUCTION = "net.micode.notes.introduction";//用于第一次打开小米便签的判断
private enum ListEditState {
private enum ListEditState {//列表编辑三种状态
NOTE_LIST, SUB_FOLDER, CALL_RECORD_FOLDER
};
private ListEditState mState;
private ListEditState mState;// 声明一些私有属性
private BackgroundQueryHandler mBackgroundQueryHandler;
private BackgroundQueryHandler mBackgroundQueryHandler;//后台疑问处理功能
private NotesListAdapter mNotesListAdapter;
private NotesListAdapter mNotesListAdapter;//便签列表配适器
private ListView mNotesListView;
private ListView mNotesListView;//主界面的视图
private Button mAddNewNote;
private Button mAddNewNote;//最下方添加便签的按钮
private boolean mDispatch;
private boolean mDispatch;//是否调度的判断变量
private int mOriginY;
private int mOriginY;//首次触摸时屏幕上的垂直距离（y值）
private int mDispatchY;
private int mDispatchY;//重新调度时的触摸的在屏幕上的垂直距离
private TextView mTitleBar;
private TextView mTitleBar;//子文件夹下的标头
private long mCurrentFolderId;
private long mCurrentFolderId;//当前文件夹的ID
private ContentResolver mContentResolver;
private ContentResolver mContentResolver;//提供内容分析
private ModeCallback mModeCallBack;
private ModeCallback mModeCallBack;//返回调用方法
private static final String TAG = "NotesListActivity";
private static final String TAG = "NotesListActivity";//名称（可用于日志文件调试）
public static final int NOTES_LISTVIEW_SCROLL_RATE = 30;
public static final int NOTES_LISTVIEW_SCROLL_RATE = 30;//列表滚轮速度
private NoteItemData mFocusNoteDataItem;
private NoteItemData mFocusNoteDataItem;//所指的便签数据内容
private static final String NORMAL_SELECTION = NoteColumns.PARENT_ID + "=?";
private static final String NORMAL_SELECTION = NoteColumns.PARENT_ID + "=?";//定义私有字符串变量
private static final String ROOT_FOLDER_SELECTION = "(" + NoteColumns.TYPE + "<>"
private static final String ROOT_FOLDER_SELECTION = "(" + NoteColumns.TYPE + "<>"//用于表明处于父文件夹下（主列表）
+ Notes.TYPE_SYSTEM + " AND " + NoteColumns.PARENT_ID + "=?)" + " OR ("
+ NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER + " AND "
+ NoteColumns.NOTES_COUNT + ">0)";
private final static int REQUEST_CODE_OPEN_NODE = 102;
private final static int REQUEST_CODE_NEW_NODE = 103;
private final static int REQUEST_CODE_OPEN_NODE = 102;//请求代码开放节点
private final static int REQUEST_CODE_NEW_NODE = 103;//请求代码新节点
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
protected void onCreate(Bundle savedInstanceState) {//创建类
super.onCreate(savedInstanceState);//super调用父类的protected函数,创建窗口时使用
setContentView(R.layout.note_list);
initResources();
@ -148,38 +149,38 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (resultCode == RESULT_OK
protected void onActivityResult(int requestCode, int resultCode, Intent data) {//对子模块的一些数据进行分析
if (resultCode == RESULT_OK//结果值与要求值正确
&& (requestCode == REQUEST_CODE_OPEN_NODE || requestCode == REQUEST_CODE_NEW_NODE)) {
mNotesListAdapter.changeCursor(null);
} else {
} else {//如果条件不满足，则将数据返回给父类，即调用父类的onActivityResult()。
super.onActivityResult(requestCode, resultCode, data);
}
}
private void setAppInfoFromRawRes() {
private void setAppInfoFromRawRes() {//从原始数据里生成应用的基本信息。
SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
if (!sp.getBoolean(PREFERENCE_ADD_INTRODUCTION, false)) {
if (!sp.getBoolean(PREFERENCE_ADD_INTRODUCTION, false)) {//判断偏好，增加说明
StringBuilder sb = new StringBuilder();
InputStream in = null;
try {
try {//从原始配置文件当中获取基本信息
in = getResources().openRawResource(R.raw.introduction);
if (in != null) {
if (in != null) {//如果加载到输入流成功，填充到缓冲区里
InputStreamReader isr = new InputStreamReader(in);
BufferedReader br = new BufferedReader(isr);
char [] buf = new char[1024];
int len = 0;
while ((len = br.read(buf)) > 0) {
while ((len = br.read(buf)) > 0) {//不断在buf中读取数据放入sb里
sb.append(buf, 0, len);
}
} else {
Log.e(TAG, "Read introduction file error");
Log.e(TAG, "Read introduction file error");//报错，读取文件错误
return;
}
} catch (IOException e) {
} catch (IOException e) {//获取IO中断异常
e.printStackTrace();
return;
} finally {
} finally {// finally是必然会执行的部分
if(in != null) {
try {
in.close();
@ -194,7 +195,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
AppWidgetManager.INVALID_APPWIDGET_ID, Notes.TYPE_WIDGET_INVALIDE,
ResourceParser.RED);
note.setWorkingText(sb.toString());
if (note.saveNote()) {
if (note.saveNote()) {//判断便签是否保存成功。
sp.edit().putBoolean(PREFERENCE_ADD_INTRODUCTION, true).commit();
} else {
Log.e(TAG, "Save introduction note error");
@ -204,12 +205,12 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
@Override
protected void onStart() {
protected void onStart() {//调用父类的onCreate活动，和同步便签列表
super.onStart();
startAsyncNotesListQuery();
}
private void initResources() {
private void initResources() {//初始化资源
mContentResolver = this.getContentResolver();
mBackgroundQueryHandler = new BackgroundQueryHandler(this.getContentResolver());
mCurrentFolderId = Notes.ID_ROOT_FOLDER;
@ -232,18 +233,19 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
private class ModeCallback implements ListView.MultiChoiceModeListener, OnMenuItemClickListener {
//实现了ActionMode接口，该接口继承了MultiChoiceListener，OnMenuItemClickListener两个类，用户界面所看到的就是长按后进入多选模式以及之后的多种操作
private DropdownMenu mDropDownMenu;
private ActionMode mActionMode;
private MenuItem mMoveMenu;
public boolean onCreateActionMode(ActionMode mode, Menu menu) {
public boolean onCreateActionMode(ActionMode mode, Menu menu) {//创建动作方式
getMenuInflater().inflate(R.menu.note_list_options, menu);
menu.findItem(R.id.delete).setOnMenuItemClickListener(this);
mMoveMenu = menu.findItem(R.id.move);
if (mFocusNoteDataItem.getParentId() == Notes.ID_CALL_RECORD_FOLDER
|| DataUtils.getUserFolderCount(mContentResolver) == 0) {
|| DataUtils.getUserFolderCount(mContentResolver) == 0) {//如果父类id在文件夹中保存或者用户文件数量为零，设置移动菜单为不可见，否者设为可见
mMoveMenu.setVisible(false);
} else {
} else {//设置菜单项目为可见
mMoveMenu.setVisible(true);
mMoveMenu.setOnMenuItemClickListener(this);
}
@ -259,7 +261,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
(Button) customView.findViewById(R.id.selection_menu),
R.menu.note_list_dropdown);
mDropDownMenu.setOnDropdownMenuItemClickListener(new PopupMenu.OnMenuItemClickListener(){
public boolean onMenuItemClick(MenuItem item) {
public boolean onMenuItemClick(MenuItem item) {//点击菜单时，设置为全选并更新菜单
mNotesListAdapter.selectAll(!mNotesListAdapter.isAllSelected());
updateMenu();
return true;
@ -269,13 +271,14 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
return true;
}
private void updateMenu() {
private void updateMenu() {//更新下拉的菜单
//函数实现：如果全选了，把全选按键的名称设置为取消全选；反之亦然
int selectedCount = mNotesListAdapter.getSelectedCount();
// Update dropdown menu
String format = getResources().getString(R.string.menu_select_title, selectedCount);
mDropDownMenu.setTitle(format);
MenuItem item = mDropDownMenu.findItem(R.id.action_select_all);
if (item != null) {
if (item != null) {//当全选成功，则将“全选”菜单项改为“取消全选”菜单，否则仍保持“全选”菜单项。
if (mNotesListAdapter.isAllSelected()) {
item.setChecked(true);
item.setTitle(R.string.menu_deselect_all);
@ -286,40 +289,41 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
public boolean onPrepareActionMode(ActionMode mode, Menu menu) {//准备动作模式
// TODO Auto-generated method stub
return false;
}
public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
public boolean onActionItemClicked(ActionMode mode, MenuItem item) {//菜单动作触发标记
// TODO Auto-generated method stub
return false;
}
public void onDestroyActionMode(ActionMode mode) {
public void onDestroyActionMode(ActionMode mode) {//销毁动作模式，设置便签可见
mNotesListAdapter.setChoiceMode(false);
mNotesListView.setLongClickable(true);
mAddNewNote.setVisibility(View.VISIBLE);
}
public void finishActionMode() {
//结束动作模式
mActionMode.finish();
}
public void onItemCheckedStateChanged(ActionMode mode, int position, long id,
boolean checked) {
boolean checked) {//勾选的状态改变时，更改勾选状态，更新菜单
mNotesListAdapter.setCheckedItem(position, checked);
updateMenu();
}
public boolean onMenuItemClick(MenuItem item) {
if (mNotesListAdapter.getSelectedCount() == 0) {
public boolean onMenuItemClick(MenuItem item) {//判断菜单是否被点击
if (mNotesListAdapter.getSelectedCount() == 0) {//当勾选数为零时（即未点击），创建文本并显示
Toast.makeText(NotesListActivity.this, getString(R.string.menu_select_none),
Toast.LENGTH_SHORT).show();
return true;
}
switch (item.getItemId()) {
switch (item.getItemId()) {//根据id号判断是删除还是移动
case R.id.delete:
AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
builder.setTitle(getString(R.string.alert_title_delete));
@ -346,10 +350,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
private class NewNoteOnTouchListener implements OnTouchListener {
private class NewNoteOnTouchListener implements OnTouchListener {//触摸便签监听器
public boolean onTouch(View v, MotionEvent event) {
switch (event.getAction()) {
public boolean onTouch(View v, MotionEvent event) {//新建便签的触摸事件的处理
switch (event.getAction()) {//获取不同动作对应不同操作
case MotionEvent.ACTION_DOWN: {
Display display = getWindowManager().getDefaultDisplay();
int screenHeight = display.getHeight();
@ -359,7 +363,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
/**
* Minus TitleBar's height
*/
if (mState == ListEditState.SUB_FOLDER) {
if (mState == ListEditState.SUB_FOLDER) {//如果再其他文件夹下，则需要减去子文件夹的title的高度
eventY -= mTitleBar.getHeight();
start -= mTitleBar.getHeight();
}
@ -372,11 +376,11 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
* Notice that, if the background of the button changes, the formula should
* also change. This is very bad, just for the UI designer's strong requirement.
*/
if (event.getY() < (event.getX() * (-0.12) + 94)) {
if (event.getY() < (event.getX() * (-0.12) + 94)) {//如果当前点击的位置不在“写便签”区域内
View view = mNotesListView.getChildAt(mNotesListView.getChildCount() - 1
- mNotesListView.getFooterViewsCount());
if (view != null && view.getBottom() > start
&& (view.getTop() < (start + 94))) {
&& (view.getTop() < (start + 94))) {//如果不在新建便签的按钮上，重新调度响应按键
mOriginY = (int) event.getY();
mDispatchY = eventY;
event.setLocation(event.getX(), mDispatchY);
@ -386,7 +390,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
break;
}
case MotionEvent.ACTION_MOVE: {
case MotionEvent.ACTION_MOVE: {//如果是移动操作，调度动作顺序
if (mDispatch) {
mDispatchY += (int) event.getY() - mOriginY;
event.setLocation(event.getX(), mDispatchY);
@ -396,7 +400,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
default: {
if (mDispatch) {
event.setLocation(event.getX(), mDispatchY);
event.setLocation(event.getX(), mDispatchY);//重新赋值
mDispatch = false;
return mNotesListView.dispatchTouchEvent(event);
}
@ -408,7 +412,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
};
private void startAsyncNotesListQuery() {
private void startAsyncNotesListQuery() {//同步便签列表请求
String selection = (mCurrentFolderId == Notes.ID_ROOT_FOLDER) ? ROOT_FOLDER_SELECTION
: NORMAL_SELECTION;
mBackgroundQueryHandler.startQuery(FOLDER_NOTE_LIST_QUERY_TOKEN, null,
@ -417,18 +421,19 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}, NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC");
}
private final class BackgroundQueryHandler extends AsyncQueryHandler {
private final class BackgroundQueryHandler extends AsyncQueryHandler {//背景请求处理器
public BackgroundQueryHandler(ContentResolver contentResolver) {
//调用父类的方法
super(contentResolver);
}
@Override
protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
protected void onQueryComplete(int token, Object cookie, Cursor cursor) {//查询完成后对光标的处理
switch (token) {
case FOLDER_NOTE_LIST_QUERY_TOKEN:
case FOLDER_NOTE_LIST_QUERY_TOKEN://如果是便签查询被采用，更改光标位置
mNotesListAdapter.changeCursor(cursor);
break;
case FOLDER_LIST_QUERY_TOKEN:
case FOLDER_LIST_QUERY_TOKEN://如果是采用列表查询，显示菜单列表
if (cursor != null && cursor.getCount() > 0) {
showFolderListMenu(cursor);
} else {
@ -441,13 +446,13 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
private void showFolderListMenu(Cursor cursor) {
private void showFolderListMenu(Cursor cursor) {//执行批量删除的操作
AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
builder.setTitle(R.string.menu_title_select_folder);
final FoldersListAdapter adapter = new FoldersListAdapter(this, cursor);
final FoldersListAdapter adapter = new FoldersListAdapter(this, cursor);//文件夹列表配适器
builder.setAdapter(adapter, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
public void onClick(DialogInterface dialog, int which) {//为对话框设置监听事件
DataUtils.batchMoveToFolder(mContentResolver,
mNotesListAdapter.getSelectedItemIds(), adapter.getItemId(which));
Toast.makeText(
@ -462,18 +467,18 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
builder.show();
}
private void createNewNote() {
Intent intent = new Intent(this, NoteEditActivity.class);
private void createNewNote() {//创建新便签
Intent intent = new Intent(this, NoteEditActivity.class);//新建一个意图，与NoteEditActivity相关联
intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mCurrentFolderId);
this.startActivityForResult(intent, REQUEST_CODE_NEW_NODE);
intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mCurrentFolderId);//设置键对值
this.startActivityForResult(intent, REQUEST_CODE_NEW_NODE);//这个活动发出请求，等待下一个活动返回数据
}
private void batchDelete() {
private void batchDelete() {//批量删除便签
new AsyncTask<Void, Void, HashSet<AppWidgetAttribute>>() {
protected HashSet<AppWidgetAttribute> doInBackground(Void... unused) {
HashSet<AppWidgetAttribute> widgets = mNotesListAdapter.getSelectedWidget();
if (!isSyncMode()) {
if (!isSyncMode()) {//如果为同步模式则删除笔记，若删除不成功打印错误信息
// if not synced, delete notes directly
if (DataUtils.batchDeleteNotes(mContentResolver, mNotesListAdapter
.getSelectedItemIds())) {
@ -492,7 +497,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
@Override
protected void onPostExecute(HashSet<AppWidgetAttribute> widgets) {
protected void onPostExecute(HashSet<AppWidgetAttribute> widgets) {//这是一个循环体结构，如果id不等的话，会进行更新id的操作。
if (widgets != null) {
for (AppWidgetAttribute widget : widgets) {
if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID
@ -506,7 +511,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}.execute();
}
private void deleteFolder(long folderId) {
private void deleteFolder(long folderId) {//删除文件夹
if (folderId == Notes.ID_ROOT_FOLDER) {
Log.e(TAG, "Wrong folder id, should not happen " + folderId);
return;
@ -516,14 +521,14 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
ids.add(folderId);
HashSet<AppWidgetAttribute> widgets = DataUtils.getFolderNoteWidget(mContentResolver,
folderId);
if (!isSyncMode()) {
if (!isSyncMode()) {//如果不同步，直接删除，否则放入垃圾文件夹中
// if not synced, delete folder directly
DataUtils.batchDeleteNotes(mContentResolver, ids);
} else {
// in sync mode, we'll move the deleted folder into the trash folder
DataUtils.batchMoveToFolder(mContentResolver, ids, Notes.ID_TRASH_FOLER);
}
if (widgets != null) {
if (widgets != null) {//如果存在对应桌面挂件，那么判断挂件信息，如果挂件id有效且挂件类型有效，则更新挂件信息
for (AppWidgetAttribute widget : widgets) {
if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID
&& widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) {
@ -533,23 +538,23 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
private void openNode(NoteItemData data) {
Intent intent = new Intent(this, NoteEditActivity.class);
private void openNode(NoteItemData data) {//打开便签
Intent intent = new Intent(this, NoteEditActivity.class);//打开便签，创建新的活动，并且等待返回值
intent.setAction(Intent.ACTION_VIEW);
intent.putExtra(Intent.EXTRA_UID, data.getId());
this.startActivityForResult(intent, REQUEST_CODE_OPEN_NODE);
}
private void openFolder(NoteItemData data) {
private void openFolder(NoteItemData data) {//打开文件夹
mCurrentFolderId = data.getId();
startAsyncNotesListQuery();
if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {//如果当前id是保存在文件夹的id，将列表编辑状态置为call文件夹，否则设置为镜像文件夹
mState = ListEditState.CALL_RECORD_FOLDER;
mAddNewNote.setVisibility(View.GONE);
} else {
mState = ListEditState.SUB_FOLDER;
}
if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {//如果当前id是保存在文件夹的id，设置标题内容为文件夹名字，否则设置为文本的前部片段内容
mTitleBar.setText(R.string.call_record_folder_name);
} else {
mTitleBar.setText(data.getSnippet());
@ -557,8 +562,8 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
mTitleBar.setVisibility(View.VISIBLE);
}
public void onClick(View v) {
switch (v.getId()) {
public void onClick(View v) {//响应一个点击操作，创建一个新的便签
switch (v.getId()) {//得到我们所点击组件的ID号并进行判断
case R.id.btn_new_note:
createNewNote();
break;
@ -567,24 +572,24 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
private void showSoftInput() {
private void showSoftInput() {//.显示软键盘
InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
if (inputMethodManager != null) {
if (inputMethodManager != null) {//若输入为空，进行对应操作，使软键盘显示，第二个参数hideFlags（用来设置是否隐藏）等于0
inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
}
}
private void hideSoftInput(View view) {
private void hideSoftInput(View view) {//关闭键盘
InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
private void showCreateOrModifyFolderDialog(final boolean create) {
final AlertDialog.Builder builder = new AlertDialog.Builder(this);
View view = LayoutInflater.from(this).inflate(R.layout.dialog_edit_text, null);
final EditText etName = (EditText) view.findViewById(R.id.et_foler_name);
private void showCreateOrModifyFolderDialog(final boolean create) {//创建或修改文件夹对话框
final AlertDialog.Builder builder = new AlertDialog.Builder(this);//初始化对话框
View view = LayoutInflater.from(this).inflate(R.layout.dialog_edit_text, null);//加载对话框的布局文件
final EditText etName = (EditText) view.findViewById(R.id.et_foler_name);//获得et_foler_name这个组件并将其转化为EditText类
showSoftInput();
if (!create) {
if (!create) {//如果create==false将对话框标题设置为 修改文件夹名称，否则设置为新建文件夹
if (mFocusNoteDataItem != null) {
etName.setText(mFocusNoteDataItem.getSnippet());
builder.setTitle(getString(R.string.menu_folder_change_name));
@ -600,23 +605,24 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
builder.setPositiveButton(android.R.string.ok, null);
builder.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
//点击触发软键盘隐藏
hideSoftInput(etName);
}
});
final Dialog dialog = builder.setView(view).show();
final Button positive = (Button)dialog.findViewById(android.R.id.button1);
positive.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
final Dialog dialog = builder.setView(view).show();//将上述对话框实例化并显示在屏幕上
final Button positive = (Button)dialog.findViewById(android.R.id.button1);//加载确定按钮布局文件
positive.setOnClickListener(new OnClickListener() {//设置点击监听器
public void onClick(View v) {//响应一个点击操作
hideSoftInput(etName);
String name = etName.getText().toString();
if (DataUtils.checkVisibleFolderName(mContentResolver, name)) {
if (DataUtils.checkVisibleFolderName(mContentResolver, name)) {//如果是可视文件，创建并显示对话框
Toast.makeText(NotesListActivity.this, getString(R.string.folder_exist, name),
Toast.LENGTH_LONG).show();
etName.setSelection(0, etName.length());
return;
}
if (!create) {
if (!create) {//当文件名字存在时，判断是否为创建操作，若不是，则更新values信息，若是，则插入values信息
if (!TextUtils.isEmpty(name)) {
ContentValues values = new ContentValues();
values.put(NoteColumns.SNIPPET, name);
@ -637,27 +643,27 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
});
if (TextUtils.isEmpty(etName.getText())) {
if (TextUtils.isEmpty(etName.getText())) {//判断文件夹的内容是否为空
positive.setEnabled(false);
}
/**
* When the name edit text is null, disable the positive button
*/
etName.addTextChangedListener(new TextWatcher() {
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
public void beforeTextChanged(CharSequence s, int start, int count, int after) {//判断是否在更改文本之前
// TODO Auto-generated method stub
}
public void onTextChanged(CharSequence s, int start, int before, int count) {
if (TextUtils.isEmpty(etName.getText())) {
public void onTextChanged(CharSequence s, int start, int before, int count) {//当前文本改变触发，文本为空按键不可用，不为空则可用
if(TextUtils.isEmpty(etName.getText())){//如果文件夹名称为空，那么便不可用
positive.setEnabled(false);
} else {
positive.setEnabled(true);
}
}
public void afterTextChanged(Editable s) {
public void afterTextChanged(Editable s) {//判断是否在文本更改之后
// TODO Auto-generated method stub
}
@ -665,8 +671,8 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
@Override
public void onBackPressed() {
switch (mState) {
public void onBackPressed() {//按返回键时根据情况更改类中的数据
switch (mState) {//判断目前所处的状态
case SUB_FOLDER:
mCurrentFolderId = Notes.ID_ROOT_FOLDER;
mState = ListEditState.NOTE_LIST;
@ -688,9 +694,9 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
private void updateWidget(int appWidgetId, int appWidgetType) {
private void updateWidget(int appWidgetId, int appWidgetType) {//更新不同widget的插件
Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
if (appWidgetType == Notes.TYPE_WIDGET_2X) {
if (appWidgetType == Notes.TYPE_WIDGET_2X) {//判断不同类型widget的操作并建立不同的类型
intent.setClass(this, NoteWidgetProvider_2x.class);
} else if (appWidgetType == Notes.TYPE_WIDGET_4X) {
intent.setClass(this, NoteWidgetProvider_4x.class);
@ -699,7 +705,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
return;
}
intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] {
intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] {//putExtra中两个参数为键对值，第一个参数为键名
appWidgetId
});
@ -707,9 +713,9 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
setResult(RESULT_OK, intent);
}
private final OnCreateContextMenuListener mFolderOnCreateContextMenuListener = new OnCreateContextMenuListener() {
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
if (mFocusNoteDataItem != null) {
private final OnCreateContextMenuListener mFolderOnCreateContextMenuListener = new OnCreateContextMenuListener() {//对文件夹进行操作的菜单
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {//创建目录的视图
if (mFocusNoteDataItem != null) {// 创建文件夹的菜单，下面包含四个选项
menu.setHeaderTitle(mFocusNoteDataItem.getSnippet());
menu.add(0, MENU_FOLDER_VIEW, 0, R.string.menu_folder_view);
menu.add(0, MENU_FOLDER_DELETE, 0, R.string.menu_folder_delete);
@ -719,20 +725,20 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
};
@Override
public void onContextMenuClosed(Menu menu) {
public void onContextMenuClosed(Menu menu) {//内容菜单关闭
if (mNotesListView != null) {
mNotesListView.setOnCreateContextMenuListener(null);
mNotesListView.setOnCreateContextMenuListener(null);//不设置监听事件
}
super.onContextMenuClosed(menu);
}
@Override
public boolean onContextItemSelected(MenuItem item) {
if (mFocusNoteDataItem == null) {
public boolean onContextItemSelected(MenuItem item) {//对菜单项进行选择对应的相应
if (mFocusNoteDataItem == null) {//若笔记数据项为空,则返回错误日志信息
Log.e(TAG, "The long click data item is null");
return false;
}
switch (item.getItemId()) {
switch (item.getItemId()) {//根据项目id判断要执行的功能，分别是打开文件、删除文件以及更改文件名
case MENU_FOLDER_VIEW:
openFolder(mFocusNoteDataItem);
break;
@ -761,9 +767,9 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
public boolean onPrepareOptionsMenu(Menu menu) {//创建菜单这个方法在每一次调用菜单的时候都会执行
menu.clear();
if (mState == ListEditState.NOTE_LIST) {
if (mState == ListEditState.NOTE_LIST) {//如果是在便签列表的状态下，加载对应的菜单资源，下面同理
getMenuInflater().inflate(R.menu.note_list, menu);
// set sync or sync_cancel
menu.findItem(R.id.menu_sync).setTitle(
@ -779,8 +785,9 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
public boolean onOptionsItemSelected(MenuItem item) {//实现菜单项目的操作，通过case语句对各个菜单项目分别设置事件
switch (item.getItemId()) {//五个菜单项的响应实现
//调用不同方法实现不同菜单项
case R.id.menu_new_folder: {
showCreateOrModifyFolderDialog(true);
break;
@ -790,13 +797,13 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
break;
}
case R.id.menu_sync: {
if (isSyncMode()) {
if (TextUtils.equals(item.getTitle(), getString(R.string.menu_sync))) {
if (isSyncMode()) {//同步
if (TextUtils.equals(item.getTitle(), getString(R.string.menu_sync))) {//如果项目title与菜单同步相同，则进行同步
GTaskSyncService.startSync(this);
} else {
GTaskSyncService.cancelSync(this);
}
} else {
} else {//如果不是同步模式，则开始设置动作
startPreferenceActivity();
}
break;
@ -819,23 +826,24 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
@Override
public boolean onSearchRequested() {
public boolean onSearchRequested() {//根据关键字搜索便签（还未实现）
startSearch(null, false, null /* appData */, false);
return true;
}
private void exportNoteToText() {
final BackupUtils backup = BackupUtils.getInstance(NotesListActivity.this);
private void exportNoteToText() {//输出文本内容的方法实现
final BackupUtils backup = BackupUtils.getInstance(NotesListActivity.this);//备份笔记信息
new AsyncTask<Void, Void, Integer>() {
@Override
protected Integer doInBackground(Void... unused) {
//未被占用的话后台进行
return backup.exportToText();
}
@Override
protected void onPostExecute(Integer result) {
if (result == BackupUtils.STATE_SD_CARD_UNMOUONTED) {
protected void onPostExecute(Integer result) {//设置备份的结果响应
if (result == BackupUtils.STATE_SD_CARD_UNMOUONTED) {//根据结果为sd卡未装载、成功、系统错误三种进行处理，均是设置对话框、标题、信息以及确认按钮状态
AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
builder.setTitle(NotesListActivity.this
.getString(R.string.failed_sdcard_export));
@ -843,7 +851,8 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
.getString(R.string.error_sdcard_unmounted));
builder.setPositiveButton(android.R.string.ok, null);
builder.show();
} else if (result == BackupUtils.STATE_SUCCESS) {
} else if (result == BackupUtils.STATE_SUCCESS) {//如果导出成功，则显示成功
//并且会显示“Export text file 《便签名称》 to SD 《目录名称》 directory”
AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
builder.setTitle(NotesListActivity.this
.getString(R.string.success_sdcard_export));
@ -852,7 +861,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
.getExportedTextFileName(), backup.getExportedTextFileDir()));
builder.setPositiveButton(android.R.string.ok, null);
builder.show();
} else if (result == BackupUtils.STATE_SYSTEM_ERROR) {
} else if (result == BackupUtils.STATE_SYSTEM_ERROR) {//如果系统错误，则显示 导出失败，请检查SD卡
AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
builder.setTitle(NotesListActivity.this
.getString(R.string.failed_sdcard_export));
@ -866,20 +875,20 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}.execute();
}
private boolean isSyncMode() {
private boolean isSyncMode() {//判断是否处于同步模式
return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
}
private void startPreferenceActivity() {
Activity from = getParent() != null ? getParent() : this;
private void startPreferenceActivity() {//跳转到设置界面
Activity from = getParent() != null ? getParent() : this;//设置便签函数
Intent intent = new Intent(from, NotesPreferenceActivity.class);
from.startActivityIfNeeded(intent, -1);
}
private class OnListItemClickListener implements OnItemClickListener {
private class OnListItemClickListener implements OnItemClickListener {//响应选项的监听器
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
if (view instanceof NotesListItem) {
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {//项目被点击的响应
if (view instanceof NotesListItem) {//判断view是否是NotesListItem的一个实例，如果是就获取他的项目信息装入item中
NoteItemData item = ((NotesListItem) view).getItemData();
if (mNotesListAdapter.isInChoiceMode()) {
if (item.getType() == Notes.TYPE_NOTE) {
@ -890,7 +899,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
return;
}
switch (mState) {
switch (mState) {//根据状态作出不同动作，如果是便签列表，则根据项的类型分别打开文件或者控制器；如果是子文件并且是数据库并且是便签类型则打开控制器，否则报错
case NOTE_LIST:
if (item.getType() == Notes.TYPE_FOLDER
|| item.getType() == Notes.TYPE_SYSTEM) {
@ -917,7 +926,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
private void startQueryDestinationFolders() {
private void startQueryDestinationFolders() {//查询目标文件
String selection = NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>? AND " + NoteColumns.ID + "<>?";
selection = (mState == ListEditState.NOTE_LIST) ? selection:
"(" + selection + ") OR (" + NoteColumns.ID + "=" + Notes.ID_ROOT_FOLDER + ")";
@ -927,7 +936,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
Notes.CONTENT_NOTE_URI,
FoldersListAdapter.PROJECTION,
selection,
new String[] {
new String[] {//新建字符列表
String.valueOf(Notes.TYPE_FOLDER),
String.valueOf(Notes.ID_TRASH_FOLER),
String.valueOf(mCurrentFolderId)
@ -936,6 +945,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
public boolean onItemLongClick(AdapterView<?> parent, View view, int position, long id) {
//实现长按项目的点击事件。如果长按的是便签，则通过ActionMode菜单实现；如果长按的是文件夹，则通过ContextMenu菜单实现。
if (view instanceof NotesListItem) {
mFocusNoteDataItem = ((NotesListItem) view).getItemData();
if (mFocusNoteDataItem.getType() == Notes.TYPE_NOTE && !mNotesListAdapter.isInChoiceMode()) {

Write Preview
Loading…
Cancel
Save