Merge branch 'llw_branch' of https://bdgit.educoder.net/p2whvruqn/gitProject1 into dev

# Conflicts:
#	doc/小米便签开源代码的泛读报告.docx

README.md

@@ -3,6 +3,10 @@
 # gitProject1
 
 1.精读小米便签源代码，写泛读报告
+<<<<<<< HEAD
+
+2.
+=======
 =======
 <<<<<<< HEAD
 <<<<<<< HEAD
@@ -24,3 +28,4 @@ abc
 1.精读小米便签源代码，写泛读报告
 >>>>>>> ec5b092c2fe5adbe24627fc2992503627dc1795b
 >>>>>>> 5f5cff49fcbaa1b5df8823143d84bbfcc52cd49f
+>>>>>>> 63fc6f227a94c2fab6101a51858ced17a7619c89

src/Notes-master/.idea/.name

@@ -0,0 +1 @@
+NoteItemData.java

src/Notes-master/app/src/main/java/net/micode/notes/model/Note.java

@@ -56,60 +56,62 @@ public class Note {
         values.put(NoteColumns.LOCAL_MODIFIED, 1);//把LOCAL_MODIFIED 本地修改 的值赋为1
         values.put(NoteColumns.PARENT_ID, folderId);//把文件夹id赋给PARENT_ID 父类id
         Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values);
+        //getContentResolver()函数是实现外部应用对于ContentProvider中的数据进行增删查改的操作
 
-        long noteId = 0;
+        long noteId = 0;//用于标记错误信息
         try {
             noteId = Long.valueOf(uri.getPathSegments().get(1));
         }
         catch (NumberFormatException e) {
             Log.e(TAG, "Get note id error :" + e.toString());
             noteId = 0;
-        }
+        }//异常处理
+
         if (noteId == -1) {
             throw new IllegalStateException("Wrong note id:" + noteId);
-        }
+        } // 如果发生错误，输出错误ID
         return noteId;
     }
 
     public Note() {
-        mNoteDiffValues = new ContentValues();
-        mNoteData = new NoteData();
+        mNoteDiffValues = new ContentValues(); //定义一个新变量，存储便签属性
+        mNoteData = new NoteData();//定义一个新变量，存出便签内容
     }
 
     public void setNoteValue(String key, String value) {
-        mNoteDiffValues.put(key, value);
-        mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
-        mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+        mNoteDiffValues.put(key, value); //设置便签属性传入ket和value
+        mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1); //设置新创建的便签更改次数为1
+        mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis()); //设置新创建的更改日期为系统当前时间
     }
 
     public void setTextData(String key, String value) {
-        mNoteData.setTextData(key, value);
+        mNoteData.setTextData(key, value); //设置便签的内容和数据
     }
 
     public void setTextDataId(long id) {
-        mNoteData.setTextDataId(id);
+        mNoteData.setTextDataId(id); //设置便签数据的ID
     }
 
     public long getTextDataId() {
-        return mNoteData.mTextDataId;
+        return mNoteData.mTextDataId; //获取便签数据的ID
     }
 
     public void setCallDataId(long id) {
-        mNoteData.setCallDataId(id);
+        mNoteData.setCallDataId(id); //设置电话的数据的ID
     }
 
     public void setCallData(String key, String value) {
-        mNoteData.setCallData(key, value);
+        mNoteData.setCallData(key, value); //设置电话的内容和数据
     }
 
     public boolean isLocalModified() {
-        return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
-    }
+        return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified(); //
+    }//判断是否为本地产生的修改
 
     public boolean syncNote(Context context, long noteId) {
         if (noteId <= 0) {
             throw new IllegalArgumentException("Wrong note id:" + noteId);
-        }
+        } //报告错误信息
 
         if (!isLocalModified()) {
             return true;
@@ -120,6 +122,13 @@ public class Note {
          * {@link NoteColumns#MODIFIED_DATE}. For data safety, though update note fails, we also update the
          * note data info
          */
+
+        /*
+        理论上，一旦数据发生变化，应在{@link NoteColumns#LOCAL_MODIFIED}和
+        {@link NotesColumns#MODIFIED_DATE}上更新注释。为了数据安全，
+        虽然更新笔记失败，但我们也会更新笔记数据信息
+         */
+
         if (context.getContentResolver().update(
                 ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), mNoteDiffValues, null,
                 null) == 0) {
@@ -134,16 +143,16 @@ public class Note {
         }
 
         return true;
-    }
+    }//用于判断便签是否正确同步
 
     private class NoteData {
-        private long mTextDataId;
+        private long mTextDataId; //定义便签数据的文件数据ID
 
-        private ContentValues mTextDataValues;
+        private ContentValues mTextDataValues; //定义文件数据
 
-        private long mCallDataId;
+        private long mCallDataId;//定义便签电话ID
 
-        private ContentValues mCallDataValues;
+        private ContentValues mCallDataValues;//定义便签电话数据
 
         private static final String TAG = "NoteData";
 
@@ -152,57 +161,62 @@ public class Note {
             mCallDataValues = new ContentValues();
             mTextDataId = 0;
             mCallDataId = 0;
-        }
+        } //构造函数，定义文件数据ID和电话数据ID为0，创建便签电话数据和文件数据类
 
         boolean isLocalModified() {
             return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
-        }
+        }//判断是否被本地修改，返回是否修改文本数据或者电话数据
 
         void setTextDataId(long id) {
             if (id <= 0) {
                 throw new IllegalArgumentException("Text data id should larger than 0");
-            }
-            mTextDataId = id;
+            } //为文本数据ID的定义提供错误判断
+            mTextDataId = id; //设置文本数据ID
         }
 
         void setCallDataId(long id) {
             if (id <= 0) {
                 throw new IllegalArgumentException("Call data id should larger than 0");
-            }
-            mCallDataId = id;
+            }//为电话数据ID的定义提供错误判断
+            mCallDataId = id;//设置电话数据ID
         }
 
         void setCallData(String key, String value) {
-            mCallDataValues.put(key, value);
-            mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
-            mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+            mCallDataValues.put(key, value); //设置电话数据的数据和内容
+            mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1); //设置电话数据的本地修改为1
+            mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis()); //设置修改时间为本地时间
         }
 
         void setTextData(String key, String value) {
-            mTextDataValues.put(key, value);
-            mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
-            mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+            mTextDataValues.put(key, value); //设置文本数据
+            mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);//设置文本数据的本地修改为1
+            mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());//设置修改时间为本地时间
         }
 
         Uri pushIntoContentResolver(Context context, long noteId) {
+
+            /*
+             *下面函数的作用是将新的数据通过Uri的操作存储到数据库
+             */
+
             /**
              * Check for safety
              */
             if (noteId <= 0) {
                 throw new IllegalArgumentException("Wrong note id:" + noteId);
-            }
+            }//显示错误代码
 
