Gt_readme.txt

@@ -1,6 +0,0 @@
-Reading Log：
-
-	2023.10.30  23点39分：
-		成功导入了mi_notes的源代码，着手开始！
-
-		成功搭建了java的环境，但是对于怎么读开源代码还是没有什么头绪。

Microsoft Calculator/calculator

@@ -1 +0,0 @@
-Subproject commit fb0f8b9b757b48a27fa767b1630b0fb27fb02675

hello.java

@@ -1,5 +0,0 @@
-public class hello{
-    public static void main(String[] args) {
-        System.out.println("hello world");
-    }
-}

src/ui/NotesListActivity.java

@@ -1,19 +1,3 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 package net.micode.notes.ui;
  
 import android.app.Activity;
@@ -77,8 +61,13 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.util.HashSet;
-
+//主界面，一进入就是这个界面
-public class NotesListActivity extends Activity implements OnClickListener, OnItemLongClickListener {
+/**
+ * @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;
@@ -89,41 +78,41 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
  
     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";  //单行超过80个字符
  
     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;  // 分发Y坐标
 
-    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";
  
     public static final int NOTES_LISTVIEW_SCROLL_RATE = 30;
  
-    private NoteItemData mFocusNoteDataItem;
+    private NoteItemData mFocusNoteDataItem;  // 当前焦点笔记的数据项
  
     private static final String NORMAL_SELECTION = NoteColumns.PARENT_ID + "=?";
  
@@ -136,38 +125,49 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
     private final static int REQUEST_CODE_NEW_NODE  = 103;
  
     @Override
-    protected void onCreate(Bundle savedInstanceState) {
+    // 创建类
-        super.onCreate(savedInstanceState);
+    protected void onCreate(final Bundle savedInstanceState) {  //需要是final类型   根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。
+        // final类不能被继承，没有子类，final类中的方法默认是final的。
+        //final方法不能被子类的方法覆盖，但可以被继承。
+        //final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
+        //final不能用于修饰构造方法。
+        super.onCreate(savedInstanceState); // 调用父类的onCreate函数
         setContentView(R.layout.note_list);
         initResources();
  
         /**
          * Insert an introduction when user firstly use this application
          */
-        setAppInfoFromRawRes();
+        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)) {
             mNotesListAdapter.changeCursor(null);
         } else {
             super.onActivityResult(requestCode, resultCode, data);
+            // 调用 Activity 的onActivityResult（）
         }
     }
  
     private void setAppInfoFromRawRes() {
+    	// Android平台给我们提供了一个SharedPreferences类，它是一个轻量级的存储类，特别适合用于保存软件配置参数。
         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 {
+                // 把资源文件放到应用程序的/raw/raw下，那么就可以在应用中使用getResources获取资源后,
+            	// 以openRawResource方法（不带后缀的资源文件名）打开这个文件。 
             	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];
+                    char [] buf = new char[1024];  // 自行定义的数值，使用者不知道有什么意义
                     int len = 0;
                     while ((len = br.read(buf)) > 0) {
                         sb.append(buf, 0, len);
@@ -180,7 +180,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                 e.printStackTrace();
                 return;
             } finally {
-                if(in != null) {
+                if (in != null) {
                     try {
                         in.close();
                     } catch (IOException e) {
@@ -190,11 +190,13 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                 }
             }
             
+            // 创建空的WorkingNote
             WorkingNote note = WorkingNote.createEmptyNote(this, Notes.ID_ROOT_FOLDER,
                     AppWidgetManager.INVALID_APPWIDGET_ID, Notes.TYPE_WIDGET_INVALIDE,
-                    ResourceParser.RED);
+                    ResourceParser.RED);  // 创建一个新的工作笔记
-            note.setWorkingText(sb.toString());
+            note.setWorkingText(sb.toString());  // 设置工作笔记的内容为读取到的介绍内容
-            if (note.saveNote()) {
+            if (note.saveNote()) {  // 保存工作笔记
+            	// 更新保存note的信息
                 sp.edit().putBoolean(PREFERENCE_ADD_INTRODUCTION, true).commit();
             } else {
                 Log.e(TAG, "Save introduction note error");
@@ -209,18 +211,23 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         startAsyncNotesListQuery();
     }
  
+    // 初始化资源
     private void initResources() {
-        mContentResolver = this.getContentResolver();
+        mContentResolver = this.getContentResolver(); // 获取应用程序的数据，得到类似数据表的东西
+     // 初始化BackgroundQueryHandler
         mBackgroundQueryHandler = new BackgroundQueryHandler(this.getContentResolver());
         mCurrentFolderId = Notes.ID_ROOT_FOLDER;
-        mNotesListView = (ListView) findViewById(R.id.notes_list);
+        
+        // findViewById 是安卓编程的定位函数，主要是引用.R文件里的引用名
+        mNotesListView = (ListView) findViewById(R.id.notes_list); // 绑定XML中的ListView，作为Item的容器
+     // 将尾部视图添加到列表视图
         mNotesListView.addFooterView(LayoutInflater.from(this).inflate(R.layout.note_list_footer, null),
                 null, false);
         mNotesListView.setOnItemClickListener(new OnListItemClickListener());
         mNotesListView.setOnItemLongClickListener(this);
         mNotesListAdapter = new NotesListAdapter(this);
         mNotesListView.setAdapter(mNotesListAdapter);
-        mAddNewNote = (Button) findViewById(R.id.btn_new_note);
+        mAddNewNote = (Button) findViewById(R.id.btn_new_note);// 在activity中要获取该按钮
         mAddNewNote.setOnClickListener(this);
         mAddNewNote.setOnTouchListener(new NewNoteOnTouchListener());
         mDispatch = false;
@@ -231,11 +238,12 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         mModeCallBack = new ModeCallback();
     }
  
+    // 继承自ListView.MultiChoiceModeListener 和 OnMenuItemClickListener
     private class ModeCallback implements ListView.MultiChoiceModeListener, OnMenuItemClickListener {
         private DropdownMenu mDropDownMenu;
         private ActionMode mActionMode;
         private MenuItem mMoveMenu;
-
+     // 创建ActionMode时触发
         public boolean onCreateActionMode(ActionMode mode, Menu menu) {
             getMenuInflater().inflate(R.menu.note_list_options, menu);
             menu.findItem(R.id.delete).setOnMenuItemClickListener(this);
@@ -251,7 +259,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
             mNotesListAdapter.setChoiceMode(true);
             mNotesListView.setLongClickable(false);
             mAddNewNote.setVisibility(View.GONE);
-
+         // 初始化下拉菜单
             View customView = LayoutInflater.from(NotesListActivity.this).inflate(
                     R.layout.note_list_dropdown_menu, null);
             mode.setCustomView(customView);
@@ -259,9 +267,9 @@ 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(final MenuItem item) {
                     mNotesListAdapter.selectAll(!mNotesListAdapter.isAllSelected());
-                    updateMenu();
+                    updateMenu();// 更新菜单
                     return true;
                 }
  
@@ -269,11 +277,12 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
             return true;
         }
  
+        // 更新菜单
         private void updateMenu() {
             int selectedCount = mNotesListAdapter.getSelectedCount();
             // Update dropdown menu
             String format = getResources().getString(R.string.menu_select_title, selectedCount);
-            mDropDownMenu.setTitle(format);
+            mDropDownMenu.setTitle(format); // 更改标题
             MenuItem item = mDropDownMenu.findItem(R.id.action_select_all);
             if (item != null) {
                 if (mNotesListAdapter.isAllSelected()) {
@@ -295,7 +304,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
             // TODO Auto-generated method stub
             return false;
         }
-
+        // 销毁ActionMode时触发
         public void onDestroyActionMode(ActionMode mode) {
             mNotesListAdapter.setChoiceMode(false);
             mNotesListView.setLongClickable(true);
@@ -305,13 +314,13 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         public void finishActionMode() {
             mActionMode.finish();
         }
-
+     // 当选择的项发生变化时触发
         public void onItemCheckedStateChanged(ActionMode mode, int position, long id,
                 boolean checked) {
             mNotesListAdapter.setCheckedItem(position, checked);
             updateMenu();
         }
-
+     // 菜单项点击事件处理
         public boolean onMenuItemClick(MenuItem item) {
             if (mNotesListAdapter.getSelectedCount() == 0) {
                 Toast.makeText(NotesListActivity.this, getString(R.string.menu_select_none),
@@ -321,6 +330,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
  
             switch (item.getItemId()) {
                 case R.id.delete:
+                	// 弹出删除对话框
                     AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
                     builder.setTitle(getString(R.string.alert_title_delete));
                     builder.setIcon(android.R.drawable.ic_dialog_alert);
@@ -337,7 +347,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                     builder.show();
                     break;
                 case R.id.move:
-                    startQueryDestinationFolders();
+                    startQueryDestinationFolders();// 查询目标文件夹
                     break;
                 default:
                     return false;
@@ -366,7 +376,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                     /**
                      * HACKME:When click the transparent part of "New Note" button, dispatch
                      * the event to the list view behind this button. The transparent part of
-                     * "New Note" button could be expressed by formula y=-0.12x+94（Unit:pixel）
+                     * "New Note" button could be expressed by formula y=-0.12x+94锛圲nit:pixel锛<EFBFBD>
                      * 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
@@ -409,14 +419,16 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
     };
  
     private void startAsyncNotesListQuery() {
+    	// 构建查询语句的selection，根据当前文件夹id选择不同的查询条件 	
         String selection = (mCurrentFolderId == Notes.ID_ROOT_FOLDER) ? ROOT_FOLDER_SELECTION
                 : NORMAL_SELECTION;
+     // 调用异步查询处理器进行数据库查询
         mBackgroundQueryHandler.startQuery(FOLDER_NOTE_LIST_QUERY_TOKEN, null,
                 Notes.CONTENT_NOTE_URI, NoteItemData.PROJECTION, selection, new String[] {
                     String.valueOf(mCurrentFolderId)
                 }, NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC");
     }
-
+ // 异步查询处理器类
     private final class BackgroundQueryHandler extends AsyncQueryHandler {
         public BackgroundQueryHandler(ContentResolver contentResolver) {
             super(contentResolver);
@@ -426,10 +438,12 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
             switch (token) {
                 case FOLDER_NOTE_LIST_QUERY_TOKEN:
+                	// 查询完成后更新列表适配器的Cursor数据源
                     mNotesListAdapter.changeCursor(cursor);
                     break;
                 case FOLDER_LIST_QUERY_TOKEN:
                     if (cursor != null && cursor.getCount() > 0) {
+                    	 // 如果查询到了文件夹列表，则显示文件夹选择菜单
                         showFolderListMenu(cursor);
                     } else {
                         Log.e(TAG, "Query folder failed");
@@ -440,7 +454,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
             }
         }
     }
-
+ // 显示文件夹选择菜单
     private void showFolderListMenu(Cursor cursor) {
         AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
         builder.setTitle(R.string.menu_title_select_folder);
@@ -448,6 +462,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         builder.setAdapter(adapter, new DialogInterface.OnClickListener() {
  
             public void onClick(DialogInterface dialog, int which) {
+            	 // 点击菜单项后进行相应操作，这里是批量移动笔记到选中的文件夹
                 DataUtils.batchMoveToFolder(mContentResolver,
                         mNotesListAdapter.getSelectedItemIds(), adapter.getItemId(which));
                 Toast.makeText(
@@ -461,19 +476,21 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         });
         builder.show();
     }
-
+ // 创建新的笔记
     private void createNewNote() {
         Intent intent = new Intent(this, NoteEditActivity.class);
         intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
         intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mCurrentFolderId);
         this.startActivityForResult(intent, REQUEST_CODE_NEW_NODE);
     }
-
+ // 批量删除操作
     private void batchDelete() {
         new AsyncTask<Void, Void, HashSet<AppWidgetAttribute>>() {
             protected HashSet<AppWidgetAttribute> doInBackground(Void... unused) {
+            	// 获取选中笔记对应的小部件信息
                 HashSet<AppWidgetAttribute> widgets = mNotesListAdapter.getSelectedWidget();
                 if (!isSyncMode()) {
+                	// 如果不是同步模式，则直接删除选中的笔记
                     // if not synced, delete notes directly
                     if (DataUtils.batchDeleteNotes(mContentResolver, mNotesListAdapter
                             .getSelectedItemIds())) {
@@ -532,7 +549,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
             }
         }
     }
-
+ // 打开笔记详情界面
     private void openNode(NoteItemData data) {
         Intent intent = new Intent(this, NoteEditActivity.class);
         intent.setAction(Intent.ACTION_VIEW);
@@ -541,6 +558,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
     }
  
     private void openFolder(NoteItemData data) {
+    	// 更新当前文件夹id，并进行异步查询笔记列表
         mCurrentFolderId = data.getId();
         startAsyncNotesListQuery();
         if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
@@ -560,85 +578,88 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
     public void onClick(View v) {
         switch (v.getId()) {
             case R.id.btn_new_note:
+            	// 点击新建笔记按钮，触发创建新的笔记操作
                 createNewNote();
                 break;
             default:
                 break;
         }
     }
-
+ // 显示输入法软键盘
     private void showSoftInput() {
         InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
         if (inputMethodManager != null) {
             inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
         }
     }
-
+ // 隐藏输入法软键盘
     private void hideSoftInput(View view) {
         InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
         inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
     }
-
+    //显示创建或修改文件夹的对话框
     private void showCreateOrModifyFolderDialog(final boolean create) {
-        final AlertDialog.Builder builder = new AlertDialog.Builder(this);
+        final AlertDialog.Builder builder = new AlertDialog.Builder(this);// 创建对话框构建器
-        View view = LayoutInflater.from(this).inflate(R.layout.dialog_edit_text, null);
+        View view = LayoutInflater.from(this).inflate(R.layout.dialog_edit_text, null);//加载布局文件
-        final EditText etName = (EditText) view.findViewById(R.id.et_foler_name);
+        final EditText etName = (EditText) view.findViewById(R.id.et_foler_name);// 获取输入框
-        showSoftInput();
+        showSoftInput();// 显示软键盘
-        if (!create) {
+        if (!create) { // 如果是修改文件夹
-            if (mFocusNoteDataItem != null) {
+            if (mFocusNoteDataItem != null) { // 如果有选中的文件夹
-                etName.setText(mFocusNoteDataItem.getSnippet());
+                etName.setText(mFocusNoteDataItem.getSnippet()); // 设置输入框文字为文件夹名称
-                builder.setTitle(getString(R.string.menu_folder_change_name));
+                builder.setTitle(getString(R.string.menu_folder_change_name)); // 设置对话框标题为"更改文件夹名称"
             } else {
-                Log.e(TAG, "The long click data item is null");
+                Log.e(TAG, "The long click data item is null"); // 输出错误日志
                 return;
             }
-        } else {
+        } else { // 如果是创建文件夹
-            etName.setText("");
+            etName.setText(""); // 清空输入框
-            builder.setTitle(this.getString(R.string.menu_create_folder));
+            builder.setTitle(this.getString(R.string.menu_create_folder)); // 设置对话框标题为"创建文件夹"
         }
  
-        builder.setPositiveButton(android.R.string.ok, null);
+        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);
+                hideSoftInput(etName); // 隐藏软键盘
             }
-        });
+        }); // 设置取消按钮，点击时隐藏软键盘
 
-        final Dialog dialog = builder.setView(view).show();
+        final Dialog dialog = builder.setView(view).show(); // 创建对话框并显示
-        final Button positive = (Button)dialog.findViewById(android.R.id.button1);
+        final Button positive = (Button)dialog.findViewById(android.R.id.button1); // 获取确定按钮
         positive.setOnClickListener(new OnClickListener() {
             public void onClick(View v) {
-                hideSoftInput(etName);
+                hideSoftInput(etName); // 隐藏软键盘
-                String name = etName.getText().toString();
+                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();
+                            Toast.LENGTH_LONG).show(); // 显示提示信息，文件夹已存在
-                    etName.setSelection(0, etName.length());
+                    etName.setSelection(0, etName.length()); // 选中输入框中的文字
                     return;
                 }
-                if (!create) {
+
-                    if (!TextUtils.isEmpty(name)) {
+                if (!create) { // 如果是修改文件夹
+                    if (!TextUtils.isEmpty(name)) { // 如果文件夹名称不为空
                         ContentValues values = new ContentValues();
-                        values.put(NoteColumns.SNIPPET, name);
+                        values.put(NoteColumns.SNIPPET, name); // 更新文件夹名称
-                        values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
+                        values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER); // 设置类型为文件夹
-                        values.put(NoteColumns.LOCAL_MODIFIED, 1);
+                        values.put(NoteColumns.LOCAL_MODIFIED, 1); // 标记本地修改
                         mContentResolver.update(Notes.CONTENT_NOTE_URI, values, NoteColumns.ID
                                 + "=?", new String[] {
                             String.valueOf(mFocusNoteDataItem.getId())
-                        });
+                        }); // 更新数据库中的文件夹信息
                     }
-                } else if (!TextUtils.isEmpty(name)) {
+                } else if (!TextUtils.isEmpty(name)) { // 如果是创建文件夹且文件夹名称不为空
                     ContentValues values = new ContentValues();
-                    values.put(NoteColumns.SNIPPET, name);
+                    values.put(NoteColumns.SNIPPET, name); // 设置文件夹名称
-                    values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
+                    values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER); // 设置类型为文件夹
-                    mContentResolver.insert(Notes.CONTENT_NOTE_URI, values);
+                    mContentResolver.insert(Notes.CONTENT_NOTE_URI, values); // 插入数据库中
                 }
-                dialog.dismiss();
+
+                dialog.dismiss(); // 关闭对话框
             }
         });
-
+        if (TextUtils.isEmpty(etName.getText())) { // 如果输入框内容为空
-        if (TextUtils.isEmpty(etName.getText())) {
+            positive.setEnabled(false); // 禁用确定按钮
-            positive.setEnabled(false);
         }
         /**
          * When the name edit text is null, disable the positive button
@@ -664,9 +685,12 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         });
     }
  
+    /* (non-Javadoc)
+     * @see android.app.Activity#onBackPressed()
+     * 按返回键时根据情况更改类中的数据
+     */
     @Override
-    public void onBackPressed() {
+    public void onBackPressed() { switch (mState) {
-        switch (mState) {
             case SUB_FOLDER:
                 mCurrentFolderId = Notes.ID_ROOT_FOLDER;
                 mState = ListEditState.NOTE_LIST;
@@ -688,6 +712,11 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         }
     }
  
+    /**
+     * @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) {
@@ -707,6 +736,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) {
@@ -726,6 +758,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         super.onContextMenuClosed(menu);
     }
  
+    /* (non-Javadoc)
+     * @see android.app.Activity#onContextItemSelected(android.view.MenuItem)
+     * 针对menu中不同的选择进行不同的处理，里面详细注释
+     */
     @Override
     public boolean onContextItemSelected(MenuItem item) {
         if (mFocusNoteDataItem == null) {
@@ -734,10 +770,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         }
         switch (item.getItemId()) {
             case MENU_FOLDER_VIEW:
-                openFolder(mFocusNoteDataItem);
+                openFolder(mFocusNoteDataItem);//打开对应文件
                 break;
             case MENU_FOLDER_DELETE:
-                AlertDialog.Builder builder = new AlertDialog.Builder(this);
+                AlertDialog.Builder builder = new AlertDialog.Builder(this);//设置确认是否删除的对话框
                 builder.setTitle(getString(R.string.alert_title_delete));
                 builder.setIcon(android.R.drawable.ic_dialog_alert);
                 builder.setMessage(getString(R.string.alert_message_delete_folder));
@@ -748,7 +784,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                             }
                         });
                 builder.setNegativeButton(android.R.string.cancel, null);
-                builder.show();
+                builder.show();//显示对话框
                 break;
             case MENU_FOLDER_CHANGE_NAME:
                 showCreateOrModifyFolderDialog(false);
@@ -763,54 +799,55 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
     @Override
     public boolean onPrepareOptionsMenu(Menu menu) {
         menu.clear();
-        if (mState == ListEditState.NOTE_LIST) {
+        if (mState == ListEditState.NOTE_LIST) {   // 如果当前状态是便签列表
-            getMenuInflater().inflate(R.menu.note_list, menu);
+            getMenuInflater().inflate(R.menu.note_list, menu);   // 加载便签列表的菜单布局
-            // set sync or sync_cancel
+            // 设置同步或取消同步选项的标题
             menu.findItem(R.id.menu_sync).setTitle(
                     GTaskSyncService.isSyncing() ? R.string.menu_sync_cancel : R.string.menu_sync);
-        } else if (mState == ListEditState.SUB_FOLDER) {
+        } else if (mState == ListEditState.SUB_FOLDER) {   // 如果当前状态是子文件夹
-            getMenuInflater().inflate(R.menu.sub_folder, menu);
+            getMenuInflater().inflate(R.menu.sub_folder, menu);   // 加载子文件夹的菜单布局
-        } else if (mState == ListEditState.CALL_RECORD_FOLDER) {
+        } else if (mState == ListEditState.CALL_RECORD_FOLDER) {   // 如果当前状态是通话记录文件夹
-            getMenuInflater().inflate(R.menu.call_record_folder, menu);
+            getMenuInflater().inflate(R.menu.call_record_folder, menu);   // 加载通话记录文件夹的菜单布局
         } else {
-            Log.e(TAG, "Wrong state:" + mState);
+            Log.e(TAG, "Wrong state:" + mState);   // 如果状态不匹配，则输出错误日志
         }
         return true;
     }
 
+ 
     @Override
     public boolean onOptionsItemSelected(MenuItem item) {
         switch (item.getItemId()) {
-            case R.id.menu_new_folder: {
+            case R.id.menu_new_folder: {   // 如果选择了新建文件夹选项
-                showCreateOrModifyFolderDialog(true);
+                showCreateOrModifyFolderDialog(true);   // 显示创建或修改文件夹对话框
                 break;
             }
-            case R.id.menu_export_text: {
+            case R.id.menu_export_text: {   // 如果选择了导出文本选项
-                exportNoteToText();
+                exportNoteToText();   // 导出便签到文本
                 break;
             }
-            case R.id.menu_sync: {
+            case R.id.menu_sync: {   // 如果选择了同步选项
-                if (isSyncMode()) {
+                if (isSyncMode()) {   // 如果处于同步模式
                     if (TextUtils.equals(item.getTitle(), getString(R.string.menu_sync))) {
-                        GTaskSyncService.startSync(this);
+                        GTaskSyncService.startSync(this);   // 启动同步服务
                     } else {
-                        GTaskSyncService.cancelSync(this);
+                        GTaskSyncService.cancelSync(this);   // 取消同步服务
                     }
                 } else {
-                    startPreferenceActivity();
+                    startPreferenceActivity();   // 跳转到设置界面
                 }
                 break;
             }
-            case R.id.menu_setting: {
+            case R.id.menu_setting: {   // 如果选择了设置选项
-                startPreferenceActivity();
+                startPreferenceActivity();   // 跳转到设置界面
                 break;
             }
-            case R.id.menu_new_note: {
+            case R.id.menu_new_note: {   // 如果选择了新建便签选项
-                createNewNote();
+                createNewNote();   // 创建新的便签
                 break;
             }
             case R.id.menu_search:
-                onSearchRequested();
+                onSearchRequested(); // 执行搜索操作
                 break;
             default:
                 break;
@@ -818,46 +855,53 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         return true;
     }
  
+    /* (non-Javadoc)
+     * @see android.app.Activity#onSearchRequested()
+     * 直接调用startSearch函数
+     */
     @Override
     public boolean onSearchRequested() {
         startSearch(null, false, null /* appData */, false);
         return true;
     }
  
+    /**
+     * 函数功能：实现将便签导出到文本功能
+     */
     private void exportNoteToText() {
         final BackupUtils backup = BackupUtils.getInstance(NotesListActivity.this);
         new AsyncTask<Void, Void, Integer>() {
  
         	@Override
             protected Integer doInBackground(Void... unused) {
-                return backup.exportToText();
+                return backup.exportToText();   // 调用备份工具类的导出便签到文本方法
             }
 
             @Override
             protected void onPostExecute(Integer result) {
-                if (result == BackupUtils.STATE_SD_CARD_UNMOUONTED) {
+                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));
+                            .getString(R.string.failed_sdcard_export));   // 设置对话框标题为导出失败
                     builder.setMessage(NotesListActivity.this
-                            .getString(R.string.error_sdcard_unmounted));
+                            .getString(R.string.error_sdcard_unmounted));   // 设置对话框内容为SD卡未挂载
                     builder.setPositiveButton(android.R.string.ok, null);
                     builder.show();
-                } else if (result == BackupUtils.STATE_SUCCESS) {
+                } else if (result == BackupUtils.STATE_SUCCESS) {   // 如果导出成功
                     AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
                     builder.setTitle(NotesListActivity.this
-                            .getString(R.string.success_sdcard_export));
+                            .getString(R.string.success_sdcard_export));   // 设置对话框标题为导出成功
                     builder.setMessage(NotesListActivity.this.getString(
                             R.string.format_exported_file_location, backup
-                                    .getExportedTextFileName(), backup.getExportedTextFileDir()));
+                                    .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) {   // 如果系统错误
                     AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
                     builder.setTitle(NotesListActivity.this
-                            .getString(R.string.failed_sdcard_export));
+                            .getString(R.string.failed_sdcard_export));   // 设置对话框标题为导出失败
                     builder.setMessage(NotesListActivity.this
-                            .getString(R.string.error_sdcard_export));
+                            .getString(R.string.error_sdcard_export));   // 设置对话框内容为导出错误
                     builder.setPositiveButton(android.R.string.ok, null);
                     builder.show();
                 }
@@ -866,26 +910,37 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         }.execute();
     }
  
+    /**
+     * @return
+     * 功能：判断是否正在同步
+     */
     private boolean isSyncMode() {
         return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
     }
  
+    /**
+     * 功能：跳转到PreferenceActivity界面
+     */
     private void startPreferenceActivity() {
         Activity from = getParent() != null ? getParent() : this;
         Intent intent = new Intent(from, NotesPreferenceActivity.class);
         from.startActivityIfNeeded(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();
+                NoteItemData item = ((NotesListItem) view).getItemData();   // 获取点击项的数据
-                if (mNotesListAdapter.isInChoiceMode()) {
+                if (mNotesListAdapter.isInChoiceMode()) {   // 如果处于选择模式
                     if (item.getType() == Notes.TYPE_NOTE) {
                         position = position - mNotesListView.getHeaderViewsCount();
                         mModeCallBack.onItemCheckedStateChanged(null, position, id,
-                                !mNotesListAdapter.isSelectedItem(position));
+                                !mNotesListAdapter.isSelectedItem(position));   // 更新选择状态
                     }
                     return;
                 }
@@ -894,9 +949,9 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                     case NOTE_LIST:
                         if (item.getType() == Notes.TYPE_FOLDER
                                 || item.getType() == Notes.TYPE_SYSTEM) {
-                            openFolder(item);
+                            openFolder(item);   // 打开文件夹
                         } else if (item.getType() == Notes.TYPE_NOTE) {
-                            openNode(item);
+                            openNode(item);   // 打开便签
                         } else {
                             Log.e(TAG, "Wrong note type in NOTE_LIST");
                         }
@@ -904,7 +959,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                     case SUB_FOLDER:
                     case CALL_RECORD_FOLDER:
                         if (item.getType() == Notes.TYPE_NOTE) {
-                            openNode(item);
+                            openNode(item);   // 打开便签
                         } else {
                             Log.e(TAG, "Wrong note type in SUB_FOLDER");
                         }
@@ -917,6 +972,9 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
 
     }
 
+    /**
+     * 查询目标文件
+     */
     private void startQueryDestinationFolders() {
         String selection = NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>? AND " + NoteColumns.ID + "<>?";
         selection = (mState == ListEditState.NOTE_LIST) ? selection:
@@ -935,18 +993,24 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                 NoteColumns.MODIFIED_DATE + " DESC");
     }
  
+    /* (non-Javadoc)
+     * @see android.widget.AdapterView.OnItemLongClickListener#onItemLongClick(android.widget.AdapterView, android.view.View, 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();
+            mFocusNoteDataItem = ((NotesListItem) view).getItemData();// 获取当前长按项的数据
             if (mFocusNoteDataItem.getType() == Notes.TYPE_NOTE && !mNotesListAdapter.isInChoiceMode()) {
                 if (mNotesListView.startActionMode(mModeCallBack) != null) {
-                    mModeCallBack.onItemCheckedStateChanged(null, position, id, true);
+                    mModeCallBack.onItemCheckedStateChanged(null, position, id, true);// 更改选择状态
                     mNotesListView.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
                 } else {
                     Log.e(TAG, "startActionMode fails");
                 }
             } else if (mFocusNoteDataItem.getType() == Notes.TYPE_FOLDER) {
-                mNotesListView.setOnCreateContextMenuListener(mFolderOnCreateContextMenuListener);
+                mNotesListView.setOnCreateContextMenuListener(mFolderOnCreateContextMenuListener);// 设置创建上下文菜单监听器
             }
         }
         return false;

src/ui/NotesListAdapter.java

@@ -1,19 +1,3 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 package net.micode.notes.ui;
  
 import android.content.Context;
@@ -23,6 +7,7 @@ import android.view.View;
 import android.view.ViewGroup;
 import android.widget.CursorAdapter;
  
+ 
 import net.micode.notes.data.Notes;
  
 import java.util.Collection;
@@ -31,55 +16,94 @@ import java.util.HashSet;
 import java.util.Iterator;
  
  
+/*
+ * 功能：直译为便签表连接器，继承了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 int mNotesCount;    //便签数
-    private boolean mChoiceMode;
+    private boolean mChoiceMode;   //选择模式标记
  
+    /*
+     * 桌面widget的属性，包括编号和类型
+     */
     public static class AppWidgetAttribute {
         public int widgetId;
         public int widgetType;
     };
  
+    /*
+     * 函数功能：初始化便签链接器
+     * 函数实现：根据传进来的内容设置相关变量
+     */
     public NotesListAdapter(Context context) {
-        super(context, null);
+        super(context, null);  //父类对象置空
-        mSelectedIndex = new HashMap<Integer, Boolean>();
+        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(cursor.getPosition()));
+           //则新建一个项目选项并且用bind跟将view和鼠标，内容，便签数据捆绑在一起
         }
     }
  
+    /*
+     * 函数功能：设置勾选框
+     * 函数实现：如下注释
+     */
     public void setCheckedItem(final int position, final boolean checked) {
         mSelectedIndex.put(position, checked);
+        //根据定位和是否勾选设置下标
         notifyDataSetChanged();
+        //在修改后刷新activity
     }
  
+    /*
+     * 函数功能：判断单选按钮是否勾选
+     */
     public boolean isInChoiceMode() {
         return mChoiceMode;
     }
  
+    /*
+     * 函数功能：设置单项选项框
+     * 函数实现：重置下标并且根据参数mode设置选项
+     */
     public void setChoiceMode(boolean mode) {
         mSelectedIndex.clear();
         mChoiceMode = mode;
     }
  
+    /*
+     * 函数功能：选择全部选项
+     * 函数实现：如下注释
+     */
     public void selectAll(boolean checked) {
         Cursor cursor = getCursor();
+        //获取光标位置
         for (int i = 0; i < getCount(); i++) {
             if (cursor.moveToPosition(i)) {
                 if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) {
@@ -87,30 +111,47 @@ public class NotesListAdapter extends CursorAdapter {
                 }
             }
         }
+        //遍历所有光标可用的位置在判断为便签类型之后勾选单项框
     }
  
+    /*
+     * 函数功能：建立选择项的下标列表
+     * 函数实现：如下注释
+     */
     public HashSet<Long> getSelectedItemIds() {
         HashSet<Long> itemSet = new HashSet<Long>();
+        //建立hash表
         for (Integer position : mSelectedIndex.keySet()) {
+        	//遍历所有的关键
             if (mSelectedIndex.get(position) == true) {
+            	//若光标位置可用
                 Long id = getItemId(position);
                 if (id == Notes.ID_ROOT_FOLDER) {
+                	//原文件不需要添加
                     Log.d(TAG, "Wrong item id, should not happen");
                 } else {
                     itemSet.add(id);
                 }
+                //则将id该下标假如选项集合中
+                
             }
         }
  
         return itemSet;
     }
  
+    /*
+     * 函数功能：建立桌面Widget的选项表
+     * 函数实现：如下注释
+     */
     public HashSet<AppWidgetAttribute> getSelectedWidget() {
         HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>();
         for (Integer position : mSelectedIndex.keySet()) {
             if (mSelectedIndex.get(position) == true) {
                 Cursor c = (Cursor) getItem(position);
+                //以上4句和getSelectedItemIds一样，不再重复
                 if (c != null) {
+                	//光标位置可用的话就建立新的Widget属性并编辑下标和类型，最后添加到选项集中
                     AppWidgetAttribute widget = new AppWidgetAttribute();
                     NoteItemData item = new NoteItemData(mContext, c);
                     widget.widgetId = item.getWidgetId();
@@ -128,26 +169,42 @@ public class NotesListAdapter extends CursorAdapter {
         return itemSet;
     }
  
+    /*
+     * 函数功能：获取选项个数
+     * 函数实现：如下注释
+     */
     public int getSelectedCount() {
         Collection<Boolean> values = mSelectedIndex.values();
+        //首先获取选项下标的值
         if (null == values) {
             return 0;
         }
         Iterator<Boolean> iter = values.iterator();
+        //初始化叠加器
         int count = 0;
         while (iter.hasNext()) {
             if (true == iter.next()) {
+            	//若value值为真计数+1
                 count++;
             }
         }
         return count;
     }
  
+    /*
+     * 函数功能：判断是否全部选中
+     * 函数实现：如下注释
+     */
     public boolean isAllSelected() {
         int checkedCount = getSelectedCount();
         return (checkedCount != 0 && checkedCount == mNotesCount);
+        //获取选项数看是否等于便签的个数
     }
  
+    /*
+     * 函数功能：判断是否为选项表
+     * 函数实现：通过传递的下标来确定
+     */
     public boolean isSelectedItem(final int position) {
         if (null == mSelectedIndex.get(position)) {
             return false;
@@ -156,29 +213,45 @@ public class NotesListAdapter extends CursorAdapter {
     }
  
     @Override
+    /*
+     * 函数功能：在activity内容发生局部变动的时候回调该函数计算便签的数量
+     * 函数实现：如下注释
+     */
     protected void onContentChanged() {
         super.onContentChanged();
+        //执行基类函数
         calcNotesCount();
     }
  
     @Override
+    /*
+     * 函数功能：在activity光标发生局部变动的时候回调该函数计算便签的数量
+     */
     public void changeCursor(Cursor cursor) {
         super.changeCursor(cursor);
+      //执行基类函数
         calcNotesCount();
     }
  
+    /*
+     * 函数功能：计算便签数量
+     * 
+     */
     private void calcNotesCount() {
         mNotesCount = 0;
         for (int i = 0; i < getCount(); i++) {
+        	//获取总数同时遍历
             Cursor c = (Cursor) getItem(i);
             if (c != null) {
                 if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) {
                     mNotesCount++;
+                   //若该位置不为空并且文本类型为便签就+1
                 }
             } else {
                 Log.e(TAG, "Invalid cursor");
                 return;
             }
+            //否则报错
         }
     } 
 }

src/ui/NotesListItem.java

@@ -1,19 +1,3 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 package net.micode.notes.ui;
  
 import android.content.Context;
@@ -30,37 +14,43 @@ import net.micode.notes.tool.DataUtils;
 import net.micode.notes.tool.ResourceParser.NoteItemBgResources;
  
  
+//创建便签列表项目选项
 public class NotesListItem extends LinearLayout {
-    private ImageView mAlert;
+    private ImageView mAlert;//闹钟图片
-    private TextView mTitle;
+    private TextView mTitle;  //标题
-    private TextView mTime;
+    private TextView mTime;   //时间
-    private TextView mCallName;
+    private TextView mCallName;    //
-    private NoteItemData mItemData;
+    private NoteItemData mItemData; //标签数据
-    private CheckBox mCheckBox;
+    private CheckBox mCheckBox;    //打钩框
  
+    /*初始化基本信息*/
     public NotesListItem(Context context) {
-        super(context);
+        super(context);   //super()它的主要作用是调整调用父类构造函数的顺序
-        inflate(context, R.layout.note_item, this);
+        inflate(context, R.layout.note_item, this);//Inflate可用于将一个xml中定义的布局控件找出来,这里的xml是r。layout
+        //findViewById用于从contentView中查找指定ID的View，转换出来的形式根据需要而定;
         mAlert = (ImageView) findViewById(R.id.iv_alert_icon);
         mTitle = (TextView) findViewById(R.id.tv_title);
         mTime = (TextView) findViewById(R.id.tv_time);
         mCallName = (TextView) findViewById(R.id.tv_name);
         mCheckBox = (CheckBox) findViewById(android.R.id.checkbox);
     }
-
+  ///根据data的属性对各个控件的属性的控制，主要是可见性Visibility，内容setText，格式setTextAppearance
     public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
         if (choiceMode && data.getType() == Notes.TYPE_NOTE) {
-            mCheckBox.setVisibility(View.VISIBLE);
+            mCheckBox.setVisibility(View.VISIBLE);  ///设置可见行为可见
-            mCheckBox.setChecked(checked);
+            mCheckBox.setChecked(checked);         ///格子打钩
         } else {
             mCheckBox.setVisibility(View.GONE);
         }
  
         mItemData = data;
+        ///设置控件属性，一共三种情况，由data的id和父id是否与保存到文件夹的id一致来决定
         if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
             mCallName.setVisibility(View.GONE);
             mAlert.setVisibility(View.VISIBLE);
+            //设置该textview的style
             mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
+            //settext为设置内容
             mTitle.setText(context.getString(R.string.call_record_folder_name)
                     + context.getString(R.string.format_folder_files_count, data.getNotesCount()));
             mAlert.setImageResource(R.drawable.call_record);
@@ -69,8 +59,9 @@ public class NotesListItem extends LinearLayout {
             mCallName.setText(data.getCallName());
             mTitle.setTextAppearance(context,R.style.TextAppearanceSecondaryItem);
             mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
+            ///关于闹钟的设置
             if (data.hasAlert()) {
-                mAlert.setImageResource(R.drawable.clock);
+                mAlert.setImageResource(R.drawable.clock);//图片来源的设置
                 mAlert.setVisibility(View.VISIBLE);
             } else {
                 mAlert.setVisibility(View.GONE);
@@ -78,7 +69,7 @@ public class NotesListItem extends LinearLayout {
         } else {
             mCallName.setVisibility(View.GONE);
             mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
-
+            ///设置title格式
             if (data.getType() == Notes.TYPE_FOLDER) {
                 mTitle.setText(data.getSnippet()
                         + context.getString(R.string.format_folder_files_count,
@@ -87,35 +78,38 @@ public class NotesListItem extends LinearLayout {
             } else {
                 mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
                 if (data.hasAlert()) {
-                    mAlert.setImageResource(R.drawable.clock);
+                    mAlert.setImageResource(R.drawable.clock);///设置图片来源
                     mAlert.setVisibility(View.VISIBLE);
                 } else {
                     mAlert.setVisibility(View.GONE);
                 }
             }
         }
-        mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));
+        ///设置内容，获取相关时间，从data里编辑的日期中获取
+        mTime. setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));
        
         setBackground(data);
     }
-
+    //根据data的文件属性来设置背景
     private void setBackground(NoteItemData data) {
         int id = data.getBgColorId();
+        //，若是note型文件，则4种情况，对于4种不同情况的背景来源
         if (data.getType() == Notes.TYPE_NOTE) {
+        	//单个数据并且只有一个子文件夹
             if (data.isSingle() || data.isOneFollowingFolder()) {
                 setBackgroundResource(NoteItemBgResources.getNoteBgSingleRes(id));
-            } else if (data.isLast()) {
+            } else if (data.isLast()) {//是最后一个数据
                 setBackgroundResource(NoteItemBgResources.getNoteBgLastRes(id));
-            } else if (data.isFirst() || data.isMultiFollowingFolder()) {
+            } else if (data.isFirst() || data.isMultiFollowingFolder()) {//是一个数据并有多个子文件夹
                 setBackgroundResource(NoteItemBgResources.getNoteBgFirstRes(id));
             } else {
                 setBackgroundResource(NoteItemBgResources.getNoteBgNormalRes(id));
             }
         } else {
+        	//若不是note直接调用文件夹的背景来源
             setBackgroundResource(NoteItemBgResources.getFolderBgRes());
         }
     }
-
     public NoteItemData getItemData() {
         return mItemData;
     }

src/ui/NotesPreferenceActivity.java

@@ -1,19 +1,3 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 package net.micode.notes.ui;
  
 import android.accounts.Account;
@@ -47,66 +31,92 @@ import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.gtask.remote.GTaskSyncService;
  
-
+/*
+ *该类功能：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) {
+    	//先执行父类的创建函数
         super.onCreate(icicle);
         
         /* using the app icon for navigation */
         getActionBar().setDisplayHomeAsUpEnabled(true);
+        //给左上角图标的左边加上一个返回的图标 
  
         addPreferencesFromResource(R.xml.preferences);
+        //添加xml来源并显示 xml
         mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);
+        //根据同步账户关键码来初始化分组
         mReceiver = new GTaskReceiver();
         IntentFilter filter = new IntentFilter();
         filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME);
         registerReceiver(mReceiver, filter);
+        //初始化同步组件
  
         mOriAccounts = null;
         View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null);
+        //获取listvivew，ListView的作用:用于列出所有选择 
         getListView().addHeaderView(header, null, true);
+        //在listview组件上方添加其他组件
     }
  
     @Override
+    /*
+     * 函数功能：activity交互功能的实现，用于接受用户的输入
+     * 函数实现：如下注释
+     */
     protected void onResume() {
+    	//先执行父类 的交互实现
         super.onResume();
  
         // need to set sync account automatically if user has added a new
         // account
         if (mHasAddedAccount) {
+        	//若用户新加了账户则自动设置同步账户
             Account[] accounts = getGoogleAccounts();
+            //获取google同步账户
             if (mOriAccounts != null && accounts.length > mOriAccounts.length) {
+                //若原账户不为空且当前账户有增加
             	for (Account accountNew : accounts) {
                     boolean found = false;
                     for (Account accountOld : mOriAccounts) {
                         if (TextUtils.equals(accountOld.name, accountNew.name)) {
+                        	//更新账户
                             found = true;
                             break;
                         }
                     }
                     if (!found) {
                         setSyncAccount(accountNew.name);
+                        //若是没有找到旧的账户，那么同步账号中就只添加新账户
                         break;
                     }
                 }
@@ -114,35 +124,52 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         }
  
         refreshUI();
+        //刷新标签界面
     }
  
     @Override
+    /*
+     * 函数功能：销毁一个activity
+     * 函数实现：如下注释
+     */
     protected void onDestroy() {
         if (mReceiver != null) {
             unregisterReceiver(mReceiver);
+            //注销接收器
         }
         super.onDestroy();
+        //执行父类的销毁动作
     }
  
+    /*
+     * 函数功能：重新设置账户信息
+     * 函数实现：如下注释
+     */
     private void loadAccountPreference() {
         mAccountCategory.removeAll();
-
+        //销毁所有的分组
         Preference accountPref = new Preference(this);
+        //建立首选项
         final String defaultAccount = getSyncAccountName(this);
         accountPref.setTitle(getString(R.string.preferences_account_title));
         accountPref.setSummary(getString(R.string.preferences_account_summary));
+        //设置首选项的大标题和小标题
         accountPref.setOnPreferenceClickListener(new OnPreferenceClickListener() {
             public boolean onPreferenceClick(Preference preference) {
+            	//建立监听器
                 if (!GTaskSyncService.isSyncing()) {
                     if (TextUtils.isEmpty(defaultAccount)) {
                         // 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中显示不能修改
                     Toast.makeText(NotesPreferenceActivity.this,
                             R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
                             .show();
@@ -151,21 +178,29 @@ public class NotesPreferenceActivity extends PreferenceActivity {
             }
         });
  
+        //根据新建首选项编辑新的账户分组
         mAccountCategory.addPreference(accountPref);
     }
  
+    /*
+     *函数功能：设置按键的状态和最后同步的时间
+     *函数实现：如下注释 
+     */
     private void loadSyncButton() {
         Button syncButton = (Button) findViewById(R.id.preference_sync_button);
         TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
-
+        //获取同步按钮控件和最终同步时间的的窗口
         // set button state
+        //设置按钮的状态
         if (GTaskSyncService.isSyncing()) {
+        	//若是在同步状态下
             syncButton.setText(getString(R.string.preferences_button_sync_cancel));
             syncButton.setOnClickListener(new View.OnClickListener() {
                 public void onClick(View v) {
                     GTaskSyncService.cancelSync(NotesPreferenceActivity.this);
                 }
             });
+            //设置按钮显示的文本为“取消同步”以及监听器
         } else {
             syncButton.setText(getString(R.string.preferences_button_sync_immediately));
             syncButton.setOnClickListener(new View.OnClickListener() {
@@ -173,50 +208,67 @@ public class NotesPreferenceActivity extends PreferenceActivity {
                     GTaskSyncService.startSync(NotesPreferenceActivity.this);
                 }
             });
+          //若是不同步则设置按钮显示的文本为“立即同步”以及对应监听器
         }
         syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this)));
+        //设置按键可用还是不可用
  
         // set last sync time
+        // 设置最终同步时间
         if (GTaskSyncService.isSyncing()) {
+        	//若是在同步的情况下
             lastSyncTimeView.setText(GTaskSyncService.getProgressString());
             lastSyncTimeView.setVisibility(View.VISIBLE);
+            // 根据当前同步服务器设置时间显示框的文本以及可见性
         } else {
+        	//若是非同步情况
             long lastSyncTime = getLastSyncTime(this);
             if (lastSyncTime != 0) {
                 lastSyncTimeView.setText(getString(R.string.preferences_last_sync_time,
                         DateFormat.format(getString(R.string.preferences_last_sync_time_format),
                                 lastSyncTime)));
                 lastSyncTimeView.setVisibility(View.VISIBLE);
+                //则根据最后同步时间的信息来编辑时间显示框的文本内容和可见性
             } else {
+            	 //若时间为空直接设置为不可见状态
                 lastSyncTimeView.setVisibility(View.GONE);
             }
         }
     }
-
+     /*
+      *函数功能：刷新标签界面
+      *函数实现：调用上文设置账号和设置按键两个函数来实现 
+      */
     private void refreshUI() {
         loadAccountPreference();
         loadSyncButton();
     }
  
+    /*
+     * 函数功能：显示账户选择的对话框并进行账户的设置
+     * 函数实现：如下注释
+     */
     private void showSelectAccountAlertDialog() {
         AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
+        //创建一个新的对话框
  
         View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
         TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
         titleTextView.setText(getString(R.string.preferences_dialog_select_account_title));
         TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
         subtitleTextView.setText(getString(R.string.preferences_dialog_select_account_tips));
-
+        //设置标题以及子标题的内容
         dialogBuilder.setCustomTitle(titleView);
         dialogBuilder.setPositiveButton(null, null);
-
+        //设置对话框的自定义标题，建立一个YES的按钮
         Account[] accounts = getGoogleAccounts();
         String defAccount = getSyncAccountName(this);
-
+        //获取同步账户信息
         mOriAccounts = accounts;
         mHasAddedAccount = false;
  
         if (accounts.length > 0) {
+        	//若账户不为空
             CharSequence[] items = new CharSequence[accounts.length];
             final CharSequence[] itemMapping = items;
             int checkedItem = -1;
@@ -224,83 +276,119 @@ public class NotesPreferenceActivity extends PreferenceActivity {
             for (Account account : accounts) {
                 if (TextUtils.equals(account.name, defAccount)) {
                     checkedItem = index;
+                    //在账户列表中查询到所需账户
                 }
                 items[index++] = account.name;
             }
             dialogBuilder.setSingleChoiceItems(items, checkedItem,
+            		//在对话框建立一个单选的复选框
                     new DialogInterface.OnClickListener() {
                         public void onClick(DialogInterface dialog, int which) {
                             setSyncAccount(itemMapping[which].toString());
                             dialog.dismiss();
+                            //取消对话框
                             refreshUI();
                         }
+                        //设置点击后执行的事件，包括检录新同步账户和刷新标签界面
                     });
+            //建立对话框网络版的监听器
         }
  
         View addAccountView = LayoutInflater.from(this).inflate(R.layout.add_account_text, null);
         dialogBuilder.setView(addAccountView);
+        //给新加账户对话框设置自定义样式
  
         final AlertDialog dialog = dialogBuilder.show();
+        //显示对话框
         addAccountView.setOnClickListener(new View.OnClickListener() {
             public void onClick(View v) {
                 mHasAddedAccount = true;
+                //将新加账户的hash置true
                 Intent intent = new Intent("android.settings.ADD_ACCOUNT_SETTINGS");
+                //建立网络建立组件
                 intent.putExtra(AUTHORITIES_FILTER_KEY, new String[] {
                     "gmail-ls"
                 });
                 startActivityForResult(intent, -1);
+                //跳回上一个选项
                 dialog.dismiss();
             }
         });
+        //建立新加账户对话框的监听器
     }
  
+    /*
+     * 函数功能：显示账户选择对话框和相关账户操作
+     * 函数实现：如下注释
+     */
     private void showChangeAccountConfirmAlertDialog() {
         AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
-
+        //创建一个新的对话框
         View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
         TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
         titleTextView.setText(getString(R.string.preferences_dialog_change_account_title,
                 getSyncAccountName(this)));
         TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
         subtitleTextView.setText(getString(R.string.preferences_dialog_change_account_warn_msg));
+        //根据同步修改的账户信息设置标题以及子标题的内容
         dialogBuilder.setCustomTitle(titleView);
-
+      //设置对话框的自定义标题
         CharSequence[] menuItemArray = new CharSequence[] {
                 getString(R.string.preferences_menu_change_account),
                 getString(R.string.preferences_menu_remove_account),
                 getString(R.string.preferences_menu_cancel)
         };
+        //定义一些标记字符串
         dialogBuilder.setItems(menuItemArray, new DialogInterface.OnClickListener() {
+        	//设置对话框要显示的一个list，用于显示几个命令时,即change，remove，cancel
             public void onClick(DialogInterface dialog, int which) {
+            	//按键功能，由which来决定
                 if (which == 0) {
+                	//进入账户选择对话框
                     showSelectAccountAlertDialog();
                 } else if (which == 1) {
+                	//删除账户并且跟新便签界面
                     removeSyncAccount();
                     refreshUI();
                 }
             }
         });
         dialogBuilder.show();
+        //显示对话框
     }
  
+    /*
+     *函数功能：获取谷歌账户
+     *函数实现：通过账户管理器直接获取
+     */
     private Account[] getGoogleAccounts() {
         AccountManager accountManager = AccountManager.get(this);
         return accountManager.getAccountsByType("com.google");
     }
  
+    /*
+     * 函数功能：设置同步账户
+     * 函数实现：如下注释：
+     */
     private void setSyncAccount(String account) {
         if (!getSyncAccountName(this).equals(account)) {
+        	//假如该账号不在同步账号列表中
             SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
             SharedPreferences.Editor editor = settings.edit();
+            //编辑共享的首选项
             if (account != null) {
                 editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, account);
             } else {
                 editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
             }
+            //将该账号加入到首选项中
+            
             editor.commit();
+            //提交修改的数据
+ 
             
-            // clean up last sync time
             setLastSyncTime(this, 0);
+          //将最后同步时间清零
  
             // clean up local gtask related info
             new Thread(new Runnable() {
@@ -311,23 +399,33 @@ public class NotesPreferenceActivity extends PreferenceActivity {
                     getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
                 }
             }).start();
+            //重置当地同步任务的信息
  
             Toast.makeText(NotesPreferenceActivity.this,
                     getString(R.string.preferences_toast_success_set_accout, account),
                     Toast.LENGTH_SHORT).show();
+            //将toast的文本信息置为“设置账户成功”并显示出来
         }
     }
-
+    /*
+     * 函数功能：删除同步账户
+     * 函数实现：如下注释：
+     */
     private void removeSyncAccount() {
         SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
         SharedPreferences.Editor editor = settings.edit();
+        //设置共享首选项
+        
         if (settings.contains(PREFERENCE_SYNC_ACCOUNT_NAME)) {
             editor.remove(PREFERENCE_SYNC_ACCOUNT_NAME);
+            //假如当前首选项中有账户就删除
         }
         if (settings.contains(PREFERENCE_LAST_SYNC_TIME)) {
             editor.remove(PREFERENCE_LAST_SYNC_TIME);
+            //删除当前首选项中有账户时间
         }
         editor.commit();
+        //提交更新后的数据
         
         // clean up local gtask related info
         new Thread(new Runnable() {
@@ -338,51 +436,79 @@ public class NotesPreferenceActivity extends PreferenceActivity {
                 getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
             }
         }).start();
+      //重置当地同步任务的信息
     }
     
+    /*
+     * 函数功能：获取同步账户名称
+     * 函数实现：通过共享的首选项里的信息直接获取
+     */
     public static String getSyncAccountName(Context context) {
         SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
                 Context.MODE_PRIVATE);
         return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
     }
  
+    /*
+     * 函数功能：设置最终同步的时间
+     * 函数实现：如下注释
+     */
     public static void setLastSyncTime(Context context, long time) {
         SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
                 Context.MODE_PRIVATE);
         SharedPreferences.Editor editor = settings.edit();
+        // 从共享首选项中找到相关账户并获取其编辑器
         editor.putLong(PREFERENCE_LAST_SYNC_TIME, time);
         editor.commit();
+        //编辑最终同步时间并提交更新
     }
-
+    /*
+     * 函数功能：获取最终同步时间
+     * 函数实现：通过共享的首选项里的信息直接获取
+     */
     public static long getLastSyncTime(Context context) {
         SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
                 Context.MODE_PRIVATE);
         return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);
     }
  
+    /*
+     * 函数功能：接受同步信息
+     * 函数实现：继承BroadcastReceiver
+     */
     private class GTaskReceiver extends BroadcastReceiver {
  
         @Override
         public void onReceive(Context context, Intent intent) {
             refreshUI();
             if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {
+                //获取随广播而来的Intent中的同步服务的数据
             	TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
                 syncStatus.setText(intent
                         .getStringExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_PROGRESS_MSG));
+                //通过获取的数据在设置系统的状态
             }
  
         }
     }
  
+    /*
+     * 函数功能：处理菜单的选项
+     * 函数实现：如下注释
+     * 参数:MenuItem菜单选项
+     */
     public boolean onOptionsItemSelected(MenuItem item) {
         switch (item.getItemId()) {
+        //根据选项的id选择，这里只有一个主页
             case android.R.id.home:
                 Intent intent = new Intent(this, NotesListActivity.class);
                 intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
                 startActivity(intent);
                 return true;
+                //在主页情况下在创建连接组件intent，发出清空的信号并开始一个相应的activity
             default:
                 return false;
         }
     }
 }
+ 

小米便签源码/.gitignore

@@ -1,9 +0,0 @@
-# generated files
-bin/
-gen/
-
-# Local configuration file (sdk path, etc)
-project.properties
-.settings/
-.classpath
-.project

小米便签源码/AndroidManifest.xml

@@ -1,150 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-
-<!-- Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="net.micode.notes"
-    android:versionCode="1"
-    android:versionName="0.1" >
-
-    <uses-sdk android:minSdkVersion="14" />
-
-    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
-    <uses-permission android:name="com.android.launcher.permission.INSTALL_SHORTCUT" />
-    <uses-permission android:name="android.permission.INTERNET" />
-    <uses-permission android:name="android.permission.READ_CONTACTS" />
-    <uses-permission android:name="android.permission.MANAGE_ACCOUNTS" />
-    <uses-permission android:name="android.permission.AUTHENTICATE_ACCOUNTS" />
-    <uses-permission android:name="android.permission.GET_ACCOUNTS" />
-    <uses-permission android:name="android.permission.USE_CREDENTIALS" />
-    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
-
-    <application
-        android:icon="@drawable/icon_app"
-        android:label="@string/app_name" >
-        <activity
-            android:name=".ui.NotesListActivity"
-            android:configChanges="keyboardHidden|orientation|screenSize"
-            android:label="@string/app_name"
-            android:launchMode="singleTop"
-            android:theme="@style/NoteTheme"
-            android:uiOptions="splitActionBarWhenNarrow"
-            android:windowSoftInputMode="adjustPan" >
-
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-
-        <activity
-            android:name=".ui.NoteEditActivity"
-            android:configChanges="keyboardHidden|orientation|screenSize"
-            android:launchMode="singleTop"
-            android:theme="@style/NoteTheme" >
-
-            <intent-filter>
-                <action android:name="android.intent.action.VIEW" />
-                <category android:name="android.intent.category.DEFAULT" />
-                <data android:mimeType="vnd.android.cursor.item/text_note" />
-                <data android:mimeType="vnd.android.cursor.item/call_note" />
-            </intent-filter>
-
-            <intent-filter>
-                <action android:name="android.intent.action.INSERT_OR_EDIT" />
-                <category android:name="android.intent.category.DEFAULT" />
-                <data android:mimeType="vnd.android.cursor.item/text_note" />
-                <data android:mimeType="vnd.android.cursor.item/call_note" />
-            </intent-filter>
-
-            <intent-filter>
-                <action android:name="android.intent.action.SEARCH" />
-                <category android:name="android.intent.category.DEFAULT" />
-            </intent-filter>
-
-            <meta-data
-                android:name="android.app.searchable"
-                android:resource="@xml/searchable" />
-        </activity>
-
-        <provider
-            android:name="net.micode.notes.data.NotesProvider"
-            android:authorities="micode_notes"
-            android:multiprocess="true" />
-
-        <receiver
-            android:name=".widget.NoteWidgetProvider_2x"
-            android:label="@string/app_widget2x2" >
-            <intent-filter>
-                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
-                <action android:name="android.appwidget.action.APPWIDGET_DELETED" />
-                <action android:name="android.intent.action.PRIVACY_MODE_CHANGED" />
-            </intent-filter>
-
-            <meta-data
-                android:name="android.appwidget.provider"
-                android:resource="@xml/widget_2x_info" />
-        </receiver>
-        <receiver
-            android:name=".widget.NoteWidgetProvider_4x"
-            android:label="@string/app_widget4x4" >
-
-            <intent-filter>
-                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
-                <action android:name="android.appwidget.action.APPWIDGET_DELETED" />
-                <action android:name="android.intent.action.PRIVACY_MODE_CHANGED" />
-            </intent-filter>
-
-            <meta-data
-                android:name="android.appwidget.provider"
-                android:resource="@xml/widget_4x_info" />
-        </receiver>
-
-        <receiver android:name=".ui.AlarmInitReceiver" >
-            <intent-filter>
-                <action android:name="android.intent.action.BOOT_COMPLETED" />
-            </intent-filter>
-        </receiver>
-
-        <receiver
-            android:name="net.micode.notes.ui.AlarmReceiver"
-            android:process=":remote" >
-        </receiver>
-
-        <activity
-            android:name=".ui.AlarmAlertActivity"
-            android:label="@string/app_name"
-            android:launchMode="singleInstance"
-            android:theme="@android:style/Theme.Holo.Wallpaper.NoTitleBar" >
-        </activity>
-
-        <activity
-            android:name="net.micode.notes.ui.NotesPreferenceActivity"
-            android:label="@string/preferences_title"
-            android:launchMode="singleTop"
-            android:theme="@android:style/Theme.Holo.Light" >
-        </activity>
-
-        <service
-            android:name="net.micode.notes.gtask.remote.GTaskSyncService"
-            android:exported="false" >
-        </service>
-
-        <meta-data
-            android:name="android.app.default_searchable"
-            android:value=".ui.NoteEditActivity" />
-    </application>
-</manifest>

小米便签源码/NOTICE

@@ -1,190 +0,0 @@
-
-   Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-

小米便签源码/README

@@ -1,23 +0,0 @@
-[中文]
-
-1. MiCode便签是小米便签的社区开源版，由MIUI团队(www.miui.com) 发起并贡献第一批代码，遵循NOTICE文件所描述的开源协议，
-   今后为MiCode社区(www.micode.net) 拥有，并由社区发布和维护。
-
-2. Bug反馈和跟踪，请访问Github,
-   https://github.com/MiCode/Notes/issues?sort=created&direction=desc&state=open
-
-3. 功能建议和综合讨论，请访问MiCode,
-   http://micode.net/forum.php?mod=forumdisplay&fid=38
-
-
-[English]
-
-1. MiCode Notes is open source edition of XM notepad, it's first initiated and sponsored by MIUI team (www.miui.com).
-   It's opened under license described by NOTICE file. It's owned by the MiCode community (www.micode.net). In future,
-   the MiCode community will release and maintain this project.
-
-2. Regarding issue tracking, please visit Github,
-   https://github.com/MiCode/Notes/issues?sort=created&direction=desc&state=open
-
-3. Regarding feature request and general discussion, please visit Micode forum,
-   http://micode.net/forum.php?mod=forumdisplay&fid=38

小米便签源码/res/color/primary_text_dark.xml

@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<!-- Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-
-<selector xmlns:android="http://schemas.android.com/apk/res/android">
-  <item android:state_pressed="true" android:color="#88555555" />
-  <item android:state_selected="true" android:color="#ff999999" />
-  <item android:color="#ff000000" />
-</selector>

小米便签源码/res/color/secondary_text_dark.xml

@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<!-- Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-
-<selector xmlns:android="http://schemas.android.com/apk/res/android">
-  <item android:color="#50000000" />
-</selector>