-            ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
-            ContentProviderOperation.Builder builder = null;
+            ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>(); //定义一个新的可变数组
+            ContentProviderOperation.Builder builder = null; //数据库的操作列表设置为空
 
-            if (mTextDataValues.size() > 0) {
-                mTextDataValues.put(DataColumns.NOTE_ID, noteId);
+            if (mTextDataValues.size() > 0) { //如果文本数据的值不为0
+                mTextDataValues.put(DataColumns.NOTE_ID, noteId); //存入note数据ID
                 if (mTextDataId == 0) {
                     mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE);
                     Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
                             mTextDataValues);
                     try {
-                        setTextDataId(Long.valueOf(uri.getPathSegments().get(1)));
+                         setTextDataId(Long.valueOf(uri.getPathSegments().get(1)));
                     }
                     catch (NumberFormatException e) {
                         Log.e(TAG, "Insert new text data fail with noteId" + noteId);
@@ -217,7 +231,7 @@ public class Note {
                     operationList.add(builder.build());
                 }
                 mTextDataValues.clear();
-            }
+            }//把文本数据存入到DataColumns
 
             if (mCallDataValues.size() > 0) {
                 mCallDataValues.put(DataColumns.NOTE_ID, noteId);
@@ -241,7 +255,7 @@ public class Note {
                     operationList.add(builder.build());
                 }
                 mCallDataValues.clear();
-            }
+            }//把电话数据存入到DataColumns
 
             if (operationList.size() > 0) {
                 try {
@@ -260,6 +274,6 @@ public class Note {
                 }
             }
             return null;
-        }
+        }//存储过程中对于异常情况的处理
     }
 }

src/Notes-master/app/src/main/java/net/micode/notes/ui/NoteEditText.java

@@ -36,7 +36,7 @@ import net.micode.notes.R;
 
 import java.util.HashMap;
 import java.util.Map;
-
+//继承edittext，设置便签设置文本框
 public class NoteEditText extends EditText {
     private static final String TAG = "NoteEditText";
     private int mIndex;
@@ -46,6 +46,8 @@ public class NoteEditText extends EditText {
     private static final String SCHEME_HTTP = "http:" ;
     private static final String SCHEME_EMAIL = "mailto:" ;
 
+//定义了一个名为sSchemaActionResMap的静态常量map,构成字符串与整数的映射
+//用于存储电话网站还有邮箱
     private static final Map<String, Integer> sSchemaActionResMap = new HashMap<String, Integer>();
     static {
         sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel);
@@ -56,54 +58,69 @@ public class NoteEditText extends EditText {
     /**
      * Call by the {@link NoteEditActivity} to delete or add edit text
      */
+
+//在NoteEditActivity中删除或添加文本的操作，可以看做是一个文本是否被变的标记
     public interface OnTextViewChangeListener {
         /**
          * Delete current edit text when {@link KeyEvent#KEYCODE_DEL} happens
          * and the text is null
          */
+        //在按下删除键且文本为空时删除当前编辑文本
         void onEditTextDelete(int index, String text);
 
         /**
          * Add edit text after current edit text when {@link KeyEvent#KEYCODE_ENTER}
          * happen
          */
+        //在按下回车键时在当前编辑文本后添加编辑文本
         void onEditTextEnter(int index, String text);
 
         /**
          * Hide or show item option when text change
          */ 
+        //在文本更改时隐藏或显示项目选项
         void onTextChange(int index, boolean hasText);
     }
 
     private OnTextViewChangeListener mOnTextViewChangeListener;
 
+
+    //根据context设置文本
     public NoteEditText(Context context) {
         super(context, null);
+        //用super引用父类变量
         mIndex = 0;
     }
 
+    //光标设置
     public void setIndex(int index) {
         mIndex = index;
     }
 
+    //初始化文本修改标记
     public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
         mOnTextViewChangeListener = listener;
     }
 
+    //初始化便签
     public NoteEditText(Context context, AttributeSet attrs) {
         super(context, attrs, android.R.attr.editTextStyle);
     }
 
+    // 根据defstyle自动初始化
     public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
         super(context, attrs, defStyle);
         // TODO Auto-generated constructor stub
     }
 
     @Override 
+    //重写函数
+    //view里的函数
     public boolean onTouchEvent(MotionEvent event) {
         switch (event.getAction()) {           
+            //重写了需要处理屏幕被按下的事
+            //改变坐标值
             case MotionEvent.ACTION_DOWN:
-
                 int x = (int) event.getX();
                 int y = (int) event.getY();
                 x -= getTotalPaddingLeft();
@@ -111,9 +128,12 @@ public class NoteEditText extends EditText {
                 x += getScrollX();
                 y += getScrollY();
 
+                //用布局控件layout根据x,y的新值设置新的位置
                 Layout layout = getLayout();
                 int line = layout.getLineForVertical(y);
                 int off = layout.getOffsetForHorizontal(line, x);
+                
+                //光标位置更新
                 Selection.setSelection(getText(), off);
                 break;
         }
@@ -123,7 +143,9 @@ public class NoteEditText extends EditText {
 
     @Override
     public boolean onKeyDown(int keyCode, KeyEvent event) {
+        //根据按键的 Unicode 编码值来处理
         switch (keyCode) {
+            //更具用户按下的keyCode是进入还是删除来处理事件
             case KeyEvent.KEYCODE_ENTER:
                 if (mOnTextViewChangeListener != null) {
                     return false;
@@ -135,30 +157,40 @@ public class NoteEditText extends EditText {
             default:
                 break;
         }
+        //继续执行父类的其他点击事件
         return super.onKeyDown(keyCode, event);
     }
 
     @Override
     public boolean onKeyUp(int keyCode, KeyEvent event) {
+        //根据按键的 Unicode 编码值来处理，有删除和进入2种操作
         switch(keyCode) {
             case KeyEvent.KEYCODE_DEL:   
+            //当按键为删除键时，如果 mOnTextViewChangeListener 不为 null，则会检查当前光标位置是否为0且 mIndex不为0，则调用
                 if (mOnTextViewChangeListener != null) {
                     if (0 == mSelectionStartBeforeDelete && mIndex != 0) {
                         mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString());
+                        //利用上文OnTextViewChangeListener对KEYCODE_DEL按键情况的删除函数进行删除
                         return true;
                     }
                 } else {
+                    //否则，会在日志中输出一条信息，表示文本视图更改监听器未设置。
                     Log.d(TAG, "OnTextViewChangeListener was not seted");
                 }
                 break;
             case KeyEvent.KEYCODE_ENTER: 
+            //当按键为进入键时
                 if (mOnTextViewChangeListener != null) {
                     int selectionStart = getSelectionStart();
+                    //获取当前位置
                     String text = getText().subSequence(selectionStart, length()).toString();
+                    //获取当前文本
                     setText(getText().subSequence(0, selectionStart));
+                    //根据获取位置设置当前文本
                     mOnTextViewChangeListener.onEditTextEnter(mIndex + 1, text);
                 } else {
                     Log.d(TAG, "OnTextViewChangeListener was not seted");
+                    //其他情况报错，并输出文档的改动监听器并没有建立
                 }
                 break;
             default:
@@ -168,30 +200,48 @@ public class NoteEditText extends EditText {
     }
 
     @Override
+    //焦点变化时处理事件
+    //focused表示是否获得焦点
+    //direction表示焦点变化的方向
+    //previouslyFocusedRect表示之前获得焦点视图的位置
     protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
+
         if (mOnTextViewChangeListener != null) {
+            //监听器已经建立
             if (!focused && TextUtils.isEmpty(getText())) {
+            	//获取到焦点并且文本不为空
                 mOnTextViewChangeListener.onTextChange(mIndex, false);
+                //false则隐藏事件选项
             } else {
                 mOnTextViewChangeListener.onTextChange(mIndex, true);
+                //true则显示事件选项
             }
         }
+    	//继续执行父类的其他焦点变化的事件
         super.onFocusChanged(focused, direction, previouslyFocusedRect);
     }
 
     @Override  
+    //用于生成上下文菜单
     protected void onCreateContextMenu(ContextMenu menu) {
+        //检查文本
         if (getText() instanceof Spanned) {
+             // 获取选定文本的起始和结束位置
             int selStart = getSelectionStart();
             int selEnd = getSelectionEnd();
 
+            // 计算选定文本的最小和最大位置
             int min = Math.min(selStart, selEnd);
             int max = Math.max(selStart, selEnd);
 
+            // 获取选定文本中的所有 URLSpan
             final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class);
+            //如果只有一个URLSpan
             if (urls.length == 1) {  
                 int defaultResId = 0;
+                //获取计划表中所有的key值  
                 for(String schema: sSchemaActionResMap.keySet()) {
+                	//若url可以添加则在添加后将defaultResId置为key所映射的值
                     if(urls[0].getURL().indexOf(schema) >= 0) {
                         defaultResId = sSchemaActionResMap.get(schema);
                         break;
@@ -201,7 +251,7 @@ public class NoteEditText extends EditText {
                 if (defaultResId == 0) {
                     defaultResId = R.string.note_link_other;
                 }
-
+                //在菜单中增加选项
                 menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener(
                         new OnMenuItemClickListener() {
                             public boolean onMenuItemClick(MenuItem item) {
@@ -212,6 +262,7 @@ public class NoteEditText extends EditText {
                         });
             }
         }
+        //执行父类的其他菜单创建事件
         super.onCreateContextMenu(menu);
     }
 }

src/Notes-master/app/src/main/java/net/micode/notes/ui/NotesListActivity.java

@@ -175,22 +175,32 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         }
     }
 
+    //从原始资源中读取介绍文件并将其内容存储在一个StringBuilder对象中
     private void setAppInfoFromRawRes() {
+    	// Android平台给我们提供了一个SharedPreferences类，它是一个轻量级的存储类，特别适合用于保存软件配置参数。
         SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
+        //查SharedPreferences对象中是否存在一个名为PREFERENCE_ADD_INTRODUCTION的布尔值。
+        //如果该值不存在或为假，则执行以下操作
         if (!sp.getBoolean(PREFERENCE_ADD_INTRODUCTION, false)) {
+            //创建一个名为sb的新的StringBuilder对象
             StringBuilder sb = new StringBuilder();
             InputStream in = null;
             try {
+                //声明一个名为in的输入流变量并初始化为null
+                //使用getResources().openRawResource(R.raw.introduction)打开原始资源中名为“introduction”的文件
+                //并将其存储在输入流变量in中
                  in = getResources().openRawResource(R.raw.introduction);
-                if (in != null) {
+                if (in != null) {//如果in非空
                     InputStreamReader isr = new InputStreamReader(in);
                     BufferedReader br = new BufferedReader(isr);
                     char [] buf = new char[1024];
                     int len = 0;
+                    //表示将字符数组buf中从索引0开始，
+                    //长度为len的子数组添加到StringBuilder对象sb的末尾
                     while ((len = br.read(buf)) > 0) {
                         sb.append(buf, 0, len);
                     }
-                } else {
+                } else {//否则使用Log.e方法记录一条错误消息并返回
                     Log.e(TAG, "Read introduction file error");
                     return;
                 }
@@ -199,6 +209,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                 return;
             } finally {
                 if(in != null) {
+                    //若不为空尝试关闭输入流且捕捉可能发生的IOException异常
                     try {
                         in.close();
                     } catch (IOException e) {
@@ -208,11 +219,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);
             note.setWorkingText(sb.toString());
             if (note.saveNote()) {
+            	// 更新保存note的信息
                 sp.edit().putBoolean(PREFERENCE_ADD_INTRODUCTION, true).commit();
             } else {
                 Log.e(TAG, "Save introduction note error");
@@ -222,22 +235,33 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
     }
 
     @Override
+    //先调用父类onStart方法
+    //然后调用startAsyncNotesListQuery方法
     protected void onStart() {
         super.onStart();
         startAsyncNotesListQuery();
     }
 
+
     private void initResources() {
+        //获取内容解析器（ContentResolve）的数据，得到类似数据表的东西
         mContentResolver = this.getContentResolver();
         mBackgroundQueryHandler = new BackgroundQueryHandler(this.getContentResolver());
         mCurrentFolderId = Notes.ID_ROOT_FOLDER;
+
+        // findViewById 是安卓编程的定位函数，主要是引用.R文件里的引用名
         mNotesListView = (ListView) findViewById(R.id.notes_list);
         mNotesListView.addFooterView(LayoutInflater.from(this).inflate(R.layout.note_list_footer, null),
                 null, false);
+        
+        //为ListView设置OnItemClickListener和OnItemLongClickListener监听器
         mNotesListView.setOnItemClickListener(new OnListItemClickListener());
         mNotesListView.setOnItemLongClickListener(this);
+        //创建一个新的NotesListAdapter对象并将其存储在名为mNotesListAdapter的变量中
         mNotesListAdapter = new NotesListAdapter(this);
         mNotesListView.setAdapter(mNotesListAdapter);
+
+        //获取布局文件activity中ID为btn_new_note的按钮（Button）对象
         mAddNewNote = (Button) findViewById(R.id.btn_new_note);
         mAddNewNote.setOnClickListener(this);
         mAddNewNote.setOnTouchListener(new NewNoteOnTouchListener());
@@ -249,11 +273,14 @@ 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);
@@ -284,16 +311,19 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                 }
 
             });
+            //创建成功则返回true
             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 (item != null) { //若项目非空
+                //检查列表适配器是否已经选择了所有列表项
                 if (mNotesListAdapter.isAllSelected()) {
                     item.setChecked(true);
                     item.setTitle(R.string.menu_deselect_all);
@@ -320,23 +350,31 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
             mAddNewNote.setVisibility(View.VISIBLE);
         }
 
+        //完成操作模式
         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) {
+                //如果等于0则使用Toast.makeText方法显示一条提示消息 
+                //返回true
                 Toast.makeText(NotesListActivity.this, getString(R.string.menu_select_none),
                         Toast.LENGTH_SHORT).show();
                 return true;
             }
 
+            //检测菜单ID
             switch (item.getItemId()) {
                 case R.id.delete:
                     AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
@@ -360,10 +398,13 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                 default:
                     return false;
             }
+            //返回true表示已经成功处理了菜单点击事件
             return true;
         }
     }
 
+
+    //已有注释
     private class NewNoteOnTouchListener implements OnTouchListener {
 
         public boolean onTouch(View v, MotionEvent event) {
@@ -426,6 +467,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
 
     };
 
+    //启动异步笔记列表查询
     private void startAsyncNotesListQuery() {
         String selection = (mCurrentFolderId == Notes.ID_ROOT_FOLDER) ? ROOT_FOLDER_SELECTION
                 : NORMAL_SELECTION;
@@ -435,12 +477,16 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                 }, NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC");
     }
 
+    //BackgroundQueryHandler类可能用于执行后台查询操
     private final class BackgroundQueryHandler extends AsyncQueryHandler {
         public BackgroundQueryHandler(ContentResolver contentResolver) {
+            //调用父类的构造函数
+            //后续代码可以使用ContentResolver对象来执行异步查询
             super(contentResolver);
         }
 
         @Override
+        //处理查询结果
         protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
             switch (token) {
                 case FOLDER_NOTE_LIST_QUERY_TOKEN:
@@ -459,6 +505,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         }
     }
 
+    //显示文件夹列表菜单 接受一个Cursor对象
     private void showFolderListMenu(Cursor cursor) {
         AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
         builder.setTitle(R.string.menu_title_select_folder);
@@ -480,6 +527,7 @@ 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);
@@ -487,12 +535,14 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         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())) {
                     } else {
@@ -500,18 +550,22 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                     }
                 } else {
                     // in sync mode, we'll move the deleted note into the trash
+                    // 在同步模式下，我们会将已删除的笔记移入回收站
                     // folder
                     if (!DataUtils.batchMoveToFolder(mContentResolver, mNotesListAdapter
                             .getSelectedItemIds(), Notes.ID_TRASH_FOLER)) {
                         Log.e(TAG, "Move notes to trash folder error, should not happens");
                     }
                 }
+                //返回小部件
                 return widgets;
             }
 
             @Override
             protected void onPostExecute(HashSet<AppWidgetAttribute> widgets) {
                 if (widgets != null) {
+                    //应用程序微件属性 
+                    //遍历这些对象并检查每个对象的 widgetId 和 widgetType 属性
                     for (AppWidgetAttribute widget : widgets) {
                         if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID
                                 && widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) {
@@ -519,11 +573,13 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                         }
                     }
                 }
+                //结束操作模式
                 mModeCallBack.finishActionMode();
             }
         }.execute();
     }
 
+    //删除文件夹
     private void deleteFolder(long folderId) {
         if (folderId == Notes.ID_ROOT_FOLDER) {
             Log.e(TAG, "Wrong folder id, should not happen " + folderId);
@@ -536,9 +592,11 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                 folderId);
         if (!isSyncMode()) {
             // if not synced, delete folder directly
+            ////如果未同步，直接删除文件夹
             DataUtils.batchDeleteNotes(mContentResolver, ids);
         } else {
             // in sync mode, we'll move the deleted folder into the trash folder
+            // 在同步模式下，我们会将已删除的文件夹移动到垃圾箱文件夹中
             DataUtils.batchMoveToFolder(mContentResolver, ids, Notes.ID_TRASH_FOLER);
         }
         if (widgets != null) {
@@ -551,6 +609,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);
@@ -558,25 +617,35 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         this.startActivityForResult(intent, REQUEST_CODE_OPEN_NODE);
     }
 
+    //打开菜单
     private void openFolder(NoteItemData data) {
+        //获取当前文件夹id
         mCurrentFolderId = data.getId();
+        //调用异步查询
         startAsyncNotesListQuery();
-        if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
+        if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {//如果是
+            //将 mState 设置为 ListEditState.CALL_RECORD_FOLDER
+            //并将 mAddNewNote 视图设置为不可见
             mState = ListEditState.CALL_RECORD_FOLDER;
             mAddNewNote.setVisibility(View.GONE);
-        } else {
+        } else {//否则
+            //将 mState 设置为 ListEditState.SUB_FOLDER
             mState = ListEditState.SUB_FOLDER;
         }
-        if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
+        if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {//如果等于
+            //则将标题栏的文本设置为字符串资源 R.string.call_record_folder_name
             mTitleBar.setText(R.string.call_record_folder_name);
-        } else {
+        } else {//否则获取代码段
             mTitleBar.setText(data.getSnippet());
         }
+        //最后，将标题栏设置为可见
         mTitleBar.setVisibility(View.VISIBLE);
     }
 
     public void onClick(View v) {
         switch (v.getId()) {
+            //如果id等于R.id.btn_new_note
+            //创建新便签
             case R.id.btn_new_note:
                 createNewNote();
                 break;
@@ -585,6 +654,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         }
     }
 
+    //显示软输入
     private void showSoftInput() {
         InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
         if (inputMethodManager != null) {
@@ -592,11 +662,13 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         }
     }
 
+    //隐藏软输入
     private void hideSoftInput(View view) {
         InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
         inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
     }
 
+    //显示创建或修改文件夹对话框
     private void showCreateOrModifyFolderDialog(final boolean create) {
         final AlertDialog.Builder builder = new AlertDialog.Builder(this);
         View view = LayoutInflater.from(this).inflate(R.layout.dialog_edit_text, null);
@@ -660,7 +732,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         }
         /**
          * When the name edit text is null, disable the positive button
+           当名称编辑文本为空时，禁用正按钮
          */
+
+        //添加文本更改监听器
         etName.addTextChangedListener(new TextWatcher() {
             public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                 // TODO Auto-generated method stub
@@ -669,8 +744,9 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
 
             public void onTextChanged(CharSequence s, int start, int before, int count) {
                 if (TextUtils.isEmpty(etName.getText())) {
+                    //设置关闭
                     positive.setEnabled(false);
-                } else {
+                } else {//设置启用
                     positive.setEnabled(true);
                 }
             }
@@ -683,34 +759,47 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
     }
 
     @Override
+    //按下返回键时调用
+    //按返回键时根据情况更改类中的数据
     public void onBackPressed() {
         switch (mState) {
-            case SUB_FOLDER:
+            case SUB_FOLDER:  //等于SUB_FOLDER
+                //将 mCurrentFolderId 设置为 Notes.ID_ROOT_FOLDER
+                //将 mState 设置为 ListEditState.NOTE_LIST
+                //调用 startAsyncNotesListQuery 方法来启动异步查询
+                //并将标题栏设置为不可见
                 mCurrentFolderId = Notes.ID_ROOT_FOLDER;
                 mState = ListEditState.NOTE_LIST;
                 startAsyncNotesListQuery();
                 mTitleBar.setVisibility(View.GONE);
                 break;
-            case CALL_RECORD_FOLDER:
+            case CALL_RECORD_FOLDER: //等于CALL_RECORD_FOLDER（通话记录文件夹）
+                //则将 mCurrentFolderId 设置为 Notes.ID_ROOT_FOLDER
+                //将 mState 设置为 ListEditState.NOTE_LIST
+                //将 mAddNewNote 视图设置为可见，将标题栏设置为不可见
+                //并调用 startAsyncNotesListQuery 方法来启动异步查询
                 mCurrentFolderId = Notes.ID_ROOT_FOLDER;
                 mState = ListEditState.NOTE_LIST;
                 mAddNewNote.setVisibility(View.VISIBLE);
                 mTitleBar.setVisibility(View.GONE);
                 startAsyncNotesListQuery();
                 break;
-            case NOTE_LIST:
+            case NOTE_LIST: //等于NOTE_LIST，调用父类的 onBackPressed 方法
                 super.onBackPressed();
                 break;
-            default:
+            default: //否则，不执行任何操作
                 break;
         }
     }
 
+    //更新widget
     private void updateWidget(int appWidgetId, int appWidgetType) {
         Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
         if (appWidgetType == Notes.TYPE_WIDGET_2X) {
+            //放大两倍
             intent.setClass(this, NoteWidgetProvider_2x.class);
         } else if (appWidgetType == Notes.TYPE_WIDGET_4X) {
+            //放大四倍
             intent.setClass(this, NoteWidgetProvider_4x.class);
         } else {
             Log.e(TAG, "Unspported widget type");
@@ -725,6 +814,8 @@ 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) {
@@ -737,6 +828,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
     };
 
     @Override
+    //上下文菜单关闭时调用
     public void onContextMenuClosed(Menu menu) {
         if (mNotesListView != null) {
             mNotesListView.setOnCreateContextMenuListener(null);
@@ -745,16 +837,21 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
     }
 
     @Override
+    //选择某个上下文菜单时被调用
     public boolean onContextItemSelected(MenuItem item) {
-        if (mFocusNoteDataItem == null) {
+        if (mFocusNoteDataItem == null) { //如果为空输出The long click data item is null"并返回false
             Log.e(TAG, "The long click data item is null");
             return false;
         }
         switch (item.getItemId()) {
             case MENU_FOLDER_VIEW:
+                //打开文件夹
                 openFolder(mFocusNoteDataItem);
                 break;
             case MENU_FOLDER_DELETE:
+                //如果等于"MENU_FOLDER_DELETE"
+                //则创建一个警告对话框来提示用户删除文件夹
+                //并在用户确认删除后调用 deleteFolder 方法来删除文件夹
                 AlertDialog.Builder builder = new AlertDialog.Builder(this);
                 builder.setTitle(getString(R.string.alert_title_delete));
                 builder.setIcon(android.R.drawable.ic_dialog_alert);
@@ -766,12 +863,13 @@ 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);
                 break;
             default:
+                //否则不执行操作
                 break;
         }
 
@@ -779,11 +877,13 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
     }
 
     @Override
+    //准备选项菜单
     public boolean onPrepareOptionsMenu(Menu menu) {
         menu.clear();
         if (mState == ListEditState.NOTE_LIST) {
             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) {
@@ -797,6 +897,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
     }
 
     @Override
+    //所选选项项
     public boolean onOptionsItemSelected(MenuItem item) {
         switch (item.getItemId()) {
             case R.id.menu_new_folder: {
@@ -819,15 +920,15 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                 }
                 break;
             }
-            case R.id.menu_setting: {
+            case R.id.menu_setting: {//启动首选项活动
                 startPreferenceActivity();
                 break;
             }
-            case R.id.menu_new_note: {
+            case R.id.menu_new_note: {//创建新便签
                 createNewNote();
                 break;
             }
-            case R.id.menu_search:
+            case R.id.menu_search: //已请求搜索
                 onSearchRequested();
                 break;
             default:
@@ -837,11 +938,13 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
     }
 
     @Override
+    //调用startSearch函数
     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>() {
@@ -884,16 +987,19 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         }.execute();
     }
 
+    //判断是否正在同步
     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);
     }
 
+    //实现对便签列表项的点击事件（短按）
     private class OnListItemClickListener implements OnItemClickListener {
 
         public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
@@ -935,6 +1041,7 @@ 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:
@@ -953,6 +1060,8 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                 NoteColumns.MODIFIED_DATE + " DESC");
     }
 
+    // 长按某一项时进行的操作
+    // 如果长按的是便签，则通过ActionMode菜单实现；如果长按的是文件夹，则通过ContextMenu菜单实现；
     public boolean onItemLongClick(AdapterView<?> parent, View view, int position, long id) {
         if (view instanceof NotesListItem) {
             mFocusNoteDataItem = ((NotesListItem) view).getItemData();

src/Notes-master/app/src/main/java/net/micode/notes/ui/NotesListAdapter.java

@@ -31,56 +31,72 @@ import java.util.HashSet;
 import java.util.Iterator;
 
 
+//便签列表适配器
+//实现鼠标和编辑便签链接的桥梁
 public class NotesListAdapter extends CursorAdapter {
     private static final String TAG = "NotesListAdapter";
     private Context mContext; 
-    private HashMap<Integer, Boolean> mSelectedIndex;
-    private int mNotesCount;
-    private boolean mChoiceMode;
+    private HashMap<Integer, Boolean> mSelectedIndex; //所选索引
+    private int mNotesCount;     //便签数量
+    private boolean mChoiceMode; //选择模式
 
     public static class AppWidgetAttribute {
         public int widgetId;
         public int widgetType;
     };
 
+    //初始化NotesListAdapter
     public NotesListAdapter(Context context) {
-        super(context, null);
-        mSelectedIndex = new HashMap<Integer, Boolean>();
+        super(context, null); //置空父类对象
+        mSelectedIndex = new HashMap<Integer, Boolean>(); //更新哈希表
         mContext = context;
         mNotesCount = 0;
     }
 
     @Override
+    //新建视图来保存光标指向内容
     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) {
+            //检查视图是否为NotesListItem类型
+            //是的话则创建一个新的 NoteItemData 对象并使用它来绑定视图
             NoteItemData itemData = new NoteItemData(context, cursor);
             ((NotesListItem) view).bind(context, itemData, mChoiceMode,
                     isSelectedItem(cursor.getPosition()));
         }
     }
 
+    //设置勾选框
     public void setCheckedItem(final int position, final boolean checked) {
+        //根据position，checked来设置下标
         mSelectedIndex.put(position, checked);
+        //刷新activity
         notifyDataSetChanged();
     }
 
+    //判断是否处于选择模式
     public boolean isInChoiceMode() {
         return mChoiceMode;
     }
 
+    //设置选择模式
     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) {
                     setCheckedItem(i, checked);
@@ -89,14 +105,15 @@ public class NotesListAdapter extends CursorAdapter {
         }
     }
 
+    //建立选择项的下标列表
     public HashSet<Long> getSelectedItemIds() {
-        HashSet<Long> itemSet = new HashSet<Long>();
-        for (Integer position : mSelectedIndex.keySet()) {
-            if (mSelectedIndex.get(position) == true) {
+        HashSet<Long> itemSet = new HashSet<Long>();//哈希表
+        for (Integer position : mSelectedIndex.keySet()) {//遍历 mSelectedIndex 变量中的所有位置
+            if (mSelectedIndex.get(position) == true) {//如果光标位置为true
                 Long id = getItemId(position);
                 if (id == Notes.ID_ROOT_FOLDER) {
                     Log.d(TAG, "Wrong item id, should not happen");
-                } else {
+                } else {//否则添加到itemSet中
                     itemSet.add(id);
                 }
             }
@@ -105,19 +122,23 @@ public class NotesListAdapter extends CursorAdapter {
         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);
                 if (c != null) {
+                    //光标非空则建立widget并编辑下标和类型
                     AppWidgetAttribute widget = new AppWidgetAttribute();
                     NoteItemData item = new NoteItemData(mContext, c);
                     widget.widgetId = item.getWidgetId();
                     widget.widgetType = item.getWidgetType();
+                    //添加到itemSet
                     itemSet.add(widget);
                     /**
                      * Don't close cursor here, only the adapter could close it
+                     * 不要在此处关闭光标，只有适配器可以关闭它
                      */
                 } else {
                     Log.e(TAG, "Invalid cursor");
@@ -128,11 +149,14 @@ public class NotesListAdapter extends CursorAdapter {
         return itemSet;
     }
 
+    //获取选项个数
     public int getSelectedCount() {
+        //获取下标值
         Collection<Boolean> values = mSelectedIndex.values();
-        if (null == values) {
+        if (null == values) { //values为空返回0
             return 0;
         }
+        //初始化
         Iterator<Boolean> iter = values.iterator();
         int count = 0;
         while (iter.hasNext()) {
@@ -143,12 +167,16 @@ public class NotesListAdapter extends CursorAdapter {
         return count;
     }
 
+    //判断是否被全部选中
     public boolean isAllSelected() {
         int checkedCount = getSelectedCount();
+        //返回比较是否检查数等于便签数且不为0
         return (checkedCount != 0 && checkedCount == mNotesCount);
     }
 
+    //判断是否为选项表
     public boolean isSelectedItem(final int position) {
+        //获取的光标位置是否为空
         if (null == mSelectedIndex.get(position)) {
             return false;
         }
@@ -156,17 +184,20 @@ public class NotesListAdapter extends CursorAdapter {
     }
 
     @Override
+    //在适配器内容发生更改时调用计算便签数量
     protected void onContentChanged() {
         super.onContentChanged();
         calcNotesCount();
     }
 
     @Override
+    //光标更改时计算便签数量
     public void changeCursor(Cursor cursor) {
         super.changeCursor(cursor);
         calcNotesCount();
     }
 
+    //计算便签数量
     private void calcNotesCount() {
         mNotesCount = 0;
         for (int i = 0; i < getCount(); i++) {

src/Notes-master/app/src/main/java/net/micode/notes/ui/NotesListItem.java

@@ -30,17 +30,21 @@ import net.micode.notes.tool.DataUtils;
 import net.micode.notes.tool.ResourceParser.NoteItemBgResources;
 
 
+//创建便签列表项目选项
 public class NotesListItem extends LinearLayout {
-    private ImageView mAlert;
-    private TextView mTitle;
-    private TextView mTime;
-    private TextView mCallName;
-    private NoteItemData mItemData;
-    private CheckBox mCheckBox;
+    private ImageView mAlert;       //警报
+    private TextView mTitle;        //标题
+    private TextView mTime;         //时间
+    private TextView mCallName;     //呼叫名称
+    private NoteItemData mItemData; //数据
+    private CheckBox mCheckBox;     //✔框
 
+    //初始化
     public NotesListItem(Context context) {
+        //调整调用父类构造函数的顺序
         super(context);
         inflate(context, R.layout.note_item, this);
+        //findViewById 查找现有试图
         mAlert = (ImageView) findViewById(R.id.iv_alert_icon);
         mTitle = (TextView) findViewById(R.id.tv_title);
         mTime = (TextView) findViewById(R.id.tv_time);
@@ -48,18 +52,23 @@ public class NotesListItem extends LinearLayout {
         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.setChecked(checked);
-        } else {
+            mCheckBox.setVisibility(View.VISIBLE);  //设置为可见
+            mCheckBox.setChecked(checked);          //打勾
+        } else {//否则被隐藏
             mCheckBox.setVisibility(View.GONE);
         }
 
+        //根据data来设置
         mItemData = data;
         if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
+            //隐藏呼叫名称视图
             mCallName.setVisibility(View.GONE);
+            //显示报警视图
             mAlert.setVisibility(View.VISIBLE);
+            //设置文本外观
             mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
             mTitle.setText(context.getString(R.string.call_record_folder_name)
                     + context.getString(R.string.format_folder_files_count, data.getNotesCount()));
@@ -94,24 +103,29 @@ public class NotesListItem extends LinearLayout {
                 }
             }
         }
+        //设置内容，获取相关时间，从data里编辑的日期中获取
         mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));
 
         setBackground(data);
     }
 
+    //传入data设置背景
     private void setBackground(NoteItemData data) {
         int id = data.getBgColorId();
+        //如果是Notes.TYPE_NOTE
         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());
         }
     }

src/Notes-master/app/src/main/java/net/micode/notes/ui/NotesPreferenceActivity.java

@@ -47,36 +47,46 @@ import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.gtask.remote.GTaskSyncService;
 
-
+//NotesPreferenceActivity其中包含应用程序的偏好设置
+//用户可以通过这个列表来更改应用程序的设置
+//主要实现的是对背景颜色和字体大小的数据储存
+//继承自 PreferenceActivity 类
 public class NotesPreferenceActivity extends PreferenceActivity {
-    public static final String PREFERENCE_NAME = "notes_preferences";
+    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_SYNC_ACCOUNT_NAME = "pref_key_account_name"; //同步账号
 
-    public static final String PREFERENCE_LAST_SYNC_TIME = "pref_last_sync_time";
+    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 PREFERENCE_SYNC_ACCOUNT_KEY = "pref_sync_account_key";//同步密码
 
-    private static final String AUTHORITIES_FILTER_KEY = "authorities";
+    private static final String AUTHORITIES_FILTER_KEY = "authorities";//本地密码
 
-    private PreferenceCategory mAccountCategory;
+    private PreferenceCategory mAccountCategory; //账户类别
 
-    private GTaskReceiver mReceiver;
+    private GTaskReceiver mReceiver; //任务接收器
 
-    private Account[] mOriAccounts;
+    private Account[] mOriAccounts;//账户
 
-    private boolean mHasAddedAccount;
+    private boolean mHasAddedAccount; //账户hash标记
 
     @Override
+    //创建
     protected void onCreate(Bundle icicle) {
+        //调用父类的 onCreate 方法并传入保存的实例状态
         super.onCreate(icicle);
 
         /* using the app icon for navigation */
+        //使用应用程序图标进行导航
+        //设置返回图标
         getActionBar().setDisplayHomeAsUpEnabled(true);
 
+        //从资源添加首选项
+        //添加xml来源并显示 xml
         addPreferencesFromResource(R.xml.preferences);
+         //根据同步账户关键码来初始化分组
         mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);
         mReceiver = new GTaskReceiver();
         IntentFilter filter = new IntentFilter();
@@ -84,20 +94,29 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         registerReceiver(mReceiver, filter);
 
         mOriAccounts = null;
+        //获取listvivew并在listview组件上方添加其他组件
         View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null);
         getListView().addHeaderView(header, null, true);
     }
 
     @Override
+    //
     protected void onResume() {
+        //执行父类
         super.onResume();
 
         // need to set sync account automatically if user has added a new
+        //如果用户添加了新的同步帐户，则需要自动设置同步帐户
         // account
+        //如果为真
         if (mHasAddedAccount) {
+            //获取谷歌账户
             Account[] accounts = getGoogleAccounts();
+            //若原账户不为空且账户数量有增加
             if (mOriAccounts != null && accounts.length > mOriAccounts.length) {
+                //遍历 accounts 中的每个帐户
                 for (Account accountNew : accounts) {
+                    //如果没有找到相同名称的账户，就调用setSyncAccount 方法并传入新帐户的名称
                     boolean found = false;
                     for (Account accountOld : mOriAccounts) {
                         if (TextUtils.equals(accountOld.name, accountNew.name)) {
@@ -112,34 +131,44 @@ public class NotesPreferenceActivity extends PreferenceActivity {
                 }
             }
         }
-
+        //刷新UI
         refreshUI();
     }
 
     @Override
+    //摧毁
     protected void onDestroy() {
         if (mReceiver != null) {
-            unregisterReceiver(mReceiver);
+            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
+                        //如果帐户已经设置，我们需要 promp
                         // user about the risk
+                        //展示更改警示对话框
                         showChangeAccountConfirmAlertDialog();
                     }
                 } else {
@@ -150,23 +179,30 @@ public class NotesPreferenceActivity extends PreferenceActivity {
                 return true;
             }
         });
-
+        //最后，将帐户首选项添加到成员变量 mAccountCategory 中
         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
+        // set button stat //设置按钮状态
+        //若在同步状态
         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 {
+            //否则设置同步按钮的文本为立即同步
+            //并为按钮设置一个点击监听器，当用户点击按钮时，监听器会调用 GTaskSyncService.startSync 方法并传入当前活动来开始同步
             syncButton.setText(getString(R.string.preferences_button_sync_immediately));
             syncButton.setOnClickListener(new View.OnClickListener() {
                 public void onClick(View v) {
@@ -177,45 +213,56 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         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) {
+                //若不为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);
 
+        //获取账户
+        //获取账户名称
         Account[] accounts = getGoogleAccounts();
         String defAccount = getSyncAccountName(this);
 
         mOriAccounts = accounts;
         mHasAddedAccount = false;
 
+        //如果账户数量不是0
         if (accounts.length > 0) {
             CharSequence[] items = new CharSequence[accounts.length];
             final CharSequence[] itemMapping = items;
@@ -223,38 +270,48 @@ public class NotesPreferenceActivity extends PreferenceActivity {
             int index = 0;
             for (Account account : accounts) {
                 if (TextUtils.equals(account.name, defAccount)) {
+                    //在账户列表中查询到所需账户
                     checkedItem = index;
                 }
                 items[index++] = account.name;
             }
+            //设置一个单选框
             dialogBuilder.setSingleChoiceItems(items, checkedItem,
+                    //新建一个列表监听器
                     new DialogInterface.OnClickListener() {
                         public void onClick(DialogInterface dialog, int which) {
                             setSyncAccount(itemMapping[which].toString());
-                            dialog.dismiss();
-                            refreshUI();
+                            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) {
+                //账户哈希表置为true
                 mHasAddedAccount = true;
+                //建立网络建立组件
                 Intent intent = new Intent("android.settings.ADD_ACCOUNT_SETTINGS");
                 intent.putExtra(AUTHORITIES_FILTER_KEY, new String[] {
                     "gmail-ls"
                 });
+                //跳回上一个选项
                 startActivityForResult(intent, -1);
                 dialog.dismiss();
             }
         });
     }
 
+    //显示账户选择对话框和相关账户操作
     private void showChangeAccountConfirmAlertDialog() {
+        //创建对话框
         AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
 
         View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
@@ -262,9 +319,12 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         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),
@@ -274,21 +334,25 @@ public class NotesPreferenceActivity extends PreferenceActivity {
             public void onClick(DialogInterface dialog, int which) {
                 if (which == 0) {
                     showSelectAccountAlertDialog();
-                } else if (which == 1) {
+                } else if (which == 1) { //如果witch==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();
@@ -297,12 +361,15 @@ public class NotesPreferenceActivity extends PreferenceActivity {
             } else {
                 editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
             }
+            //提交修改的数据
             editor.commit();
 
             // clean up last sync time
+            //清理上次同步时间
             setLastSyncTime(this, 0);
 
             // clean up local gtask related info
+            // 清理本地 gtask 相关信息
             new Thread(new Runnable() {
                 public void run() {
                     ContentValues values = new ContentValues();
@@ -312,24 +379,31 @@ public class NotesPreferenceActivity extends PreferenceActivity {
                 }
             }).start();
 
+            //将toast的文本信息置为“设置账户成功”并显示出来
             Toast.makeText(NotesPreferenceActivity.this,
                     getString(R.string.preferences_toast_success_set_accout, account),
                     Toast.LENGTH_SHORT).show();
         }
     }
 
+
+    //删除同步账户
     private void removeSyncAccount() {
+        //设置共享首选项
         SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
         SharedPreferences.Editor editor = settings.edit();
-        if (settings.contains(PREFERENCE_SYNC_ACCOUNT_NAME)) {
+        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
+        //清理本地 gtask 相关信息
         new Thread(new Runnable() {
             public void run() {
                 ContentValues values = new ContentValues();
@@ -340,31 +414,38 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         }).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);
     }
 
+    //接受同步信息
     private class GTaskReceiver extends BroadcastReceiver {
 
         @Override
         public void onReceive(Context context, Intent intent) {
             refreshUI();
+            //获取随广播而来的Intent中的同步服务的数据
+            //通过获取的数据在设置系统的状态
             if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {
                 TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
                 syncStatus.setText(intent
@@ -373,7 +454,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
 
         }
     }
-
+    //处理菜单的选项
     public boolean onOptionsItemSelected(MenuItem item) {
         switch (item.getItemId()) {
             case android.R.id.home:

src/Notes-master/app/src/main/java/net/micode/notes/widget/NoteWidgetProvider.java

@@ -14,6 +14,13 @@
  * limitations under the License.
  */
 
+//abcdefgzjhcjrllw
+//123456114514
+
+
+
+
+// 可以修改    //sadadsa
 package net.micode.notes.widget;
 import android.app.PendingIntent;
 import android.appwidget.AppWidgetManager;
@@ -32,6 +39,10 @@ import net.micode.notes.tool.ResourceParser;
 import net.micode.notes.ui.NoteEditActivity;
 import net.micode.notes.ui.NotesListActivity;
 
+
+//这段代码定义了一个名为NoteWidgetProvider的抽象类，它继承自AppWidgetProvider类。
+//NoteWidgetProvider类定义了一个名为PROJECTION的静态字符串数组，它包含三个元素：NoteColumns.ID、NoteColumns.BG_COLOR_ID和NoteColumns.SNIPPET。
+//这些元素可能用于定义查询数据库时需要返回的列。
 public abstract class NoteWidgetProvider extends AppWidgetProvider {
     public static final String [] PROJECTION = new String [] {
         NoteColumns.ID,
@@ -39,6 +50,9 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
         NoteColumns.SNIPPET
     };
 
+//这段代码定义了四个静态常量。前三个常量COLUMN_ID、COLUMN_BG_COLOR_ID和COLUMN_SNIPPET分别被赋值为0、1和2。
+//这些常量可能用于定义查询数据库时需要返回的列的索引。
+//第四个常量TAG被赋值为字符串"NoteWidgetProvider"，它可能用于记录日志时标识日志来源。
     public static final int COLUMN_ID           = 0;
     public static final int COLUMN_BG_COLOR_ID  = 1;
     public static final int COLUMN_SNIPPET      = 2;
@@ -46,6 +60,7 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
     private static final String TAG = "NoteWidgetProvider";
 
     @Override
+    //删除便签程序小部件
     public void onDeleted(Context context, int[] appWidgetIds) {
         ContentValues values = new ContentValues();
         values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
@@ -57,6 +72,7 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
         }
     }
 
+    //获取小部件信息
     private Cursor getNoteWidgetInfo(Context context, int widgetId) {
         return context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
                 PROJECTION,
@@ -65,21 +81,27 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
                 null);
     }
 
+    //更新应用程序小部件
     protected void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
         update(context, appWidgetManager, appWidgetIds, false);
     }
 
+    //更新
     private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds,
             boolean privacyMode) {
+        //遍历所有小部件 ID
         for (int i = 0; i < appWidgetIds.length; i++) {
+            //若有效 获取默认背景 ID 和一个空字符串作为 snippet
             if (appWidgetIds[i] != AppWidgetManager.INVALID_APPWIDGET_ID) {
                 int bgId = ResourceParser.getDefaultBgId(context);
                 String snippet = "";
+                //创建一个指向 NoteEditActivity 的意图
                 Intent intent = new Intent(context, NoteEditActivity.class);
                 intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
                 intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]);
                 intent.putExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, getWidgetType());
 
+                //查询以获取有关该小部件的信息
                 Cursor c = getNoteWidgetInfo(context, appWidgetIds[i]);
                 if (c != null && c.moveToFirst()) {
                     if (c.getCount() > 1) {
@@ -91,7 +113,7 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
                     bgId = c.getInt(COLUMN_BG_COLOR_ID);
                     intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID));
                     intent.setAction(Intent.ACTION_VIEW);
-                } else {
+                } else {//它将 snippet 设置为默认文本，并将意图设置为插入或编辑操作
                     snippet = context.getResources().getString(R.string.widget_havenot_content);
                     intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
                 }
@@ -105,6 +127,7 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
                 intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId);
                 /**
                  * Generate the pending intent to start host for the widget
+                 * 生成为小组件启动主机的挂起意图
                  */
                 PendingIntent pendingIntent = null;
                 if (privacyMode) {
@@ -124,9 +147,12 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
         }
     }
 
+    //获取 Bg 资源标识
     protected abstract int getBgResourceId(int bgId);
 
+    //获取布局标识
     protected abstract int getLayoutId();
 
+    //获取小部件类型
     protected abstract int getWidgetType();
 }

src/Notes-master/app/src/main/java/net/micode/notes/widget/NoteWidgetProvider_2x.java

@@ -27,20 +27,24 @@ import net.micode.notes.tool.ResourceParser;
 public class NoteWidgetProvider_2x extends NoteWidgetProvider {
     @Override
     public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
+        // 调用父类的 update 方法
         super.update(context, appWidgetManager, appWidgetIds);
     }
 
     @Override
     protected int getLayoutId() {
+        //返回布局资源 ID
         return R.layout.widget_2x;
     }
 
     @Override
+    // 调用 ResourceParser.WidgetBgResources 类的静态方法 getWidget2xBgResource
     protected int getBgResourceId(int bgId) {
         return ResourceParser.WidgetBgResources.getWidget2xBgResource(bgId);
     }
 
     @Override
+    //// 返回小部件类型常量
     protected int getWidgetType() {
         return Notes.TYPE_WIDGET_2X;
     }

src/Notes-master/app/src/main/java/net/micode/notes/widget/NoteWidgetProvider_4x.java

@@ -23,6 +23,7 @@ import net.micode.notes.R;
 import net.micode.notes.data.Notes;
 import net.micode.notes.tool.ResourceParser;
 
+//同NoteWidgetProvider_2x
 
 public class NoteWidgetProvider_4x extends NoteWidgetProvider {
     @Override