From 1b1f0e9c8fae38244f3d1b5559073ee901841ee6 Mon Sep 17 00:00:00 2001
From: SYH <1017401752@qq.com>
Date: Tue, 17 Dec 2024 09:25:55 +0800
Subject: [PATCH 01/11] 2

---
 .idea/gradle.xml                              |   2 +-
 .idea/vcs.xml                                 |   6 +
 .../monke/basemvplib/impl/BaseActivity.java   | 108 +++++++++++-------
 .../monke/basemvplib/impl/BaseFragment.java   |  41 ++++---
 .../monke/basemvplib/impl/BaseModelImpl.java  |  27 +++--
 .../basemvplib/impl/BasePresenterImpl.java    |  13 ++-
 .../basemvplib/impl/RetryIntercepter.java     |  20 +++-
 7 files changed, 139 insertions(+), 78 deletions(-)
 create mode 100644 .idea/vcs.xml

diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index 4441641..218206a 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -1,9 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
   <component name="GradleSettings">
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
-        <option name="distributionType" value="DEFAULT_WRAPPED" />
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
         <option name="modules">
           <set>
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 0000000..35eb1dd
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/basemvplib/src/main/java/com/monke/basemvplib/impl/BaseActivity.java b/basemvplib/src/main/java/com/monke/basemvplib/impl/BaseActivity.java
index 731ca71..7ccd6fa 100644
--- a/basemvplib/src/main/java/com/monke/basemvplib/impl/BaseActivity.java
+++ b/basemvplib/src/main/java/com/monke/basemvplib/impl/BaseActivity.java
@@ -1,79 +1,96 @@
+// 定义包名
 package com.monke.basemvplib.impl;
-
-import android.app.ActivityOptions;
-import android.content.Context;
-import android.content.Intent;
-import android.os.Build;
-import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.view.View;
-import com.monke.basemvplib.AppActivityManager;
-import com.monke.basemvplib.IPresenter;
-import com.monke.basemvplib.IView;
+// 导入需要的类和接口
+import android.app.ActivityOptions;// 导入android.app.ActivityOptions类，用于在Android 5.0（Lollipop）及以后的版本中创建Activity之间的转场动画。
+import android.content.Context;// 导入android.content.Context类，这是一个抽象类，提供了一个接口来访问应用程序的全局信息。
+import android.content.Intent;// 导入android.content.Intent类，它是一种携带请求的消息对象，用于在组件之间传递指令
+import android.os.Build;// 导入android.os.Build类，提供了一个接口来访问关于Android构建版本的信息。
+import android.os.Bundle;// 导入android.os.Bundle类，它是一个存储键值对的数据结构，通常用于在Activity、Fragment等组件间传递数据。
+import android.support.annotation.NonNull;// 导入android.support.annotation.NonNull注解，用于标记方法参数或返回值不允许为null。
+import android.view.View;// 导入android.view.View类，它是所有UI组件的基类，代表屏幕上的一个矩形区域。
+import com.monke.basemvplib.AppActivityManager;// 导入com.monke.basemvplib.AppActivityManager类，这是一个管理所有Activity的类，可能用于管理Activity的生命周期等。
+import com.monke.basemvplib.IPresenter;// 导入com.monke.basemvplib.IPresenter接口，它定义了MVP模式中的Presenter层的行为。
+import com.monke.basemvplib.IView;// 导入com.monke.basemvplib.IView接口，它定义了MVP模式中的View层的行为。
+// 导入com.trello.rxlifecycle2.components.support.RxAppCompatActivity类，这是一个支持RxJava生命周期处理的Activity基类。
 import com.trello.rxlifecycle2.components.support.RxAppCompatActivity;
 
+// 定义 BaseActivity 类，它是一个抽象类，用于继承 RxAppCompatActivity 并实现 IView 接口
 public abstract class BaseActivity<T extends IPresenter> extends RxAppCompatActivity implements IView {
+    // 定义一个常量字符串，用于在Intent中传递是否需要启动共享元素动画的标志
     public final static String start_share_ele= "start_with_share_ele";
-    protected Bundle savedInstanceState;
-    protected T mPresenter;
-    private Boolean startShareAnim = false;
+    protected Bundle savedInstanceState;// 定义一个Bundle类型的变量，用于存储保存的实例状态
+    protected T mPresenter;// 定义一个泛型变量mPresenter，用于存储与当前Activity相关联的Presenter
+    private Boolean startShareAnim = false;// 定义一个布尔变量，用于标记是否启动共享元素动画
     @Override
+    // onCreate 方法是 Activity 生命周期中的第一个回调方法，用于初始化 Activity
     protected void onCreate(Bundle savedInstanceState) {
+        // 调用超类的 onCreate 方法
         super.onCreate(savedInstanceState);
+        // 将传入的 savedInstanceState 赋值给成员变量
         this.savedInstanceState = savedInstanceState;
+        // 如果 getIntent() 不为空，则从 Intent 中获取是否需要启动共享元素动画的标志
         if(getIntent()!=null){
             startShareAnim = getIntent().getBooleanExtra(start_share_ele,false);
         }
+        // 将当前 Activity 添加到 AppActivityManager 的管理列表中
         AppActivityManager.getInstance().add(this);
+        // 初始化 SDK
         initSDK();
+        // 调用抽象方法 onCreateActivity，用于设置布局内容
         onCreateActivity();
+        // 调用抽象方法 initInjector，用于初始化 Presenter
         mPresenter = initInjector();
+        // 将 View 绑定到 Presenter
         attachView();
-        initData();
-        bindView();
-        bindEvent();
-        firstRequest();
+        initData();// 调用抽象方法 initData，用于初始化数据
+        bindView();// 调用方法 bindView，用于绑定视图
+        bindEvent();// 调用方法 bindEvent，用于绑定事件
+        firstRequest();// 调用方法 firstRequest，用于执行首次逻辑操作
     }
 
     /**
      * 首次逻辑操作
      */
-    protected void firstRequest() {
+    protected void firstRequest() { // 首次逻辑操作的方法，子类需要根据需要实现具体的逻辑
 
     }
 
     /**
      * 事件触发绑定
      */
-    protected void bindEvent() {
+    protected void bindEvent() {// 事件触发绑定的方法，子类需要根据需要实现具体的事件绑定逻辑
 
     }
 
     /**
      * 控件绑定
      */
-    protected void bindView() {
+    protected void bindView() {// 控件绑定的方法，子类需要根据需要实现具体的控件绑定逻辑
 
     }
 
     /**
      * P层绑定V层
      */
-    private void attachView() {
+    private void attachView() {// P层绑定V层的方法，将 Presenter 和 View 绑定在一起
+        // 如果 mPresenter 不为空，则调用其 attachView 方法，将当前 View 绑定到 Presenter
         if (null != mPresenter) {
             mPresenter.attachView(this);
         }
     }
 
+    // onPause 方法是 Activity 生命周期中的回调方法，当 Activity 不可见时调用
     @Override
     protected void onPause() {
+        // 调用超类的 onPause 方法
         super.onPause();
     }
 
     /**
      * P层解绑V层
      */
-    private void detachView() {
+    private void detachView() {// P层解绑V层的方法，将 Presenter 和 View 解绑
+        // 如果 mPresenter 不为空，则调用其 detachView 方法，将当前 View 从 Presenter 解绑
         if (null != mPresenter) {
             mPresenter.detachView();
         }
@@ -82,7 +99,7 @@ public abstract class BaseActivity<T extends IPresenter> extends RxAppCompatActi
     /**
      * SDK初始化
      */
-    protected void initSDK() {
+    protected void initSDK() {// SDK初始化的方法，子类需要根据需要实现具体的 SDK 初始化逻辑
 
     }
 
@@ -91,64 +108,73 @@ public abstract class BaseActivity<T extends IPresenter> extends RxAppCompatActi
      *
      * @return
      */
-    protected abstract T initInjector();
+    protected abstract T initInjector();// P层绑定的方法，子类需要根据需要实现具体的 Presenter 初始化逻辑，并返回对应的 Presenter 实例
 
     /**
      * 布局载入  setContentView()
      */
-    protected abstract void onCreateActivity();
+    protected abstract void onCreateActivity(); // 布局载入的方法，子类需要根据需要实现具体的布局载入逻辑
 
     /**
      * 数据初始化
      */
-    protected abstract void initData();
+    protected abstract void initData();// 数据初始化的方法，子类需要根据需要实现具体的数据初始化逻辑
 
     @Override
-    protected void onResume() {
-        super.onResume();
+    protected void onResume() {// onResume 方法是 Activity 生命周期中的回调方法，当 Activity 可见时调用
+        super.onResume();// 调用超类的 onResume 方法
     }
 
     @Override
-    protected void onDestroy() {
-        super.onDestroy();
-        detachView();
-        AppActivityManager.getInstance().remove(this);
+    protected void onDestroy() {// onDestroy 方法是 Activity 生命周期中的回调方法，当 Activity 销毁时调用
+        super.onDestroy();// 调用超类的 onDestroy 方法
+        detachView();// 调用 detachView 方法，将 View 从 Presenter 解绑
+        AppActivityManager.getInstance().remove(this);// 将当前 Activity 从 AppActivityManager 的管理列表中移除
     }
 
     ////////////////////////////////启动Activity转场动画/////////////////////////////////////////////
 
-    protected void startActivityForResultByAnim(Intent intent, int requestCode, int animIn, int animExit) {
-        startActivityForResult(intent, requestCode);
-        overridePendingTransition(animIn, animExit);
+    protected void startActivityForResultByAnim(Intent intent, int requestCode, int animIn, int animExit) {// 通过动画启动一个新的 Activity，并指定进入和退出的动画资源 ID
+        startActivityForResult(intent, requestCode);// 调用 startActivityForResult 方法启动新的 Activity，并指定请求码
+        overridePendingTransition(animIn, animExit);// 调用 overridePendingTransition 方法设置进入和退出的动画
     }
 
-    protected void startActivityByAnim(Intent intent, int animIn, int animExit) {
-        startActivity(intent);
-        overridePendingTransition(animIn, animExit);
+    protected void startActivityByAnim(Intent intent, int animIn, int animExit) {// 通过动画启动一个新的 Activity，并指定进入和退出的动画资源 ID
+        startActivity(intent);// 调用 startActivity 方法启动新的 Activity
+        overridePendingTransition(animIn, animExit);// 调用 overridePendingTransition 方法设置进入和退出的动画
     }
 
+    // 通过共享元素动画启动一个新的 Activity，并指定进入和退出的动画资源 ID
     protected void startActivityForResultByAnim(Intent intent, int requestCode, @NonNull View view, @NonNull String transitionName, int animIn, int animExit) {
+        // 如果当前系统版本大于等于 LOLLIPOP，则使用共享元素动画
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+            // 调用 startActivityForResult 方法启动新的 Activity，并指定请求码和共享元素动画的参数
             startActivityForResult(intent, requestCode, ActivityOptions.makeSceneTransitionAnimation(this, view, transitionName).toBundle());
         } else {
+            // 如果当前系统版本小于 LOLLIPOP，则使用普通动画启动 Activity
             startActivityForResultByAnim(intent, requestCode, animIn, animExit);
         }
     }
 
+    // 通过共享元素动画启动一个新的 Activity，并指定进入和退出的动画资源 ID
     protected void startActivityByAnim(Intent intent, @NonNull View view, @NonNull String transitionName, int animIn, int animExit) {
+        // 如果当前系统版本大于等于 LOLLIPOP，则使用共享元素动画
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+            // 将是否需要启动共享元素动画的标志放入 Intent
             intent.putExtra(start_share_ele,true);
+            // 调用 startActivity 方法启动新的 Activity，并指定共享元素动画的参数
             startActivity(intent, ActivityOptions.makeSceneTransitionAnimation(this, view, transitionName).toBundle());
         } else {
+            // 如果当前系统版本小于 LOLLIPOP，则使用普通动画启动 Activity
             startActivityByAnim(intent, animIn, animExit);
         }
     }
 
-    public Context getContext(){
+    public Context getContext(){// 获取当前 Context 对象的方法
         return this;
     }
 
-    public Boolean getStart_share_ele() {
+    public Boolean getStart_share_ele() {// 获取是否需要启动共享元素动画的标志的方法
         return startShareAnim;
     }
 }
\ No newline at end of file
diff --git a/basemvplib/src/main/java/com/monke/basemvplib/impl/BaseFragment.java b/basemvplib/src/main/java/com/monke/basemvplib/impl/BaseFragment.java
index d27f45a..77cbdf7 100644
--- a/basemvplib/src/main/java/com/monke/basemvplib/impl/BaseFragment.java
+++ b/basemvplib/src/main/java/com/monke/basemvplib/impl/BaseFragment.java
@@ -1,67 +1,82 @@
+// 定义包名
 package com.monke.basemvplib.impl;
-
-import android.os.Bundle;
-import android.support.annotation.Nullable;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-import com.monke.basemvplib.IPresenter;
-import com.monke.basemvplib.IView;
+// 导入需要的类和接口
+import android.os.Bundle;// 导入android.os.Bundle类，它是一个存储键值对的数据结构，通常用于在Activity、Fragment等组件间传递数据。
+import android.support.annotation.Nullable;// 导入android.support.annotation.Nullable注解，用于标记方法参数、返回值或字段可以为null。
+import android.view.LayoutInflater;// 导入android.view.LayoutInflater类，它用于在Activity或Fragment中实例化视图。
+import android.view.View;// 导入android.view.View类，它是所有UI组件的基类，代表屏幕上的一个矩形区域。
+import android.view.ViewGroup;// 导入android.view.ViewGroup类，它是一个视图的容器，可以包含其他的View或ViewGroup。
+import com.monke.basemvplib.IPresenter;// 导入com.monke.basemvplib.IPresenter接口，它定义了MVP模式中的Presenter层的行为。
+import com.monke.basemvplib.IView;// 导入com.monke.basemvplib.IView接口，它定义了MVP模式中的View层的行为。
+// 导入com.trello.rxlifecycle2.components.RxFragment类，这是一个支持RxJava生命周期处理的Fragment基类。
 import com.trello.rxlifecycle2.components.RxFragment;
 
+// 定义 BaseFragment 类，它是一个抽象类，用于继承 RxFragment 并实现 IView 接口
 public abstract class BaseFragment<T extends IPresenter> extends RxFragment implements IView{
+    // 定义一个 View 类型的变量，用于存储 Fragment 的视图
     protected View view;
+    // 定义一个 Bundle 类型的变量，用于存储保存的实例状态
     protected Bundle savedInstanceState;
+    // onCreateView 方法是 Fragment 生命周期中的第一个回调方法，用于初始化 Fragment
     @Nullable
     @Override
     public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        // 将传入的 savedInstanceState 赋值给成员变量
         this.savedInstanceState = savedInstanceState;
+        // 初始化第三方 SDK
         initSDK();
+        // 调用抽象方法 createView，用于创建视图
         view = createView(inflater, container);
+        // 调用方法 initData，用于初始化数据
         initData();
+        // 调用方法 bindView，用于绑定视图
         bindView();
+        // 调用方法 bindEvent，用于绑定事件
         bindEvent();
+        // 调用方法 firstRequest，用于执行首次逻辑操作
         firstRequest();
+        // 返回创建的视图
         return view;
     }
 
     /**
      * 事件触发绑定
      */
-    protected void bindEvent() {
+    protected void bindEvent() {// 事件触发绑定的方法，子类需要根据需要实现具体的事件绑定逻辑
 
     }
 
     /**
      * 控件绑定
      */
-    protected void bindView() {
+    protected void bindView() {// 控件绑定的方法，子类需要根据需要实现具体的控件绑定逻辑
 
     }
 
     /**
      * 数据初始化
      */
-    protected void initData() {
+    protected void initData() {// 数据初始化的方法，子类需要根据需要实现具体的数据初始化逻辑
 
     }
 
     /**
      * 首次逻辑操作
      */
-    protected void firstRequest() {
+    protected void firstRequest() { // 首次逻辑操作的方法，子类需要根据需要实现具体的首次逻辑操作
 
     }
 
     /**
      * 加载布局
      */
+    // 加载布局的抽象方法，子类需要根据需要实现具体的布局加载逻辑
     protected abstract View createView(LayoutInflater inflater, ViewGroup container);
 
     /**
      * 第三方SDK初始化
      */
-    protected void initSDK() {
+    protected void initSDK() {// 第三方SDK初始化的方法，子类需要根据需要实现具体的第三方 SDK 初始化逻辑
 
     }
 }
diff --git a/basemvplib/src/main/java/com/monke/basemvplib/impl/BaseModelImpl.java b/basemvplib/src/main/java/com/monke/basemvplib/impl/BaseModelImpl.java
index 36dadbc..56ddc0b 100644
--- a/basemvplib/src/main/java/com/monke/basemvplib/impl/BaseModelImpl.java
+++ b/basemvplib/src/main/java/com/monke/basemvplib/impl/BaseModelImpl.java
@@ -1,5 +1,6 @@
+// 定义包名
 package com.monke.basemvplib.impl;
-
+// 导入所需的类
 import com.monke.basemvplib.EncodoConverter;
 
 import java.util.concurrent.TimeUnit;
@@ -9,31 +10,33 @@ import retrofit2.Retrofit;
 import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;
 import retrofit2.converter.scalars.ScalarsConverterFactory;
 
-public class BaseModelImpl {
-
+public class BaseModelImpl {// 定义 BaseModelImpl 类
+    // 定义一个 OkHttpClient.Builder 类型的保护变量，用于构建 OkHttpClient 实例
     protected OkHttpClient.Builder clientBuilder = new OkHttpClient.Builder()
-            .connectTimeout(10, TimeUnit.SECONDS)
-            .writeTimeout(10, TimeUnit.SECONDS)
-            .readTimeout(10, TimeUnit.SECONDS)
-            .addNetworkInterceptor(new RetryIntercepter(1));
+            .connectTimeout(10, TimeUnit.SECONDS)// 设置连接超时时间为10秒
+            .writeTimeout(10, TimeUnit.SECONDS)// 设置写超时时间为10秒
+            .readTimeout(10, TimeUnit.SECONDS)// 设置读超时时间为10秒
+            .addNetworkInterceptor(new RetryIntercepter(1));// 添加一个网络拦截器，用于重试机制
 
     protected Retrofit getRetrofitObject(String url) {
+        // 创建 Retrofit 实例，设置 baseUrl、转换工厂、调用适配器和客户端
         return new Retrofit.Builder().baseUrl(url)
                 //增加返回值为字符串的支持(以实体类返回)
                 .addConverterFactory(ScalarsConverterFactory.create())
                 //增加返回值为Oservable<T>的支持
                 .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
-                .client(clientBuilder.build())
-                .build();
+                .client(clientBuilder.build())// 设置客户端
+                .build();// 构建 Retrofit 实例
     }
 
     protected Retrofit getRetrofitString(String url, String encode) {
+        // 创建 Retrofit 实例，设置 baseUrl、转换工厂、调用适配器和客户端
         return new Retrofit.Builder().baseUrl(url)
-                //增加返回值为字符串的支持(以实体类返回)
+                //增加返回值为字符串的支持(以实体类返回)，使用自定义的编码转换器
                 .addConverterFactory(EncodoConverter.create(encode))
                 //增加返回值为Oservable<T>的支持
                 .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
-                .client(clientBuilder.build())
-                .build();
+                .client(clientBuilder.build()) // 设置客户端
+                .build();// 构建 Retrofit 实例
     }
 }
\ No newline at end of file
diff --git a/basemvplib/src/main/java/com/monke/basemvplib/impl/BasePresenterImpl.java b/basemvplib/src/main/java/com/monke/basemvplib/impl/BasePresenterImpl.java
index b11479c..5b6c728 100644
--- a/basemvplib/src/main/java/com/monke/basemvplib/impl/BasePresenterImpl.java
+++ b/basemvplib/src/main/java/com/monke/basemvplib/impl/BasePresenterImpl.java
@@ -1,14 +1,17 @@
+// 定义包名
 package com.monke.basemvplib.impl;
+// 导入所需的类和接口
+import android.support.annotation.NonNull;// 导入android.support.annotation.NonNull注解，用于标记方法参数或返回值不允许为null。
+import com.monke.basemvplib.IPresenter;// 导入com.monke.basemvplib.IPresenter接口，它定义了MVP模式中的Presenter层的行为和职责。
+import com.monke.basemvplib.IView;// 导入com.monke.basemvplib.IView接口，它定义了MVP模式中的View层的行为和职责。
 
-import android.support.annotation.NonNull;
-import com.monke.basemvplib.IPresenter;
-import com.monke.basemvplib.IView;
-
-public abstract class BasePresenterImpl<T extends IView> implements IPresenter{
+// 定义 BasePresenterImpl 类，它是一个抽象类，用于实现 IPresenter 接口
+public abstract class BasePresenterImpl<T extends IView> implements IPresenter{// 定义一个泛型变量 mView，它是 IView 接口的子类，用于持有 View 层的引用
     protected T mView;
 
     @Override
     public void attachView(@NonNull IView iView) {
+        // 将传入的 IView 类型参数强制转换为泛型 T 类型，并赋值给 mView
         mView = (T) iView;
     }
 }
diff --git a/basemvplib/src/main/java/com/monke/basemvplib/impl/RetryIntercepter.java b/basemvplib/src/main/java/com/monke/basemvplib/impl/RetryIntercepter.java
index 0966e3d..bcd2c79 100644
--- a/basemvplib/src/main/java/com/monke/basemvplib/impl/RetryIntercepter.java
+++ b/basemvplib/src/main/java/com/monke/basemvplib/impl/RetryIntercepter.java
@@ -1,27 +1,35 @@
+// 定义包名
 package com.monke.basemvplib.impl;
+// 导入所需的类
+import java.io.IOException;// 导入java.io.IOException类，它是所有I/O错误的基类，用于在网络请求过程中捕获和处理I/O异常。
 
-import java.io.IOException;
-
-import okhttp3.Interceptor;
-import okhttp3.Request;
-import okhttp3.Response;
+import okhttp3.Interceptor;// 导入okhttp3.Interceptor类，它是OkHttp库中用于拦截和处理网络请求和响应的接口。
+import okhttp3.Request;// 导入okhttp3.Request类，它表示一个HTTP请求，包括请求方法、URL、头部和正文。
+import okhttp3.Response;// 导入okhttp3.Response类，它表示一个HTTP响应，包括状态码、头部、正文和一个可以关闭连接的方法。
 
+// 定义 RetryIntercepter 类，实现 Interceptor 接口
 public class RetryIntercepter implements Interceptor {
     public int maxRetry;//最大重试次数
     private int retryNum = 0;//假如设置为3次重试的话，则最大可能请求4次（默认1次+3次重试）
 
-    public RetryIntercepter(int maxRetry) {
+    public RetryIntercepter(int maxRetry) {// 构造函数，用于初始化最大重试次数
         this.maxRetry = maxRetry;
     }
 
     @Override
     public Response intercept(Chain chain) throws IOException {
+        // 获取请求对象
         Request request = chain.request();
+        // 执行请求并获取响应
         Response response = chain.proceed(request);
+        // 当响应不成功且重试次数小于最大重试次数时，进行重试
         while (!response.isSuccessful() && retryNum < maxRetry) {
+            // 重试次数加1
             retryNum++;
+            // 再次执行请求
             response = chain.proceed(request);
         }
+        // 返回最终的响应对象
         return response;
     }
 }
-- 
2.34.1


From c7231758ff46dc3cb9ea93dbd702f0fad7d35299 Mon Sep 17 00:00:00 2001
From: SYH <1017401752@qq.com>
Date: Tue, 17 Dec 2024 11:32:52 +0800
Subject: [PATCH 02/11] 2

---
 .../monke/basemvplib/AppActivityManager.java  | 80 ++++++++++++-------
 .../com/monke/basemvplib/BaseApplication.java |  8 +-
 .../com/monke/basemvplib/EncodoConverter.java | 43 ++++++----
 .../java/com/monke/basemvplib/IPresenter.java |  6 +-
 .../main/java/com/monke/basemvplib/IView.java | 11 ++-
 5 files changed, 98 insertions(+), 50 deletions(-)

diff --git a/basemvplib/src/main/java/com/monke/basemvplib/AppActivityManager.java b/basemvplib/src/main/java/com/monke/basemvplib/AppActivityManager.java
index 87e1062..acb476d 100644
--- a/basemvplib/src/main/java/com/monke/basemvplib/AppActivityManager.java
+++ b/basemvplib/src/main/java/com/monke/basemvplib/AppActivityManager.java
@@ -1,5 +1,6 @@
+// 定义包名
 package com.monke.basemvplib;
-
+// 导入所需的类
 import android.app.Activity;
 
 import com.monke.basemvplib.impl.BaseActivity;
@@ -12,18 +13,25 @@ import java.util.List;
  * Activity管理器,管理项目中Activity的状态
  */
 public class AppActivityManager {
-
+    // 使用静态变量存储Activity的弱引用列表，避免内存泄漏
     private static List<WeakReference<Activity>> activities;
 
-    private AppActivityManager(){
-        activities = new ArrayList<>();
+    private AppActivityManager(){// 私有构造函数，确保外部无法直接实例化
+        activities = new ArrayList<>();// 初始化Activity列表
     }
 
+    // 声明一个volatile变量用于保存AppActivityManager的实例，确保线程安全
     private static volatile AppActivityManager instance;
 
+    /**
+     * 获取AppActivityManager的单例对象。
+     * 使用双重检查锁定模式确保线程安全和性能。
+     */
     public static AppActivityManager getInstance(){
+        // 如果instance为空，则进入同步代码块
         if(null == instance){
             synchronized (AppActivityManager.class){
+                // 再次检查instance是否为空，避免多线程同时创建多个实例
                 if(null == instance){
                     instance = new AppActivityManager();
                 }
@@ -32,36 +40,46 @@ public class AppActivityManager {
         return instance;
     }
 
+    /**
+     * 获取Activity列表。
+     * @return 返回Activity的弱引用列表
+     */
     public List<WeakReference<Activity>> getActivities() {
-        return activities;
+        return activities;// 返回存储Activity弱引用的列表
     }
 
     /*
-    添加Activity
+    添加Activity到管理器中
+    @param activity 需要添加的Activity
      */
     public void add(Activity activity){
-        activities.add(new WeakReference<Activity>(activity));
+        activities.add(new WeakReference<Activity>(activity));// 将Activity的弱引用添加到列表中
     }
 
     /*
     移除Activity
+    @param activity 需要移除的Activity
      */
     public void remove(Activity activity){
-        for(WeakReference<Activity> temp :activities){
-            if(null != temp.get() && temp.get() == activity){
-                activities.remove(temp);
-                break;
+        for(WeakReference<Activity> temp :activities){// 遍历活动列表
+            if(null != temp.get() && temp.get() == activity){// 如果找到了对应的Activity
+                activities.remove(temp);// 从列表中移除
+                break;// 结束循环
             }
         }
     }
 
     /*
     移除Activity
+    @param activityClass 需要移除的Activity类
      */
     public void remove(Class<?> activityClass){
         for(Iterator<WeakReference<Activity>> iterator = activities.iterator();iterator.hasNext();){
+            // 获取下一个活动的弱引用
             WeakReference<Activity> item = iterator.next();
+            // 判断是否匹配
             if(null != item && null != item.get() && item.get().getClass() == activityClass){
+                // 移除匹配的Activity
                 iterator.remove();
             }
         }
@@ -69,47 +87,53 @@ public class AppActivityManager {
 
     /*
     关闭指定 activity
+    @param activities 需要关闭的Activity数组
      */
     public void finishActivity(BaseActivity... activities){
-        for(int i=0;i<activities.length;i++){
-            if(null != activities[i]){
-                activities[i].finish();
+        for(int i=0;i<activities.length;i++){// 遍历传入的Activity数组
+            if(null != activities[i]){// 如果Activity不为null
+                activities[i].finish();// 关闭Activity
             }
         }
     }
 
     /*
     关闭指定 activity(class)
+    @param activityClasses 需要关闭的Activity类数组
      */
     public void finishActivity(Class<?>... activityClasses){
+        // 存储待关闭的Activity
         ArrayList<WeakReference<Activity>> waitfinish = new ArrayList<>();
-        for(WeakReference<Activity> temp :activities){
-            for(int i=0;i<activityClasses.length;i++){
-                if(null != temp.get() && temp.get().getClass() == activityClasses[i]){
-                    waitfinish.add(temp);
-                    break;
+        for(WeakReference<Activity> temp :activities){// 遍历当前管理的Activity
+            for(int i=0;i<activityClasses.length;i++){// 遍历需要关闭的Activity类数组
+                if(null != temp.get() && temp.get().getClass() == activityClasses[i]){// 判断是否匹配
+                    waitfinish.add(temp);// 添加到待关闭列表
+                    break;// 结束内层循环
                 }
             }
         }
+        // 遍历待关闭的Activity
         for(WeakReference<Activity> activityWeakReference:waitfinish){
-            if(null != activityWeakReference.get()){
-                activityWeakReference.get().finish();
+            if(null != activityWeakReference.get()){// 如果弱引用有效
+                activityWeakReference.get().finish();// 关闭Activity
             }
         }
     }
 
     /*
     判断指定Activity是否存在
+    param activityClass 需要检查的Activity类
+    @return 是否存在
      */
     public Boolean isExist(Class<?> activityClass){
-        Boolean result = false;
-        for(Iterator<WeakReference<Activity>> iterator = activities.iterator();iterator.hasNext();){
-            WeakReference<Activity> item = iterator.next();
-            if(null != item && null != item.get() && item.get().getClass() == activityClass){
-                result = true;
-                break;
+        Boolean result = false;// 默认不存在
+        for(Iterator<WeakReference<Activity>> iterator = activities.iterator();iterator.hasNext();){// 遍历活动列表
+            WeakReference<Activity> item = iterator.next();// 获取下一个活动的弱引用
+            if(null != item && null != item.get() && item.get().getClass() == activityClass){// 如果找到目标Activity
+                result = true;// 标记为存在
+                break;// 结束循环
             }
         }
-        return result;
+        return result;// 返回是否存在的结果
     }
 }
\ No newline at end of file
diff --git a/basemvplib/src/main/java/com/monke/basemvplib/BaseApplication.java b/basemvplib/src/main/java/com/monke/basemvplib/BaseApplication.java
index f030ad6..e6f4c3e 100644
--- a/basemvplib/src/main/java/com/monke/basemvplib/BaseApplication.java
+++ b/basemvplib/src/main/java/com/monke/basemvplib/BaseApplication.java
@@ -1,10 +1,12 @@
+// 定义包名
 package com.monke.basemvplib;
+// 导入所需的类
+import android.app.Application;// 导入Android框架中的Application类
 
-import android.app.Application;
-
-public class BaseApplication extends Application{
+public class BaseApplication extends Application{//定义一个扩展自Application的基类
     @Override
     public void onCreate() {
+        // 调用父类的方法
         super.onCreate();
     }
 }
\ No newline at end of file
diff --git a/basemvplib/src/main/java/com/monke/basemvplib/EncodoConverter.java b/basemvplib/src/main/java/com/monke/basemvplib/EncodoConverter.java
index 23cde75..e118a02 100644
--- a/basemvplib/src/main/java/com/monke/basemvplib/EncodoConverter.java
+++ b/basemvplib/src/main/java/com/monke/basemvplib/EncodoConverter.java
@@ -1,43 +1,52 @@
+// 定义包名
 package com.monke.basemvplib;
-
-import java.io.IOException;
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Type;
-import java.nio.charset.Charset;
-import okhttp3.ResponseBody;
-import okio.BufferedSource;
-import okio.Okio;
-import retrofit2.Converter;
-import retrofit2.Retrofit;
-
+// 导入所需的类
+import java.io.IOException;// 导入 IOException 类，处理输入输出异常
+import java.lang.annotation.Annotation;// 导入 Annotation 类的定义，使用 Java 反射时需要这个类
+import java.lang.reflect.Type;// 导入 Type 接口，表示 Java 类型的反射信息
+import java.nio.charset.Charset;// 导入 Charset 类，处理字符集
+import okhttp3.ResponseBody;// 导入 OkHttp 库中的 ResponseBody 类，用于处理网络响应体
+import okio.BufferedSource;// 导入 Okio 库中的 BufferedSource 类，用于高效处理流数据
+import okio.Okio;// 导入 Okio 库中的 Okio 类，提供工具方法
+import retrofit2.Converter;// 导入 Retrofit 库中的 Converter 类，为响应转换器提供基类
+import retrofit2.Retrofit;// 导入 Retrofit 库中的 Retrofit 类，表示 Retrofit 的核心类
+
+/**
+ * 自定义 Retrofit 转换器，用于将 ResponseBody 转换为字符串
+ */
 public class EncodoConverter extends Converter.Factory {
-
+    // 默认的编码方式
     private String encode = "utf-8";
 
-    private EncodoConverter(){
+    private EncodoConverter(){// 私有构造函数，禁止无参实例化
 
     }
-    private EncodoConverter(String encode){
+    private EncodoConverter(String encode){// 带编码方式的构造函数
         this.encode = encode;
     }
 
-    public static EncodoConverter create(){
+    public static EncodoConverter create(){// 静态方法，创建默认编码的 EncodoConverter 实例
         return new EncodoConverter();
     }
 
-    public static EncodoConverter create(String en){
+    public static EncodoConverter create(String en){// 静态方法，创建指定编码的 EncodoConverter 实例
         return new EncodoConverter(en);
     }
 
+    // 重写 responseBodyConverter 方法，返回自定义的转换器
     @Override
     public Converter<ResponseBody, String> responseBodyConverter(Type type, Annotation[] annotations,
                                                             Retrofit retrofit) {
+        // 返回一个新的字符串转换器
         return new Converter<ResponseBody, String>() {
+            // 实现转换逻辑
             @Override
             public String convert(ResponseBody value) throws IOException {
+                // 使用 Okio 读取 ResponseBody 数据
                 BufferedSource bufferedSource = Okio.buffer(value.source());
+                // 以指定编码读取字符串
                 String responseData = bufferedSource.readString(Charset.forName(encode));
-                return responseData;
+                return responseData;// 返回读取的字符串
             }
         };
     }
diff --git a/basemvplib/src/main/java/com/monke/basemvplib/IPresenter.java b/basemvplib/src/main/java/com/monke/basemvplib/IPresenter.java
index 80fe36e..7a08088 100644
--- a/basemvplib/src/main/java/com/monke/basemvplib/IPresenter.java
+++ b/basemvplib/src/main/java/com/monke/basemvplib/IPresenter.java
@@ -1,7 +1,11 @@
+// 定义包名
 package com.monke.basemvplib;
-
+// 导入支持库中的 NonNull 注解，用于标记非空参数
 import android.support.annotation.NonNull;
 
+/**
+ * IPresenter 接口，用于定义 Presenter 层的基本行为
+ */
 public interface IPresenter {
     /**
      * 注入View，使之能够与View相互响应
diff --git a/basemvplib/src/main/java/com/monke/basemvplib/IView.java b/basemvplib/src/main/java/com/monke/basemvplib/IView.java
index 667797a..df69a50 100644
--- a/basemvplib/src/main/java/com/monke/basemvplib/IView.java
+++ b/basemvplib/src/main/java/com/monke/basemvplib/IView.java
@@ -1,7 +1,16 @@
+// 定义包名
 package com.monke.basemvplib;
-
+// 导入 Context 类，这是 Android 中的一个基础类，表示应用程序的环境信息
 import android.content.Context;
 
+/**
+ * IView 接口，用于定义 View 层的基本行为
+ */
 public interface IView {
+
+    /**
+     * 获取 Context 对象
+     * @return 当前 View 的上下文
+     */
     public Context getContext();
 }
-- 
2.34.1


From 661f6ab5b74246a40f5af83252db98941d5ea77a Mon Sep 17 00:00:00 2001
From: SYH <1017401752@qq.com>
Date: Tue, 17 Dec 2024 12:54:08 +0800
Subject: [PATCH 03/11] 2

---
 .../monkeybook/dao/BookContentBeanDao.java    |  84 +++++++-------
 .../monke/monkeybook/dao/BookInfoBeanDao.java | 104 +++++++++---------
 .../monkeybook/dao/BookShelfBeanDao.java      |  48 ++++----
 .../monkeybook/dao/ChapterListBeanDao.java    |  76 ++++++-------
 .../com/monke/basemvplib/ApplicationTest.java |  13 ++-
 5 files changed, 164 insertions(+), 161 deletions(-)

diff --git a/app/src/main/java/com/monke/monkeybook/dao/BookContentBeanDao.java b/app/src/main/java/com/monke/monkeybook/dao/BookContentBeanDao.java
index 92c5d2f..d93d879 100644
--- a/app/src/main/java/com/monke/monkeybook/dao/BookContentBeanDao.java
+++ b/app/src/main/java/com/monke/monkeybook/dao/BookContentBeanDao.java
@@ -1,13 +1,13 @@
 //指定了当前类BookContentBeanDao所在的包路径，即com.monke.monkeybook.dao
 package com.monke.monkeybook.dao;
 //导入必要的类，包含GreenDAO、SQLite和Android数据库操作的相关类
-import android.database.Cursor;
-import android.database.sqlite.SQLiteStatement;
-import org.greenrobot.greendao.AbstractDao;
-import org.greenrobot.greendao.Property;
-import org.greenrobot.greendao.internal.DaoConfig;
-import org.greenrobot.greendao.database.Database;
-import org.greenrobot.greendao.database.DatabaseStatement;
+import android.database.Cursor;// 导入Cursor类，用于数据库查询结果
+import android.database.sqlite.SQLiteStatement;// 导入SQLiteStatement类，用于预编译SQL语句
+import org.greenrobot.greendao.AbstractDao;// 导入AbstractDao类，这是GreenDAO的基类，用于实现DAO功能
+import org.greenrobot.greendao.Property;// 导入Property类，用于属性映射
+import org.greenrobot.greendao.internal.DaoConfig;// 导入DaoConfig类，包含DAO的配置
+import org.greenrobot.greendao.database.Database;// 导入Database类，代表数据库操作
+import org.greenrobot.greendao.database.DatabaseStatement;// 导入DatabaseStatement类，用于执行数据库语句
 // 导入实体类 BookContentBean
 import com.monke.monkeybook.bean.BookContentBean;
 
@@ -18,7 +18,7 @@ import com.monke.monkeybook.bean.BookContentBean;
 //继承自GreenDAO的AbstractDao类，BookContentBean为实体类，String为主键类型
 public class BookContentBeanDao extends AbstractDao<BookContentBean, String> {
     //定义常量TABLENAME，表示该表的名称
-    public static final String TABLENAME = "BOOK_CONTENT_BEAN";
+    public static final String TABLENAME = "BOOK_CONTENT_BEAN";// 表名常量
     /**
      * Properties of entity BookContentBean.<br/>
      * Can be used for QueryBuilder and for referencing column names.
@@ -26,10 +26,10 @@ public class BookContentBeanDao extends AbstractDao<BookContentBean, String> {
      */
     // 定义实体类属性映射：对应数据库表字段名的属性
     public static class Properties {
-        public final static Property DurChapterUrl = new Property(0, String.class, "durChapterUrl", true, "DUR_CHAPTER_URL");
-        public final static Property DurChapterIndex = new Property(1, int.class, "durChapterIndex", false, "DUR_CHAPTER_INDEX");
-        public final static Property DurCapterContent = new Property(2, String.class, "durCapterContent", false, "DUR_CAPTER_CONTENT");
-        public final static Property Tag = new Property(3, String.class, "tag", false, "TAG");
+        public final static Property DurChapterUrl = new Property(0, String.class, "durChapterUrl", true, "DUR_CHAPTER_URL");// 章节URL属性
+        public final static Property DurChapterIndex = new Property(1, int.class, "durChapterIndex", false, "DUR_CHAPTER_INDEX");// 章节索引属性
+        public final static Property DurCapterContent = new Property(2, String.class, "durCapterContent", false, "DUR_CAPTER_CONTENT");// 章节内容属性
+        public final static Property Tag = new Property(3, String.class, "tag", false, "TAG");// 标签属性
     };
 
     //构造函数，传入DaoConfig，用于初始化DAO
@@ -51,10 +51,10 @@ public class BookContentBeanDao extends AbstractDao<BookContentBean, String> {
         String constraint = ifNotExists? "IF NOT EXISTS ": "";
         //使用SQL执行表创建语句
         db.execSQL("CREATE TABLE " + constraint + "\"BOOK_CONTENT_BEAN\" (" + //
-                "\"DUR_CHAPTER_URL\" TEXT PRIMARY KEY NOT NULL ," + // 0: durChapterUrl
-                "\"DUR_CHAPTER_INDEX\" INTEGER NOT NULL ," + // 1: durChapterIndex
-                "\"DUR_CAPTER_CONTENT\" TEXT," + // 2: durCapterContent
-                "\"TAG\" TEXT);"); // 3: tag
+                "\"DUR_CHAPTER_URL\" TEXT PRIMARY KEY NOT NULL ," + // 0: durChapterUrl, 主键列
+                "\"DUR_CHAPTER_INDEX\" INTEGER NOT NULL ," + // 1: durChapterIndex, 整数列
+                "\"DUR_CAPTER_CONTENT\" TEXT," + // 2: durCapterContent,章节内容列
+                "\"TAG\" TEXT);"); // 3: tag, 标签列
     }
 
     /** Drops the underlying database table.
@@ -62,73 +62,73 @@ public class BookContentBeanDao extends AbstractDao<BookContentBean, String> {
      */
     public static void dropTable(Database db, boolean ifExists) {
         //使用SQL删除表，确保表存在时删除
-        String sql = "DROP TABLE " + (ifExists ? "IF EXISTS " : "") + "\"BOOK_CONTENT_BEAN\"";
-        db.execSQL(sql);
+        String sql = "DROP TABLE " + (ifExists ? "IF EXISTS " : "") + "\"BOOK_CONTENT_BEAN\"";// 生成删除表的SQL语句
+        db.execSQL(sql);// 执行删除表操作
     }
 
     @Override
     protected final void bindValues(DatabaseStatement stmt, BookContentBean entity) {
         //清除绑定的值，确保每次绑定时都是干净的
-        stmt.clearBindings();
+        stmt.clearBindings();// 清除先前绑定的参数
 
         //绑定durChapterUrl字段到SQL语句的第一个位置
-        String durChapterUrl = entity.getDurChapterUrl();
+        String durChapterUrl = entity.getDurChapterUrl();// 获取durChapterUrl属性值
         if (durChapterUrl != null) {
             //将章节URL字符串绑定到SQL语句的第一个位置
-            stmt.bindString(1, durChapterUrl);
+            stmt.bindString(1, durChapterUrl);// 将durChapterUrl绑定到SQL语句的第一个参数
         }
 
         //绑定durChapterIndex字段到SQL语句的第二个位置
         stmt.bindLong(2, entity.getDurChapterIndex());//将章节索引绑定到SQL语句的第二个位置
 
         //绑定durCapterContent字段到SQL语句的第三个位置
-        String durCapterContent = entity.getDurCapterContent();
+        String durCapterContent = entity.getDurCapterContent();// 获取durCapterContent属性值
         if (durCapterContent != null) {
             //将章节内容绑定到SQL语句的第三个位置
-            stmt.bindString(3, durCapterContent);
+            stmt.bindString(3, durCapterContent);// 将durCapterContent绑定到SQL语句的第三个参数
         }
 
         //绑定tag字段到SQL语句的第四个位置
-        String tag = entity.getTag();
+        String tag = entity.getTag();// 获取tag属性值
         if (tag != null) {
             //将标签绑定到SQL语句的第四个位置
-            stmt.bindString(4, tag);
+            stmt.bindString(4, tag);// 将tag绑定到SQL语句的第四个参数
         }
     }
 
     @Override
     protected final void bindValues(SQLiteStatement stmt, BookContentBean entity) {
         //清除绑定的值，确保每次绑定时都是干净的
-        stmt.clearBindings();
+        stmt.clearBindings();// 清除先前绑定的参数
 
         //绑定durChapterUrl字段到SQL语句的第一个位置
-        String durChapterUrl = entity.getDurChapterUrl();
+        String durChapterUrl = entity.getDurChapterUrl();// 获取durChapterUrl属性值
         if (durChapterUrl != null) {
             //将章节URL字符串绑定到SQL语句的第一个位置
-            stmt.bindString(1, durChapterUrl);
+            stmt.bindString(1, durChapterUrl);// 将durChapterUrl绑定到SQL语句的第一个参数
         }
         //绑定durChapterIndex字段到SQL语句的第二个位置
         stmt.bindLong(2, entity.getDurChapterIndex()); //将章节索引绑定到SQL语句的第二个位置
 
         //绑定durCapterContent字段到SQL语句的第三个位置
-        String durCapterContent = entity.getDurCapterContent();
+        String durCapterContent = entity.getDurCapterContent();// 获取durCapterContent属性值
         if (durCapterContent != null) {
             //将章节内容绑定到SQL语句的第三个位置
-            stmt.bindString(3, durCapterContent);
+            stmt.bindString(3, durCapterContent);// 将durCapterContent绑定到SQL语句的第三个参数
         }
 
         //绑定tag字段到SQL语句的第四个位置
-        String tag = entity.getTag();
+        String tag = entity.getTag();// 获取tag属性值
         if (tag != null) {
             //将标签绑定到SQL语句的第四个位置
-            stmt.bindString(4, tag);
+            stmt.bindString(4, tag);// 将tag绑定到SQL语句的第四个参数
         }
     }
 
     @Override
     public String readKey(Cursor cursor, int offset) {
         //从Cursor中读取主键(durChapterUrl)，若为null则返回null
-        return cursor.isNull(offset + 0) ? null : cursor.getString(offset + 0);
+        return cursor.isNull(offset + 0) ? null : cursor.getString(offset + 0);// 根据游标读取主键值
     }
 
     @Override
@@ -140,38 +140,38 @@ public class BookContentBeanDao extends AbstractDao<BookContentBean, String> {
                 cursor.isNull(offset + 2) ? null : cursor.getString(offset + 2), // durCapterContent
                 cursor.isNull(offset + 3) ? null : cursor.getString(offset + 3) // tag
         );
-        return entity;
+        return entity;// 返回创建的实体对象
     }
 
     @Override
     public void readEntity(Cursor cursor, BookContentBean entity, int offset) {
         //从Cursor中读取值并设置到BookContentBean对象的相应属性中
-        entity.setDurChapterUrl(cursor.isNull(offset + 0) ? null : cursor.getString(offset + 0));
-        entity.setDurChapterIndex(cursor.getInt(offset + 1));
-        entity.setDurCapterContent(cursor.isNull(offset + 2) ? null : cursor.getString(offset + 2));
-        entity.setTag(cursor.isNull(offset + 3) ? null : cursor.getString(offset + 3));
+        entity.setDurChapterUrl(cursor.isNull(offset + 0) ? null : cursor.getString(offset + 0));// 设置durChapterUrl属性
+        entity.setDurChapterIndex(cursor.getInt(offset + 1));// 设置durChapterIndex属性
+        entity.setDurCapterContent(cursor.isNull(offset + 2) ? null : cursor.getString(offset + 2));// 设置durCapterContent属性
+        entity.setTag(cursor.isNull(offset + 3) ? null : cursor.getString(offset + 3));// 设置tag属性
     }
 
     @Override
     protected final String updateKeyAfterInsert(BookContentBean entity, long rowId) {
         //返回更新时需要的主键字段，这里是durChapterUrl
-        return entity.getDurChapterUrl();
+        return entity.getDurChapterUrl();// 返回用于更新的主键
     }
 
     @Override
     public String getKey(BookContentBean entity) {
         //获取实体对象的主键值，返回durChapterUrl
         if(entity != null) {
-            return entity.getDurChapterUrl();
+            return entity.getDurChapterUrl();// 返回实体的主键值
         } else {
-            return null;
+            return null;// 如果实体为空，返回null
         }
     }
 
     @Override
     protected final boolean isEntityUpdateable() {
         //指示实体是否可以被更新，这里返回true，表示支持更新
-        return true;
+        return true;// 表示该实体可被更新
     }
 
 }
diff --git a/app/src/main/java/com/monke/monkeybook/dao/BookInfoBeanDao.java b/app/src/main/java/com/monke/monkeybook/dao/BookInfoBeanDao.java
index ac4edfb..d090565 100644
--- a/app/src/main/java/com/monke/monkeybook/dao/BookInfoBeanDao.java
+++ b/app/src/main/java/com/monke/monkeybook/dao/BookInfoBeanDao.java
@@ -44,12 +44,12 @@ public class BookInfoBeanDao extends AbstractDao<BookInfoBean, String> {
 
     //构造函数，使用DaoConfig配置创建DAO对象
     public BookInfoBeanDao(DaoConfig config) {
-        super(config);
+        super(config);// 调用父类的构造函数，传入DaoConfig配置
     }
 
     //构造函数，使用DaoConfig和DaoSession配置创建DAO对象
     public BookInfoBeanDao(DaoConfig config, DaoSession daoSession) {
-        super(config, daoSession);
+        super(config, daoSession);// 调用父类的构造函数，传入DaoConfig和DaoSession配置
     }
 
     /** Creates the underlying database table.
@@ -85,64 +85,64 @@ public class BookInfoBeanDao extends AbstractDao<BookInfoBean, String> {
     //将BookInfoBean实体对象的值绑定到DatabaseStatement对象中
     protected final void bindValues(DatabaseStatement stmt, BookInfoBean entity) {
         //清除绑定的值，确保每次绑定时都是干净的
-        stmt.clearBindings();
+        stmt.clearBindings();// 清除之前的绑定值
 
         //绑定name字段到SQL语句的第一个位置
-        String name = entity.getName();
+        String name = entity.getName();// 获取name属性值
         if (name != null) {
             //将书名绑定到SQL语句的第一个位置
-            stmt.bindString(1, name);
+            stmt.bindString(1, name);// 将name绑定到SQL语句的第一个位置
         }
 
         //绑定tag字段到SQL语句的第二个位置
-        String tag = entity.getTag();
+        String tag = entity.getTag();// 获取tag属性值
         if (tag != null) {
             //将标签绑定到SQL语句的第二个位置
-            stmt.bindString(2, tag);
+            stmt.bindString(2, tag);// 将tag绑定到SQL语句的第二个位置
         }
 
         //绑定noteUrl字段到SQL语句的第三个位置
-        String noteUrl = entity.getNoteUrl();
+        String noteUrl = entity.getNoteUrl(); // 获取noteUrl属性值
         if (noteUrl != null) {
             //将书籍URL绑定到SQL语句的第三个位置
-            stmt.bindString(3, noteUrl);
+            stmt.bindString(3, noteUrl);// 将noteUrl绑定到SQL语句的第三个位置
         }
 
         //绑定chapterUrl字段到SQL语句的第四个位置
-        String chapterUrl = entity.getChapterUrl();
+        String chapterUrl = entity.getChapterUrl();// 获取chapterUrl属性值
         if (chapterUrl != null) {
             //将章节URL绑定到SQL语句的第四个位置
-            stmt.bindString(4, chapterUrl);
+            stmt.bindString(4, chapterUrl);// 将chapterUrl绑定到SQL语句的第四个位置
         }
         //将最后刷新时间（long 类型）绑定到SQL语句的第五个位置
-        stmt.bindLong(5, entity.getFinalRefreshData());
+        stmt.bindLong(5, entity.getFinalRefreshData()); // 将finalRefreshData绑定到SQL语句的第五个位置
 
         //绑定coverUrl字段到SQL语句的第六个位置
-        String coverUrl = entity.getCoverUrl();
+        String coverUrl = entity.getCoverUrl();// 获取coverUrl属性值
         if (coverUrl != null) {
             //将封面图URL绑定到SQL语句的第六个位置
-            stmt.bindString(6, coverUrl);
+            stmt.bindString(6, coverUrl);// 将coverUrl绑定到SQL语句的第六个位置
         }
 
         //绑定author字段到SQL语句的第七个位置
-        String author = entity.getAuthor();
+        String author = entity.getAuthor();// 获取author属性值
         if (author != null) {
             //将作者绑定到SQL语句的第七个位置
-            stmt.bindString(7, author);
+            stmt.bindString(7, author);// 将author绑定到SQL语句的第七个位置
         }
 
         //绑定introduce字段到SQL语句的第八个位置
-        String introduce = entity.getIntroduce();
+        String introduce = entity.getIntroduce();// 获取introduce属性值
         if (introduce != null) {
             //将简介绑定到SQL语句的第八个位置
-            stmt.bindString(8, introduce);
+            stmt.bindString(8, introduce);// 将introduce绑定到SQL语句的第八个位置
         }
 
         //绑定origin字段到SQL语句的第九个位置
-        String origin = entity.getOrigin();
+        String origin = entity.getOrigin();// 获取origin属性值
         if (origin != null) {
             //将来源绑定到SQL语句的第九个位置
-            stmt.bindString(9, origin);
+            stmt.bindString(9, origin);// 将origin绑定到SQL语句的第九个位置
         }
     }
 
@@ -153,53 +153,53 @@ public class BookInfoBeanDao extends AbstractDao<BookInfoBean, String> {
         stmt.clearBindings();
 
         //绑定name字段值
-        String name = entity.getName();
+        String name = entity.getName();// 获取name属性值
         if (name != null) {
-            stmt.bindString(1, name);
+            stmt.bindString(1, name);// 将name绑定到SQL语句的第一个位置
         }
 
         //绑定tag字段值
-        String tag = entity.getTag();
+        String tag = entity.getTag();// 获取tag属性值
         if (tag != null) {
-            stmt.bindString(2, tag);
+            stmt.bindString(2, tag);// 将tag绑定到SQL语句的第二个位置
         }
 
         //绑定noteUrl字段值
-        String noteUrl = entity.getNoteUrl();
+        String noteUrl = entity.getNoteUrl();// 获取noteUrl属性值
         if (noteUrl != null) {
-            stmt.bindString(3, noteUrl);
+            stmt.bindString(3, noteUrl);// 将noteUrl绑定到SQL语句的第三个位置
         }
 
         //绑定chapterUrl字段值
-        String chapterUrl = entity.getChapterUrl();
+        String chapterUrl = entity.getChapterUrl();// 获取chapterUrl属性值
         if (chapterUrl != null) {
-            stmt.bindString(4, chapterUrl);
+            stmt.bindString(4, chapterUrl);// 将chapterUrl绑定到SQL语句的第四个位置
         }
         //绑定finalRefreshData字段值
-        stmt.bindLong(5, entity.getFinalRefreshData());
+        stmt.bindLong(5, entity.getFinalRefreshData());// 将finalRefreshData绑定到SQL语句的第五个位置
 
         //绑定coverUrl字段值
-        String coverUrl = entity.getCoverUrl();
+        String coverUrl = entity.getCoverUrl();// 获取coverUrl属性值
         if (coverUrl != null) {
-            stmt.bindString(6, coverUrl);
+            stmt.bindString(6, coverUrl);// 将coverUrl绑定到SQL语句的第六个位置
         }
 
         //绑定author字段值
-        String author = entity.getAuthor();
+        String author = entity.getAuthor();// 获取author属性值
         if (author != null) {
-            stmt.bindString(7, author);
+            stmt.bindString(7, author);// 将author绑定到SQL语句的第七个位置
         }
 
         //绑定introduce字段值
-        String introduce = entity.getIntroduce();
+        String introduce = entity.getIntroduce();// 获取introduce属性值
         if (introduce != null) {
-            stmt.bindString(8, introduce);
+            stmt.bindString(8, introduce);// 将introduce绑定到SQL语句的第八个参数
         }
 
         //绑定origin字段值
-        String origin = entity.getOrigin();
+        String origin = entity.getOrigin();// 获取来源属性值
         if (origin != null) {
-            stmt.bindString(9, origin);
+            stmt.bindString(9, origin);// 将来源绑定到SQL语句的第九个参数
         }
     }
 
@@ -207,7 +207,7 @@ public class BookInfoBeanDao extends AbstractDao<BookInfoBean, String> {
     //从Cursor中读取主键
     public String readKey(Cursor cursor, int offset) {
         //主键在第三列(offset + 2)，如果为空返回null，否则返回字符串
-        return cursor.isNull(offset + 2) ? null : cursor.getString(offset + 2);
+        return cursor.isNull(offset + 2) ? null : cursor.getString(offset + 2);// 读取主键noteUrl字段
     }
 
     @Override
@@ -226,28 +226,28 @@ public class BookInfoBeanDao extends AbstractDao<BookInfoBean, String> {
                 cursor.isNull(offset + 8) ? null : cursor.getString(offset + 8) // origin
         );
         //返回创建好的BookInfoBean对象
-        return entity;
+        return entity;// 返回读取到的实体对象
     }
 
     @Override
     //将Cursor中的数据读取到已存在的BookInfoBean实体中
     public void readEntity(Cursor cursor, BookInfoBean entity, int offset) {
-        entity.setName(cursor.isNull(offset + 0) ? null : cursor.getString(offset + 0));//name
-        entity.setTag(cursor.isNull(offset + 1) ? null : cursor.getString(offset + 1));//tag
-        entity.setNoteUrl(cursor.isNull(offset + 2) ? null : cursor.getString(offset + 2));//noteUrl
-        entity.setChapterUrl(cursor.isNull(offset + 3) ? null : cursor.getString(offset + 3));//chapterUrl
-        entity.setFinalRefreshData(cursor.getLong(offset + 4));//finalRefreshData
-        entity.setCoverUrl(cursor.isNull(offset + 5) ? null : cursor.getString(offset + 5));//coverUrl
-        entity.setAuthor(cursor.isNull(offset + 6) ? null : cursor.getString(offset + 6));//author
-        entity.setIntroduce(cursor.isNull(offset + 7) ? null : cursor.getString(offset + 7));//introduce
-        entity.setOrigin(cursor.isNull(offset + 8) ? null : cursor.getString(offset + 8));//origin
+        entity.setName(cursor.isNull(offset + 0) ? null : cursor.getString(offset + 0));//设置name
+        entity.setTag(cursor.isNull(offset + 1) ? null : cursor.getString(offset + 1));//设置tag
+        entity.setNoteUrl(cursor.isNull(offset + 2) ? null : cursor.getString(offset + 2));//设置noteUrl
+        entity.setChapterUrl(cursor.isNull(offset + 3) ? null : cursor.getString(offset + 3));//设置chapterUrl
+        entity.setFinalRefreshData(cursor.getLong(offset + 4));//设置finalRefreshData
+        entity.setCoverUrl(cursor.isNull(offset + 5) ? null : cursor.getString(offset + 5));//设置coverUrl
+        entity.setAuthor(cursor.isNull(offset + 6) ? null : cursor.getString(offset + 6));//设置author
+        entity.setIntroduce(cursor.isNull(offset + 7) ? null : cursor.getString(offset + 7));//设置introduce
+        entity.setOrigin(cursor.isNull(offset + 8) ? null : cursor.getString(offset + 8));//设置origin
     }
 
     @Override
     //插入数据后更新主键
     protected final String updateKeyAfterInsert(BookInfoBean entity, long rowId) {
         //使用noteUrl作为主键
-        return entity.getNoteUrl();
+        return entity.getNoteUrl();// 返回用于更新的主键
     }
 
     @Override
@@ -255,9 +255,9 @@ public class BookInfoBeanDao extends AbstractDao<BookInfoBean, String> {
     public String getKey(BookInfoBean entity) {
         if(entity != null) {
             //返回noteUrl作为主键
-            return entity.getNoteUrl();
+            return entity.getNoteUrl();// 返回实体的主键noteUrl
         } else {
-            return null;
+            return null;// 如果实体为空，返回null
         }
     }
 
@@ -265,7 +265,7 @@ public class BookInfoBeanDao extends AbstractDao<BookInfoBean, String> {
     //是否可更新实体
     protected final boolean isEntityUpdateable() {
         //可更新
-        return true;
+        return true;// 表示该实体可更新
     }
 
 }
diff --git a/app/src/main/java/com/monke/monkeybook/dao/BookShelfBeanDao.java b/app/src/main/java/com/monke/monkeybook/dao/BookShelfBeanDao.java
index b0eb9f3..b2afea4 100644
--- a/app/src/main/java/com/monke/monkeybook/dao/BookShelfBeanDao.java
+++ b/app/src/main/java/com/monke/monkeybook/dao/BookShelfBeanDao.java
@@ -36,12 +36,12 @@ public class BookShelfBeanDao extends AbstractDao<BookShelfBean, String> {
 
     // 构造函数，使用DaoConfig配置初始化Dao
     public BookShelfBeanDao(DaoConfig config) {
-        super(config);
+        super(config);// 调用父类构造函数进行初始化
     }
 
     // 构造函数，使用DaoConfig和DaoSession配置初始化Dao
     public BookShelfBeanDao(DaoConfig config, DaoSession daoSession) {
-        super(config, daoSession);
+        super(config, daoSession);// 调用父类构造函数进行初始化
     }
 
     /** Creates the underlying database table.
@@ -66,27 +66,27 @@ public class BookShelfBeanDao extends AbstractDao<BookShelfBean, String> {
     // 删除BOOK_SHELF_BEAN表的方法
     public static void dropTable(Database db, boolean ifExists) {
         // 构造删除表的SQL语句
-        String sql = "DROP TABLE " + (ifExists ? "IF EXISTS " : "") + "\"BOOK_SHELF_BEAN\"";
+        String sql = "DROP TABLE " + (ifExists ? "IF EXISTS " : "") + "\"BOOK_SHELF_BEAN\"";// 如果指定ifExists，则添加条件
         // 执行SQL语句删除表
-        db.execSQL(sql);
+        db.execSQL(sql);// 执行删除表的SQL语句
     }
 
     @Override
     // 将BookShelfBean实体对象的值绑定到DatabaseStatement语句中
     protected final void bindValues(DatabaseStatement stmt, BookShelfBean entity) {
         // 清除之前的绑定
-        stmt.clearBindings();
+        stmt.clearBindings();// 清除绑定，以保证每次都是干净的
 
-        String noteUrl = entity.getNoteUrl();
+        String noteUrl = entity.getNoteUrl(); // 获取noteUrl属性值
         if (noteUrl != null) {
             // 绑定noteUrl值到第一个参数位置
-            stmt.bindString(1, noteUrl);
+            stmt.bindString(1, noteUrl);// 将noteUrl绑定到SQL语句的第一个位置
         }
         stmt.bindLong(2, entity.getDurChapter()); // 绑定durChapter值到第二个参数位置
         stmt.bindLong(3, entity.getDurChapterPage()); // 绑定durChapterPage值到第三个参数位置
         stmt.bindLong(4, entity.getFinalDate()); // 绑定finalDate值到第四个参数位置
 
-        String tag = entity.getTag();
+        String tag = entity.getTag();// 获取tag属性值
         if (tag != null) {
             stmt.bindString(5, tag); // 绑定tag值到第五个参数位置
         }
@@ -96,21 +96,21 @@ public class BookShelfBeanDao extends AbstractDao<BookShelfBean, String> {
     // 将BookShelfBean实体对象的值绑定到SQLiteStatement语句中，与上一个方法功能类似，只是对象不同
     protected final void bindValues(SQLiteStatement stmt, BookShelfBean entity) {
         // 清除之前的绑定
-        stmt.clearBindings();
+        stmt.clearBindings();// 清除绑定，以保证每次都是干净的
 
-        String noteUrl = entity.getNoteUrl();
+        String noteUrl = entity.getNoteUrl();// 获取noteUrl属性值
         if (noteUrl != null) {
             // 绑定noteUrl值到第一个参数位置
-            stmt.bindString(1, noteUrl);
+            stmt.bindString(1, noteUrl);// 将noteUrl绑定到SQL语句的第一个位置
         }
         stmt.bindLong(2, entity.getDurChapter()); // 绑定durChapter值到第二个参数位置
         stmt.bindLong(3, entity.getDurChapterPage()); // 绑定durChapterPage值到第三个参数位置
         stmt.bindLong(4, entity.getFinalDate()); // 绑定finalDate值到第四个参数位置
 
-        String tag = entity.getTag();
+        String tag = entity.getTag();// 获取tag属性值
         if (tag != null) {
             // 绑定tag值到第五个参数位置
-            stmt.bindString(5, tag);
+            stmt.bindString(5, tag);// 将tag绑定到SQL语句的第五个位置
         }
     }
 
@@ -118,7 +118,7 @@ public class BookShelfBeanDao extends AbstractDao<BookShelfBean, String> {
     // 从游标中读取主键
     public String readKey(Cursor cursor, int offset) {
         // 从偏移量offset+0的位置读取主键值，如果为空返回null，否则返回字符串
-        return cursor.isNull(offset + 0) ? null : cursor.getString(offset + 0);
+        return cursor.isNull(offset + 0) ? null : cursor.getString(offset + 0);// noteUrl是主键
     }
 
     @Override
@@ -133,24 +133,24 @@ public class BookShelfBeanDao extends AbstractDao<BookShelfBean, String> {
                 cursor.isNull(offset + 4) ? null : cursor.getString(offset + 4) // tag
         );
         // 返回创建好的BookShelfBean对象
-        return entity;
+        return entity;// 返回读取到的实体对象
     }
 
     @Override
     // 将游标中的数据读取到已存在的BookShelfBean实体中
     public void readEntity(Cursor cursor, BookShelfBean entity, int offset) {
-        entity.setNoteUrl(cursor.isNull(offset + 0) ? null : cursor.getString(offset + 0)); // noteUrl
-        entity.setDurChapter(cursor.getInt(offset + 1)); // durChapter
-        entity.setDurChapterPage(cursor.getInt(offset + 2)); // durChapterPage
-        entity.setFinalDate(cursor.getLong(offset + 3)); // finalDate
-        entity.setTag(cursor.isNull(offset + 4) ? null : cursor.getString(offset + 4)); // tag
+        entity.setNoteUrl(cursor.isNull(offset + 0) ? null : cursor.getString(offset + 0)); // 设置noteUrl
+        entity.setDurChapter(cursor.getInt(offset + 1)); // 设置durChapter
+        entity.setDurChapterPage(cursor.getInt(offset + 2)); // 设置durChapterPage
+        entity.setFinalDate(cursor.getLong(offset + 3)); // 设置finalDate
+        entity.setTag(cursor.isNull(offset + 4) ? null : cursor.getString(offset + 4)); // 设置tag
     }
 
     @Override
     // 插入数据后更新主键
     protected final String updateKeyAfterInsert(BookShelfBean entity, long rowId) {
         // 返回noteUrl作为主键
-        return entity.getNoteUrl();
+        return entity.getNoteUrl();// 用于更新的主键值
     }
 
     @Override
@@ -158,9 +158,9 @@ public class BookShelfBeanDao extends AbstractDao<BookShelfBean, String> {
     public String getKey(BookShelfBean entity) {
         if(entity != null) {
             // 返回noteUrl作为主键
-            return entity.getNoteUrl();
+            return entity.getNoteUrl();// 返回实体的主键值
         } else {
-            return null;
+            return null;// 如果实体为空，则返回null
         }
     }
 
@@ -168,7 +168,7 @@ public class BookShelfBeanDao extends AbstractDao<BookShelfBean, String> {
     // 判断实体是否可更新
     protected final boolean isEntityUpdateable() {
         // 返回true，表示实体可更新
-        return true;
+        return true;// 该实体类型支持更新
     }
 
 }
diff --git a/app/src/main/java/com/monke/monkeybook/dao/ChapterListBeanDao.java b/app/src/main/java/com/monke/monkeybook/dao/ChapterListBeanDao.java
index fc4de8e..ed45b20 100644
--- a/app/src/main/java/com/monke/monkeybook/dao/ChapterListBeanDao.java
+++ b/app/src/main/java/com/monke/monkeybook/dao/ChapterListBeanDao.java
@@ -11,22 +11,24 @@ import org.greenrobot.greendao.database.Database; // 导入Database类，GreenDa
 import org.greenrobot.greendao.database.DatabaseStatement; // 导入DatabaseStatement类，用于执行SQL语句
 
 // 导入ChapterListBean类，这是数据库操作的对象
-import com.monke.monkeybook.bean.ChapterListBean;
+import com.monke.monkeybook.bean.ChapterListBean;// 导入ChapterListBean实体类
 
 // THIS CODE IS GENERATED BY greenDAO, DO NOT EDIT.
 /**
  * DAO for table "CHAPTER_LIST_BEAN".
+ * 该类是用于操作"CHAPTER_LIST_BEAN"表的DAO类
  */
 // ChapterListBeanDao类继承AbstractDao，操作ChapterListBean对象，主键类型为String
 public class ChapterListBeanDao extends AbstractDao<ChapterListBean, String> {
     // 数据库表名常量
-    public static final String TABLENAME = "CHAPTER_LIST_BEAN";
+    public static final String TABLENAME = "CHAPTER_LIST_BEAN";// 定义常量，表示数据库表的名称
 
     /**
      * Properties of entity ChapterListBean.<br/>
      * Can be used for QueryBuilder and for referencing column names.
      */
     public static class Properties {
+        // 定义实体类属性映射，指向数据库表中的字段
         public final static Property NoteUrl = new Property(0, String.class, "noteUrl", false, "NOTE_URL"); // 属性0：noteUrl，String类型，非主键，数据库列名NOTE_URL
         public final static Property DurChapterIndex = new Property(1, int.class, "durChapterIndex", false, "DUR_CHAPTER_INDEX"); // 属性1：durChapterIndex，int类型，非主键，数据库列名DUR_CHAPTER_INDEX
         public final static Property DurChapterUrl = new Property(2, String.class, "durChapterUrl", true, "DUR_CHAPTER_URL"); // 属性2：durChapterUrl，String类型，主键，数据库列名DUR_CHAPTER_URL
@@ -37,19 +39,19 @@ public class ChapterListBeanDao extends AbstractDao<ChapterListBean, String> {
 
     // 构造函数，使用DaoConfig配置初始化Dao
     public ChapterListBeanDao(DaoConfig config) {
-        super(config);
+        super(config);// 调用父类构造函数初始化DAO对象
     }
 
     // 构造函数，使用DaoConfig和DaoSession配置初始化Dao
     public ChapterListBeanDao(DaoConfig config, DaoSession daoSession) {
-        super(config, daoSession);
+        super(config, daoSession);// 调用父类构造函数初始化DAO对象
     }
 
     /** Creates the underlying database table. */
     // 创建CHAPTER_LIST_BEAN表的方法
     public static void createTable(Database db, boolean ifNotExists) {
         // 根据ifNotExists判断是否需要添加"IF NOT EXISTS"条件
-        String constraint = ifNotExists? "IF NOT EXISTS ": "";
+        String constraint = ifNotExists? "IF NOT EXISTS ": "";// 如果ifNotExists为真，则添加条件
         // 执行SQL语句创建表
         db.execSQL("CREATE TABLE " + constraint + "\"CHAPTER_LIST_BEAN\" (" + //
                 "\"NOTE_URL\" TEXT," + // NOTE_URL字段，TEXT类型
@@ -66,47 +68,47 @@ public class ChapterListBeanDao extends AbstractDao<ChapterListBean, String> {
     // 删除CHAPTER_LIST_BEAN表的方法
     public static void dropTable(Database db, boolean ifExists) {
         // 构造删除表的SQL语句
-        String sql = "DROP TABLE " + (ifExists ? "IF EXISTS " : "") + "\"CHAPTER_LIST_BEAN\"";
+        String sql = "DROP TABLE " + (ifExists ? "IF EXISTS " : "") + "\"CHAPTER_LIST_BEAN\"";// 如果ifExists为真，则加上条件
         // 执行SQL语句删除表
-        db.execSQL(sql);
+        db.execSQL(sql);// 执行删除表的SQL语句
     }
 
     @Override
     // 将ChapterListBean实体对象的值绑定到DatabaseStatement语句中
     protected final void bindValues(DatabaseStatement stmt, ChapterListBean entity) {
         // 清除之前的绑定
-        stmt.clearBindings();
+        stmt.clearBindings();// 确保每次绑定之前清除旧的绑定
 
-        String noteUrl = entity.getNoteUrl();
+        String noteUrl = entity.getNoteUrl();// 获取noteUrl属性值
         if (noteUrl != null) {
             // 绑定noteUrl值到第一个参数位置
-            stmt.bindString(1, noteUrl);
+            stmt.bindString(1, noteUrl);// 将noteUrl绑定到SQL语句的第一个位置
         }
         // 绑定durChapterIndex值到第二个参数位置
-        stmt.bindLong(2, entity.getDurChapterIndex());
+        stmt.bindLong(2, entity.getDurChapterIndex());// 将durChapterIndex绑定到SQL语句的第二个位置
 
-        String durChapterUrl = entity.getDurChapterUrl();
+        String durChapterUrl = entity.getDurChapterUrl();// 获取durChapterUrl属性值
         if (durChapterUrl != null) {
             // 绑定durChapterUrl值到第三个参数位置
-            stmt.bindString(3, durChapterUrl);
+            stmt.bindString(3, durChapterUrl);// 将durChapterUrl绑定到SQL语句的第三个位置
         }
 
-        String durChapterName = entity.getDurChapterName();
+        String durChapterName = entity.getDurChapterName();// 获取durChapterName属性值
         if (durChapterName != null) {
             // 绑定durChapterName值到第四个参数位置
-            stmt.bindString(4, durChapterName);
+            stmt.bindString(4, durChapterName);// 将durChapterName绑定到SQL语句的第四个位置
         }
 
-        String tag = entity.getTag();
+        String tag = entity.getTag();// 获取tag属性值
         if (tag != null) {
             // 绑定tag值到第五个参数位置
-            stmt.bindString(5, tag);
+            stmt.bindString(5, tag);// 将tag绑定到SQL语句的第五个位置
         }
 
-        Boolean hasCache = entity.getHasCache();
+        Boolean hasCache = entity.getHasCache();// 获取hasCache属性值
         if (hasCache != null) {
             // 绑定hasCache值到第六个参数位置，true为1，false为0
-            stmt.bindLong(6, hasCache ? 1L: 0L);
+            stmt.bindLong(6, hasCache ? 1L: 0L);// 将hasCache绑定到SQL语句的第六个位置（布尔值转为整数）
         }
     }
 
@@ -114,38 +116,38 @@ public class ChapterListBeanDao extends AbstractDao<ChapterListBean, String> {
     // 将ChapterListBean实体对象的值绑定到SQLiteStatement语句中，与上一个方法功能类似，只是对象不同
     protected final void bindValues(SQLiteStatement stmt, ChapterListBean entity) {
         // 清除之前的绑定
-        stmt.clearBindings();
+        stmt.clearBindings();// 确保每次绑定之前清除旧的绑定
 
-        String noteUrl = entity.getNoteUrl();
+        String noteUrl = entity.getNoteUrl();// 获取noteUrl属性值
         if (noteUrl != null) {
             // 绑定noteUrl值到第一个参数位置
-            stmt.bindString(1, noteUrl);
+            stmt.bindString(1, noteUrl);// 将noteUrl绑定到SQL语句的第一个位置
         }
         // 绑定durChapterIndex值到第二个参数位置
-        stmt.bindLong(2, entity.getDurChapterIndex());
+        stmt.bindLong(2, entity.getDurChapterIndex());// 将durChapterIndex绑定到SQL语句的第二个位置
 
-        String durChapterUrl = entity.getDurChapterUrl();
+        String durChapterUrl = entity.getDurChapterUrl();// 获取durChapterUrl属性值
         if (durChapterUrl != null) {
             // 绑定durChapterUrl值到第三个参数位置
-            stmt.bindString(3, durChapterUrl);
+            stmt.bindString(3, durChapterUrl);// 将durChapterUrl绑定到SQL语句的第三个位置
         }
 
-        String durChapterName = entity.getDurChapterName();
+        String durChapterName = entity.getDurChapterName();// 获取durChapterName属性值
         if (durChapterName != null) {
             // 绑定durChapterName值到第四个参数位置
-            stmt.bindString(4, durChapterName);
+            stmt.bindString(4, durChapterName);// 将durChapterName绑定到SQL语句的第四个位置
         }
 
-        String tag = entity.getTag();
+        String tag = entity.getTag();// 获取tag属性值
         if (tag != null) {
             // 绑定tag值到第五个参数位置
-            stmt.bindString(5, tag);
+            stmt.bindString(5, tag);// 将tag绑定到SQL语句的第五个位置
         }
 
-        Boolean hasCache = entity.getHasCache();
+        Boolean hasCache = entity.getHasCache();// 获取hasCache属性值
         if (hasCache != null) {
             // 绑定hasCache值到第六个参数位置，true为1，false为0
-            stmt.bindLong(6, hasCache ? 1L: 0L);
+            stmt.bindLong(6, hasCache ? 1L: 0L);// 将hasCache绑定到SQL语句的第六个位置（布尔值转为整数）
         }
     }
 
@@ -153,7 +155,7 @@ public class ChapterListBeanDao extends AbstractDao<ChapterListBean, String> {
     // 从游标中读取主键
     public String readKey(Cursor cursor, int offset) {
         // 从偏移量offset+2的位置读取主键值，如果为空返回null，否则返回字符串
-        return cursor.isNull(offset + 2) ? null : cursor.getString(offset + 2);
+        return cursor.isNull(offset + 2) ? null : cursor.getString(offset + 2);// 返回durChapterUrl作为主键
     }
 
     @Override
@@ -169,7 +171,7 @@ public class ChapterListBeanDao extends AbstractDao<ChapterListBean, String> {
                 cursor.isNull(offset + 5) ? null : cursor.getShort(offset + 5) != 0 // hasCache  将short转换为boolean
         );
         // 返回创建好的ChapterListBean对象
-        return entity;
+        return entity;// 返回读取到的实体对象
     }
 
     @Override
@@ -187,7 +189,7 @@ public class ChapterListBeanDao extends AbstractDao<ChapterListBean, String> {
     // 插入数据后更新主键
     protected final String updateKeyAfterInsert(ChapterListBean entity, long rowId) {
         // 返回durChapterUrl作为主键
-        return entity.getDurChapterUrl();
+        return entity.getDurChapterUrl();// 用于更新的主键值
     }
 
     @Override
@@ -195,9 +197,9 @@ public class ChapterListBeanDao extends AbstractDao<ChapterListBean, String> {
     public String getKey(ChapterListBean entity) {
         if(entity != null) {
             // 返回durChapterUrl作为主键
-            return entity.getDurChapterUrl();
+            return entity.getDurChapterUrl();// 返回实体的主键值
         } else {
-            return null;
+            return null; // 实体为空，返回null
         }
     }
 
@@ -205,7 +207,7 @@ public class ChapterListBeanDao extends AbstractDao<ChapterListBean, String> {
     // 判断实体是否可更新
     protected final boolean isEntityUpdateable() {
         // 返回true，表示实体可更新
-        return true;
+        return true;// 该实体类型支持更新
     }
 
 }
diff --git a/basemvplib/src/androidTest/java/com/monke/basemvplib/ApplicationTest.java b/basemvplib/src/androidTest/java/com/monke/basemvplib/ApplicationTest.java
index 19307d1..0e47272 100644
--- a/basemvplib/src/androidTest/java/com/monke/basemvplib/ApplicationTest.java
+++ b/basemvplib/src/androidTest/java/com/monke/basemvplib/ApplicationTest.java
@@ -1,13 +1,14 @@
+// 声明包名，指明该类属于 com.monke.basemvplib 包
 package com.monke.basemvplib;
-
-import android.app.Application;
-import android.test.ApplicationTestCase;
+// 导入需要的类
+import android.app.Application;// 导入 Android 的 Application 类，使得可以对应用程序进行测试
+import android.test.ApplicationTestCase;// 导入 ApplicationTestCase 类，这是用于测试 Application 的基类
 
 /**
  * <a href="http://d.android.com/tools/testing/testing_android.html">Testing Fundamentals</a>
  */
-public class ApplicationTest extends ApplicationTestCase<Application> {
-    public ApplicationTest() {
-        super(Application.class);
+public class ApplicationTest extends ApplicationTestCase<Application> {// 定义一个公共类 ApplicationTest，继承自 ApplicationTestCase，指定测试的类为 Application
+    public ApplicationTest() {// 定义构造函数
+        super(Application.class);// 调用父类的构造函数，传入 Application.class，告知需要测试的应用类是 Application
     }
 }
\ No newline at end of file
-- 
2.34.1


From 14e4d323657f0a2ec0ed02439418448ebe5e0011 Mon Sep 17 00:00:00 2001
From: SYH <1017401752@qq.com>
Date: Tue, 17 Dec 2024 12:57:34 +0800
Subject: [PATCH 04/11] 2

---
 .../main/res/anim/anim_act_importbook_in.xml  |  6 +++--
 .../main/res/anim/anim_act_importbook_out.xml |  6 +++--
 app/src/main/res/anim/anim_bookshelf_item.xml |  8 +++----
 .../main/res/anim/anim_pop_chapterlist_in.xml |  8 +++----
 .../res/anim/anim_pop_chapterlist_out.xml     | 10 ++++----
 .../res/anim/anim_pop_checkaddshelf_in.xml    | 13 +++++++++--
 .../res/anim/anim_pop_checkaddshelf_out.xml   | 23 +++++++++++--------
 .../main/res/anim/anim_pop_moresetting_in.xml |  9 ++++----
 8 files changed, 50 insertions(+), 33 deletions(-)

diff --git a/app/src/main/res/anim/anim_act_importbook_in.xml b/app/src/main/res/anim/anim_act_importbook_in.xml
index 778ccd0..e39c783 100644
--- a/app/src/main/res/anim/anim_act_importbook_in.xml
+++ b/app/src/main/res/anim/anim_act_importbook_in.xml
@@ -1,7 +1,9 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?> <!-- 声明此 XML 文档的版本和编码格式 -->
 <set xmlns:android="http://schemas.android.com/apk/res/android"
-    android:duration="500">
+    android:duration="500"> <!-- 定义动画的持续时间为500毫秒 -->
     <translate
         android:fromYDelta="100%"
         android:toYDelta="0" />
+    <!-- 动画开始时，Y轴位置为100%（即视图完全在屏幕下方） -->
+    <!-- 动画结束时，Y轴位置为0（即视图返回到其原始位置） -->
 </set>
\ No newline at end of file
diff --git a/app/src/main/res/anim/anim_act_importbook_out.xml b/app/src/main/res/anim/anim_act_importbook_out.xml
index 9715139..3ebb3c5 100644
--- a/app/src/main/res/anim/anim_act_importbook_out.xml
+++ b/app/src/main/res/anim/anim_act_importbook_out.xml
@@ -1,7 +1,9 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?> <!-- 声明此 XML 文档的版本和编码格式 -->
 <set xmlns:android="http://schemas.android.com/apk/res/android"
-    android:duration="500">
+    android:duration="500"> <!-- 动画持续时间为500毫秒 -->
     <translate
         android:fromYDelta="0"
         android:toYDelta="100%" />
+    <!-- 动画开始时视图在 Y 轴的位置为 0（其原始位置） -->
+    <!-- 动画结束时视图在 Y 轴上的位置为其自身高度的 100%（完全下移到视图下方） -->
 </set>
\ No newline at end of file
diff --git a/app/src/main/res/anim/anim_bookshelf_item.xml b/app/src/main/res/anim/anim_bookshelf_item.xml
index 8a20cda..425eba5 100644
--- a/app/src/main/res/anim/anim_bookshelf_item.xml
+++ b/app/src/main/res/anim/anim_bookshelf_item.xml
@@ -1,7 +1,7 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?> <!-- 声明此 XML 文档的版本和编码格式 -->
 <set xmlns:android="http://schemas.android.com/apk/res/android"
-    android:duration="600">
+    android:duration="600"> <!-- 定义整个动画的持续时间为600毫秒 -->
     <translate
-        android:fromYDelta="100%"
-        android:toYDelta="0"/>
+        android:fromYDelta="100%" <!-- 动画开始时，视图在 Y 轴的起始位置为其高度的 100%（即在屏幕底部之外） -->
+        android:toYDelta="0"/> <!-- 动画结束时，视图在 Y 轴的目标位置为 0（即回到其原始位置） -->
 </set>
\ No newline at end of file
diff --git a/app/src/main/res/anim/anim_pop_chapterlist_in.xml b/app/src/main/res/anim/anim_pop_chapterlist_in.xml
index b0bcc5a..a0e26d3 100644
--- a/app/src/main/res/anim/anim_pop_chapterlist_in.xml
+++ b/app/src/main/res/anim/anim_pop_chapterlist_in.xml
@@ -1,6 +1,6 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?> <!-- 声明此 XML 文档的版本和编码格式 -->
 <set xmlns:android="http://schemas.android.com/apk/res/android"
-    android:duration="200">
-    <translate android:fromXDelta="-100%"
-        android:toXDelta="0"/>
+    android:duration="200"> <!-- 定义整个动画的持续时间为200毫秒 -->
+    <translate android:fromXDelta="-100%" <!-- 动画开始时，视图在 X 轴的起始位置为其自身宽度的 -100%（即屏幕左侧之外的不可见位置） -->
+        android:toXDelta="0"/> <!-- 动画结束时，视图在 X 轴的目标位置为0（即回到其原始位置） -->
 </set>
\ No newline at end of file
diff --git a/app/src/main/res/anim/anim_pop_chapterlist_out.xml b/app/src/main/res/anim/anim_pop_chapterlist_out.xml
index 6d294e7..4713bb6 100644
--- a/app/src/main/res/anim/anim_pop_chapterlist_out.xml
+++ b/app/src/main/res/anim/anim_pop_chapterlist_out.xml
@@ -1,6 +1,6 @@
-<?xml version="1.0" encoding="utf-8"?>
-<set xmlns:android="http://schemas.android.com/apk/res/android"
-    android:duration="200">
-    <translate android:fromXDelta="0"
-        android:toXDelta="-100%"/>
+<?xml version="1.0" encoding="utf-8"?><!-- 声明 XML 文档的版本和编码格式 -->
+<set xmlns:android="http://schemas.android.com/apk/res/android"<!-- 定义动画集合，使用 Android 的命名空间 -->
+    android:duration="200"> <!-- 设置动画的持续时间为 200 毫秒 -->
+    <translate android:fromXDelta="0" <!-- 定义平移动画，设置动画的起始 X 坐标变化量为 0 -->
+        android:toXDelta="-100%"/> <!-- 设置动画的结束 X 坐标变化量为 -100%，表示向左移动至视图的左侧 -->
 </set>
\ No newline at end of file
diff --git a/app/src/main/res/anim/anim_pop_checkaddshelf_in.xml b/app/src/main/res/anim/anim_pop_checkaddshelf_in.xml
index 9085b7e..07e6e8a 100644
--- a/app/src/main/res/anim/anim_pop_checkaddshelf_in.xml
+++ b/app/src/main/res/anim/anim_pop_checkaddshelf_in.xml
@@ -1,12 +1,21 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?> <!-- 声明此 XML 文档的版本和编码格式 -->
+<!-- 定义动画集合，使用 Android 的命名空间 -->
 <set xmlns:android="http://schemas.android.com/apk/res/android"
-    android:duration="300">
+    android:duration="300"> <!-- 设置动画的持续时间为 300 毫秒 -->
+    <!-- 定义缩放动画的起始 X 轴缩放比为 0.6 (60%) -->
     <scale android:fromXScale="0.6"
+    <!-- 定义缩放动画的起始 Y 轴缩放比为 0.6 (60%) -->
         android:fromYScale="0.6"
+    <!-- 定义缩放动画的结束 X 轴缩放比为 1.0 (100%) -->
         android:toXScale="1.0"
+    <!-- 定义缩放动画的结束 Y 轴缩放比为 1.0 (100%) -->
         android:toYScale="1.0"
+    <!-- 设置缩放的 X 轴支点位置为视图宽度的 50% (中心点) -->
         android:pivotX="50%"
+    <!-- 设置缩放的 Y 轴支点位置为视图高度的 50% (中心点) -->
         android:pivotY="50%"/>
+    <!-- 定义透明度动画的起始透明度为 0，完全透明 -->
     <alpha android:fromAlpha="0"
+    <!-- 定义透明度动画的结束透明度为 1，不透明 -->
         android:toAlpha="1"/>
 </set>
\ No newline at end of file
diff --git a/app/src/main/res/anim/anim_pop_checkaddshelf_out.xml b/app/src/main/res/anim/anim_pop_checkaddshelf_out.xml
index bd2d3a6..c6161b4 100644
--- a/app/src/main/res/anim/anim_pop_checkaddshelf_out.xml
+++ b/app/src/main/res/anim/anim_pop_checkaddshelf_out.xml
@@ -1,12 +1,15 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?> <!-- 声明此 XML 文档的版本和编码格式 -->
+<!-- 定义动画集合，使用 Android 的命名空间 -->
 <set xmlns:android="http://schemas.android.com/apk/res/android"
-    android:duration="300">
-    <scale android:fromXScale="1.0"
-        android:fromYScale="1.0"
-        android:toXScale="0.6"
-        android:toYScale="0.6"
-        android:pivotX="50%"
-        android:pivotY="50%"/>
-    <alpha android:fromAlpha="1"
-        android:toAlpha="0"/>
+     android:duration="300"> <!-- 设置整个动画的持续时间为 300 毫秒 -->
+
+    <scale android:fromXScale="1.0" <!-- 定义缩放动画的起始 X 轴缩放比为 1.0 (100%) -->
+    android:fromYScale="1.0" <!-- 定义缩放动画的起始 Y 轴缩放比为 1.0 (100%) -->
+    android:toXScale="0.6"   <!-- 定义缩放动画的结束 X 轴缩放比为 0.6 (60%) -->
+    android:toYScale="0.6"   <!-- 定义缩放动画的结束 Y 轴缩放比为 0.6 (60%) -->
+    android:pivotX="50%"     <!-- 设置缩放的 X 轴支点位置为视图宽度的 50% (中心点) -->
+    android:pivotY="50%"/>    <!-- 设置缩放的 Y 轴支点位置为视图高度的 50% (中心点) -->
+
+    <alpha android:fromAlpha="1"  <!-- 定义透明度动画的起始透明度为 1，不透明 -->
+    android:toAlpha="0"/>      <!-- 定义透明度动画的结束透明度为 0，完全透明 -->
 </set>
\ No newline at end of file
diff --git a/app/src/main/res/anim/anim_pop_moresetting_in.xml b/app/src/main/res/anim/anim_pop_moresetting_in.xml
index 161eabc..a92bb3c 100644
--- a/app/src/main/res/anim/anim_pop_moresetting_in.xml
+++ b/app/src/main/res/anim/anim_pop_moresetting_in.xml
@@ -1,6 +1,7 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?> <!-- 声明此 XML 文档的版本和编码格式 -->
+<!-- 定义动画集合，使用 Android 的命名空间 -->
 <set xmlns:android="http://schemas.android.com/apk/res/android"
-    android:duration="200">
-    <translate android:fromXDelta="100%"
-        android:toXDelta="0"/>
+    android:duration="200"> <!-- 设置整个动画的持续时间为 200 毫秒 -->
+    <translate android:fromXDelta="100%" <!-- 定义平移动画的起始位置为视图宽度的 100%（右侧外部） -->
+        android:toXDelta="0"/><!-- 定义平移动画的结束位置为 0，视图移动到它的原始位置 -->
 </set>
\ No newline at end of file
-- 
2.34.1


From b9f3ab7840f8cfa02828fdfd938ef3625e1b69c6 Mon Sep 17 00:00:00 2001
From: SYH <1017401752@qq.com>
Date: Tue, 17 Dec 2024 13:12:20 +0800
Subject: [PATCH 05/11] 2

---
 .../com/monke/monkeybook/dao/DaoMaster.java   | 29 ++++++++++---------
 .../res/anim/anim_pop_moresetting_out.xml     |  7 +++--
 .../main/res/anim/anim_pop_windowlight_in.xml | 10 +++++--
 .../com/monke/monkeybook/ExampleUnitTest.java | 10 +++++--
 4 files changed, 35 insertions(+), 21 deletions(-)

diff --git a/app/src/main/java/com/monke/monkeybook/dao/DaoMaster.java b/app/src/main/java/com/monke/monkeybook/dao/DaoMaster.java
index fa361b4..5c87d8e 100644
--- a/app/src/main/java/com/monke/monkeybook/dao/DaoMaster.java
+++ b/app/src/main/java/com/monke/monkeybook/dao/DaoMaster.java
@@ -20,7 +20,7 @@ import org.greenrobot.greendao.identityscope.IdentityScopeType; // 导入Identit
 // DaoMaster类继承AbstractDaoMaster，是所有DAO的管理者
 public class DaoMaster extends AbstractDaoMaster {
     // 数据库模式版本号
-    public static final int SCHEMA_VERSION = 1;
+    public static final int SCHEMA_VERSION = 1;// 定义常量，表示数据库的版本号
 
     /** Creates underlying database table using DAOs. */
     // 创建所有数据库表的方法
@@ -55,19 +55,20 @@ public class DaoMaster extends AbstractDaoMaster {
         // 创建DaoMaster实例
         DaoMaster daoMaster = new DaoMaster(db);
         // 创建DaoSession实例并返回
-        return daoMaster.newSession();
+        return daoMaster.newSession();// 创建并返回DaoSession
     }
 
     // 构造函数，使用SQLiteDatabase对象初始化DaoMaster
     public DaoMaster(SQLiteDatabase db) {
         // 使用StandardDatabase包装SQLiteDatabase
-        this(new StandardDatabase(db));
+        this(new StandardDatabase(db));// 创建StandardDatabase对象并调用另一个构造函数
     }
 
     // 构造函数，使用Database对象初始化DaoMaster
     public DaoMaster(Database db) {
         // 调用父类的构造函数
         super(db, SCHEMA_VERSION);
+        // 注册所有DAO类，供后续使用
         registerDaoClass(BookContentBeanDao.class); // 注册BookContentBeanDao
         registerDaoClass(BookInfoBeanDao.class); // 注册BookInfoBeanDao
         registerDaoClass(BookShelfBeanDao.class); // 注册BookShelfBeanDao
@@ -78,14 +79,14 @@ public class DaoMaster extends AbstractDaoMaster {
 
     // 创建一个新的DaoSession，使用默认的IdentityScopeType.Session
     public DaoSession newSession() {
-        // 创建DaoSession实例
-        return new DaoSession(db, IdentityScopeType.Session, daoConfigMap);
+        // 创建DaoSession实例，使用Session作用域
+        return new DaoSession(db, IdentityScopeType.Session, daoConfigMap);// 返回新的DaoSession实例
     }
 
     // 创建一个新的DaoSession，使用指定的IdentityScopeType
     public DaoSession newSession(IdentityScopeType type) {
-        // 创建DaoSession实例
-        return new DaoSession(db, type, daoConfigMap);
+        // 创建DaoSession实例，使用指定的作用域类型
+        return new DaoSession(db, type, daoConfigMap);// 返回新的DaoSession实例
     }
 
     /**
@@ -96,21 +97,21 @@ public class DaoMaster extends AbstractDaoMaster {
         // 构造函数，指定上下文和数据库名称
         public OpenHelper(Context context, String name) {
             // 调用父类的构造函数
-            super(context, name, SCHEMA_VERSION);
+            super(context, name, SCHEMA_VERSION);/ 设置上下文、数据库名称和版本号
         }
         // 构造函数，指定上下文、数据库名称和游标工厂
         public OpenHelper(Context context, String name, CursorFactory factory) {
             // 调用父类的构造函数
-            super(context, name, factory, SCHEMA_VERSION);
+            super(context, name, factory, SCHEMA_VERSION);// 设置上下文、数据库名称、游标工厂和版本号
         }
 
         @Override
         // 创建数据库时调用
         public void onCreate(Database db) {
-            // 输出日志信息
+            // 输出日志信息，记录数据库创建事件
             Log.i("greenDAO", "Creating tables for schema version " + SCHEMA_VERSION);
             // 创建所有数据库表
-            createAllTables(db, false);
+            createAllTables(db, false);// 调用创建所有表的方法
         }
     }
 
@@ -120,13 +121,13 @@ public class DaoMaster extends AbstractDaoMaster {
         // 构造函数，指定上下文和数据库名称
         public DevOpenHelper(Context context, String name) {
             // 调用父类的构造函数
-            super(context, name);
+            super(context, name); // 设置上下文和数据库名称
         }
 
         // 构造函数，指定上下文、数据库名称和游标工厂
         public DevOpenHelper(Context context, String name, CursorFactory factory) {
             // 调用父类的构造函数
-            super(context, name, factory);
+            super(context, name, factory);// 设置上下文、数据库名称和游标工厂
         }
 
         @Override
@@ -137,7 +138,7 @@ public class DaoMaster extends AbstractDaoMaster {
             // 删除所有数据库表
             dropAllTables(db, true);
             // 重新创建数据库表
-            onCreate(db);
+            onCreate(db);// 调用创建表的方法
         }
     }
 
diff --git a/app/src/main/res/anim/anim_pop_moresetting_out.xml b/app/src/main/res/anim/anim_pop_moresetting_out.xml
index 10b6138..ad9efbe 100644
--- a/app/src/main/res/anim/anim_pop_moresetting_out.xml
+++ b/app/src/main/res/anim/anim_pop_moresetting_out.xml
@@ -1,6 +1,9 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?> <!-- 声明 XML 版本和编码方式 -->
+<!-- 定义 XML 的命名空间，指定Android属性 -->
 <set xmlns:android="http://schemas.android.com/apk/res/android"
-    android:duration="200">
+    android:duration="200"> <!-- 设置整体动画的持续时间为200毫秒 -->
     <translate android:fromXDelta="0"
         android:toXDelta="100%"/>
+    <!-- 动画开始时的水平偏移量，从0开始 -->
+    <!-- 动画结束时的水平偏移量，移动到视图宽度的100% -->
 </set>
\ No newline at end of file
diff --git a/app/src/main/res/anim/anim_pop_windowlight_in.xml b/app/src/main/res/anim/anim_pop_windowlight_in.xml
index dffa737..83db358 100644
--- a/app/src/main/res/anim/anim_pop_windowlight_in.xml
+++ b/app/src/main/res/anim/anim_pop_windowlight_in.xml
@@ -1,6 +1,7 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?> <!-- 声明 XML 版本和编码方式 -->
+<!-- 定义 XML 的命名空间 -->
 <set xmlns:android="http://schemas.android.com/apk/res/android"
-    android:duration="200">
+    android:duration="200"><!-- 设置整体动画的持续时间为200毫秒 -->
     <!--<translate-->
         <!--android:fromYDelta="100%"-->
         <!--android:toYDelta="0" />-->
@@ -9,4 +10,9 @@
         android:fromXScale="1"
         android:toXScale="1"
         android:pivotY="100%"/>
+    <!-- 动画开始时在Y轴上的缩放比例，初始为0（不可见） -->
+    <!-- 动画结束时在Y轴上的缩放比例，设置为1（正常大小） -->
+    <!-- X轴上的缩放比例保持为1（不缩放） -->
+    <!-- X轴缩放结束时仍然为1（不缩放） -->
+    <!-- 设置缩放的中心点在Y轴的100%位置（底部） -->
 </set>
\ No newline at end of file
diff --git a/app/src/test/java/com/monke/monkeybook/ExampleUnitTest.java b/app/src/test/java/com/monke/monkeybook/ExampleUnitTest.java
index 59cf255..b6a8cdd 100644
--- a/app/src/test/java/com/monke/monkeybook/ExampleUnitTest.java
+++ b/app/src/test/java/com/monke/monkeybook/ExampleUnitTest.java
@@ -1,14 +1,18 @@
+// 声明当前类的包名
 package com.monke.monkeybook;
 
-import org.junit.Test;
-import static org.junit.Assert.*;
+import org.junit.Test; // 导入JUnit的@Test注解，用于标识测试方法
+import static org.junit.Assert.*;// 导入JUnit的断言静态方法，用于验证测试结果
 
 /**
  * To work on unit tests, switch the Test Artifact in the Build Variants view.
+ *该注释说明如何切换测试构件，以在不同的构建变体下运行单元测试。
  */
 public class ExampleUnitTest {
+    // 标识这是一个JUnit测试方法
     @Test
     public void addition_isCorrect() throws Exception {
-        assertEquals(4, 2 + 2);
+        // 使用assertEquals方法检查两个值是否相等
+        assertEquals(4, 2 + 2);// 断言2 + 2的结果应该等于4
     }
 }
\ No newline at end of file
-- 
2.34.1


From 15906f54f7e74e2fc34b59fea07c2429e8885429 Mon Sep 17 00:00:00 2001
From: SYH <1017401752@qq.com>
Date: Tue, 17 Dec 2024 13:25:18 +0800
Subject: [PATCH 06/11] 2

---
 .../com/monke/monkeybook/ApplicationTest.java |  7 ++-
 app/src/main/AndroidManifest.xml              | 57 +++++++++++++------
 .../com/monke/basemvplib/ExampleUnitTest.java | 11 ++--
 3 files changed, 53 insertions(+), 22 deletions(-)

diff --git a/app/src/androidTest/java/com/monke/monkeybook/ApplicationTest.java b/app/src/androidTest/java/com/monke/monkeybook/ApplicationTest.java
index 5fa3869..1da8c98 100644
--- a/app/src/androidTest/java/com/monke/monkeybook/ApplicationTest.java
+++ b/app/src/androidTest/java/com/monke/monkeybook/ApplicationTest.java
@@ -1,12 +1,15 @@
+// 声明包名
 package com.monke.monkeybook;
 
-import android.app.Application;
-import android.test.ApplicationTestCase;
+import android.app.Application;// 导入Application类，代表整个应用程序
+import android.test.ApplicationTestCase;// 导入ApplicationTestCase类，它提供了应用测试的基础
 
 /**
  * <a href="http://d.android.com/tools/testing/testing_android.html">Testing Fundamentals</a>
+ * 该注释提供了一个指向Android测试基础知识的链接
  */
 public class ApplicationTest extends ApplicationTestCase<Application> {
+    // 构造函数，参数为应用程序类的.class文件对象
     public ApplicationTest() {
         super(Application.class);
     }
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index dc84cbe..477b29e 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools"
-    package="com.monke.monkeybook">
+    package="com.monke.monkeybook">  <!-- 声明包名 -->
 
     <application
         android:name=".MApplication"
@@ -12,39 +12,60 @@
         android:theme="@style/CAppTheme"
         tools:replace="android:theme"
         android:networkSecurityConfig="@xml/network_security_config">
+        <!-- 自定义应用程序类 -->
+        <!-- 允许备份 -->
+        <!-- 应用图标 -->
+        <!-- 应用名称 -->
+        <!-- 支持从右向左的布局 -->
+        <!-- 应用主题 -->
+        <!-- 指示工具覆盖主题 -->
+        <!-- 网络安全配置 -->
+
+        <!-- 欢迎界面 -->
         <activity
             android:name=".view.impl.WelcomeActivity"
             android:screenOrientation="portrait">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
+            <!-- 欢迎活动类 -->
+            <!-- 竖屏模式 -->
+            <intent-filter> <!-- 指定启动活动的意图过滤器 -->
+                <action android:name="android.intent.action.MAIN" /><!-- 主活动 -->
 
-                <category android:name="android.intent.category.LAUNCHER" />
+                <category android:name="android.intent.category.LAUNCHER" /><!-- 启动器 -->
             </intent-filter>
         </activity>
+        <!-- 主活动 -->
         <activity
             android:name=".view.impl.MainActivity"
-            android:launchMode="singleTask"
-            android:screenOrientation="portrait" />
+            android:launchMode="singleTask" <!-- 单一任务模式 -->
+            android:screenOrientation="portrait" /><!-- 竖屏模式 -->
+
+
+
+        <!-- 搜索活动 -->
         <activity
             android:name=".view.impl.SearchActivity"
             android:configChanges="locale|keyboardHidden|orientation|screenSize"
             android:screenOrientation="portrait"
             android:theme="@style/CAppTransparentTheme"
-            android:windowSoftInputMode="stateHidden|adjustPan" />
+            android:windowSoftInputMode="stateHidden|adjustPan" /><!-- 软件输入法隐藏时更改视图 -->
 
-        <service android:name=".service.DownloadService" />
+        <service android:name=".service.DownloadService" /><!-- 下载服务 -->
 
+        <!-- 库活动 -->
         <activity
             android:name=".view.impl.LibraryActivity"
             android:screenOrientation="portrait"
             android:theme="@style/CAppTransparentTheme" />
+        <!-- 选择书籍活动 -->
         <activity
             android:name=".view.impl.ChoiceBookActivity"
             android:screenOrientation="portrait" />
+        <!-- 书籍详情活动 -->
         <activity
             android:name=".view.impl.BookDetailActivity"
             android:screenOrientation="portrait"
             android:theme="@style/CAppTransparentTheme" />
+        <!-- 阅读书籍活动 -->
         <activity
             android:name=".view.impl.ReadBookActivity"
             android:launchMode="singleTask"
@@ -52,24 +73,28 @@
             <intent-filter>
                 <action android:name="android.intent.action.VIEW"></action>
                 <category android:name="android.intent.category.DEFAULT"></category>
-                <data android:mimeType="text/plain"></data>
+                <data android:mimeType="text/plain"></data><!-- 处理文本类型数据 -->
             </intent-filter>
         </activity>
+
+        <!-- 导入书籍活动 -->
         <activity
             android:name=".view.impl.ImportBookActivity"
             android:screenOrientation="portrait"
             android:theme="@style/CAppTransparentTheme" />
 
+        <!-- 元数据 -->
         <meta-data
             android:name="UMENG_CHANNEL_VALUE"
-            android:value="${UMENG_CHANNEL_VALUE}" />
+            android:value="${UMENG_CHANNEL_VALUE}" /><!-- 用于第三方渠道的元数据 -->
     </application>
 
-    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
-    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
-    <uses-permission android:name="android.permission.INTERNET" />
-    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
-    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+    <!-- 权限要求 -->
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" /><!-- 读取外部存储权限 -->
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /><!-- 写入外部存储权限 -->
+    <uses-permission android:name="android.permission.INTERNET" /><!-- 访问互联网权限 -->
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /><!-- 访问网络状态权限 -->
+    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" /><!-- 访问Wi-Fi状态权限 -->
 
-    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
+    <uses-permission android:name="android.permission.READ_PHONE_STATE" /><!-- 读取电话状态权限 -->
 </manifest>
\ No newline at end of file
diff --git a/basemvplib/src/test/java/com/monke/basemvplib/ExampleUnitTest.java b/basemvplib/src/test/java/com/monke/basemvplib/ExampleUnitTest.java
index 8e8424d..23a2284 100644
--- a/basemvplib/src/test/java/com/monke/basemvplib/ExampleUnitTest.java
+++ b/basemvplib/src/test/java/com/monke/basemvplib/ExampleUnitTest.java
@@ -1,15 +1,18 @@
+//导入包名
 package com.monke.basemvplib;
 
-import org.junit.Test;
+import org.junit.Test;// 导入JUnit的@Test注解，用于标记测试方法
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.*;// 导入JUnit的断言静态方法，方便在测试中使用各种断言
 
 /**
  * To work on unit tests, switch the Test Artifact in the Build Variants view.
+ * 该注释提示开发者如何切换到合适的测试构件来工作
  */
 public class ExampleUnitTest {
-    @Test
+    @Test  // 使用 @Test 注解标识这个方法是一个测试方法
     public void addition_isCorrect() throws Exception {
-        assertEquals(4, 2 + 2);
+        // 使用assertEquals方法检查两个值是否相等
+        assertEquals(4, 2 + 2);// 断言2 + 2的结果应该等于4
     }
 }
\ No newline at end of file
-- 
2.34.1


From f227258aab4a130a39d82f5401f6ab2ed2bfac91 Mon Sep 17 00:00:00 2001
From: SYH <1017401752@qq.com>
Date: Tue, 17 Dec 2024 13:49:10 +0800
Subject: [PATCH 07/11] 2

---
 .../monkeybook/widget/RecyclerViewBar.java    | 164 +++++++++++-------
 1 file changed, 98 insertions(+), 66 deletions(-)

diff --git a/app/src/main/java/com/monke/monkeybook/widget/RecyclerViewBar.java b/app/src/main/java/com/monke/monkeybook/widget/RecyclerViewBar.java
index 0aa746d..74532fd 100644
--- a/app/src/main/java/com/monke/monkeybook/widget/RecyclerViewBar.java
+++ b/app/src/main/java/com/monke/monkeybook/widget/RecyclerViewBar.java
@@ -1,5 +1,6 @@
+//定义类所在的包路径,表示该文件属于com.monke.monkeybook.widget包
 package com.monke.monkeybook.widget;
-
+// 导入必要的类
 import android.animation.Animator;
 import android.animation.ObjectAnimator;
 import android.annotation.TargetApi;
@@ -24,215 +25,246 @@ import com.monke.monkeybook.R;
 import com.monke.monkeybook.utils.DensityUtil;
 
 public class RecyclerViewBar extends LinearLayout {
+    // 定义滑动动画的时间常量
     public static long SLIDE_ANIM_TIME = 800;
-
+    // 定义滑块的 ImageView
     private ImageView ivSlider;
+    // 定义滑块的高度，默认为 35dp
     private int sliderHeight = DensityUtil.dp2px(getContext(), 35f);
-
+    // 定义 RecyclerView
     private RecyclerView recyclerView;
-
+    // 定义滑块显示和隐藏的动画对象
     private Animator slideIn;
     private Animator slideOut;
 
+    // 构造方法，初始化
     public RecyclerViewBar(Context context) {
         this(context, null);
     }
 
+    // 带有属性集的构造方法
     public RecyclerViewBar(Context context, @Nullable AttributeSet attrs) {
         this(context, attrs, 0);
     }
 
+    // 带有样式属性的构造方法
     public RecyclerViewBar(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
         super(context, attrs, defStyleAttr);
-        init(attrs);
+        init(attrs);// 调用初始化方法
     }
 
+    // 针对 Lollipop 及以上版本的构造方法
     @TargetApi(Build.VERSION_CODES.LOLLIPOP)
     public RecyclerViewBar(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
         super(context, attrs, defStyleAttr, defStyleRes);
-        init(attrs);
+        init(attrs);// 调用初始化方法
     }
 
+    // 初始化方法
     private void init(AttributeSet attrs) {
-        setOrientation(VERTICAL);
+        setOrientation(VERTICAL);// 设置垂直布局
+        // 获取自定义属性
         TypedArray a = getContext().obtainStyledAttributes(attrs, R.styleable.RecyclerViewBar);
+        // 设置滑块高度
         sliderHeight = a.getDimensionPixelSize(R.styleable.RecyclerViewBar_slider_height, sliderHeight);
+        // 设置滑块的左右内边距
         int paddingLeft = a.getDimensionPixelSize(R.styleable.RecyclerViewBar_slider_paddingLeft, 0);
         int paddingRight = a.getDimensionPixelSize(R.styleable.RecyclerViewBar_slider_paddingRight, 0);
+        // 创建滑块 ImageView
         ivSlider = new ImageView(getContext());
-        ivSlider.setPadding(paddingLeft, 0, paddingRight, 0);
-        ivSlider.setAlpha(0f);
-        ivSlider.setClickable(true);
-        addView(ivSlider);
+        ivSlider.setPadding(paddingLeft, 0, paddingRight, 0);// 设置滑块内边距
+        ivSlider.setAlpha(0f);// 初始透明度为 0
+        ivSlider.setClickable(true);// 设置为可点击
+        addView(ivSlider);// 将 ImageView 添加到布局中
+        // 设置滑块的布局参数
         LayoutParams layoutParams = new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, sliderHeight);
-        ivSlider.setLayoutParams(layoutParams);
-        ivSlider.setImageResource(R.drawable.icon_slider);
-        ivSlider.setScaleType(ImageView.ScaleType.FIT_XY);
+        ivSlider.setLayoutParams(layoutParams);// 应用布局参数
+        ivSlider.setImageResource(R.drawable.icon_slider);// 设置滑块图标
+        ivSlider.setScaleType(ImageView.ScaleType.FIT_XY);// 设置图像缩放模式
 
-        initIvSlider();
+        initIvSlider();// 初始化滑块的触摸事件
 
+        // 添加全局布局监听
         RecyclerViewBar.this.getViewTreeObserver().addOnGlobalLayoutListener(layoutInitListener);
     }
 
+    // 用于记录触摸的 final Y 坐标
     private float finalY = -10000;
 
+    // 初始化滑块的触摸事件监听
     private void initIvSlider() {
+        // 设置触摸事件监听器
         ivSlider.setOnTouchListener(new OnTouchListener() {
             @Override
             public boolean onTouch(View v, MotionEvent event) {
-                int action = event.getAction();
+                int action = event.getAction();// 获取触摸事件类型
                 switch (action) {
                     case MotionEvent.ACTION_DOWN:
-                        finalY = event.getY();
-                        return true;
+                        finalY = event.getY();// 记录初始 Y 坐标
+                        return true;// 消耗事件
                     case MotionEvent.ACTION_MOVE:
-                        if (finalY >= 0) {
-                            float tempY = event.getY();
-                            float durY = tempY - finalY;
-                            updateSlider(durY);
+                        if (finalY >= 0) {// 检查是否为合法的 Y 坐标
+                            float tempY = event.getY();// 获取当前 Y 坐标
+                            float durY = tempY - finalY;// 计算移动的距离
+                            updateSlider(durY);// 更新滑块位置
 
-                            showSlide();
+                            showSlide(); // 显示滑块
                         } else {
-                            finalY = event.getY();
+                            finalY = event.getY();// 更新 finalY
                         }
-                        return true;
+                        return true;// 消耗事件
                     case MotionEvent.ACTION_UP:
-                        if (finalY >= 0) {
-                            finalY = -10000;
-                            timeCountDown.cancel();
-                            timeCountDown.start();
-                            return true;
+                        if (finalY >= 0) {// 检查是否为合法的 Y 坐标
+                            finalY = -10000;// 重置 finalY
+                            timeCountDown.cancel();// 取消计时器
+                            timeCountDown.start();// 启动计时器
+                            return true;// 消耗事件
                         }
                         break;
                     default:
                         if (finalY >= 0) {
-                            finalY = -10000;
-                            return true;
+                            finalY = -10000;// 重置 finalY
+                            return true;// 消耗事件
                         }
                         break;
                 }
-                return false;
+                return false;// 未消费事件
             }
         });
     }
 
+    // 更新滑块位置
     private void updateSlider(float durY) {
-        LayoutParams l = (LayoutParams) ivSlider.getLayoutParams();
-        float finalMarginTop = l.topMargin + durY;
+        LayoutParams l = (LayoutParams) ivSlider.getLayoutParams();// 获取滑块的布局参数
+        float finalMarginTop = l.topMargin + durY;// 计算新的顶部边距
+        // 限制滑块的位置
         if (finalMarginTop < 0) {
             finalMarginTop = 0;
         } else if (finalMarginTop > getHeight() - sliderHeight) {
             finalMarginTop = getHeight() - sliderHeight;
         }
+        // 如果 RecyclerView 不为空
         if (recyclerView != null) {
+            // 计算 RecyclerView 的滚动位置
             int position = Math.round(finalMarginTop / (getHeight() - sliderHeight) * (recyclerView.getAdapter().getItemCount() - 1));
-            ((LinearLayoutManager) recyclerView.getLayoutManager()).scrollToPositionWithOffset(position, 0);
+            ((LinearLayoutManager) recyclerView.getLayoutManager()).scrollToPositionWithOffset(position, 0);// 滚动到指定位置
         }
 
-        l.topMargin = Math.round(finalMarginTop);
-        ivSlider.setLayoutParams(l);
+        l.topMargin = Math.round(finalMarginTop);// 更新滑块的顶部边距
+        ivSlider.setLayoutParams(l);// 应用新的布局参数
     }
 
+    // 设置 RecyclerView
     public void setRecyclerView(RecyclerView recyclerView) {
-        this.recyclerView = recyclerView;
+        this.recyclerView = recyclerView;// 保存 RecyclerView 的引用
         if (this.recyclerView != null) {
+            // 添加滚动监听
             this.recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
                 @Override
                 public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
+                    // 如果滚动状态不为停止，则显示滑块
                     super.onScrollStateChanged(recyclerView, newState);
                     if (newState != 0) {
                         showSlide();
                     } else {
-                        timeCountDown.cancel();
-                        timeCountDown.start();
+                        timeCountDown.cancel();// 停止计时器
+                        timeCountDown.start();// 启动计时器
                     }
                 }
 
                 @Override
                 public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
                     super.onScrolled(recyclerView, dx, dy);
+                    // 将滑块滚动到当前可见项目的位置
                     scrollToPositionWithOffset(((LinearLayoutManager) recyclerView.getLayoutManager()).findFirstVisibleItemPosition());
                 }
             });
         }
     }
 
+    // 根据位置滚动并更新滑块位置
     public void scrollToPositionWithOffset(int position) {
+        // 如果 RecyclerView 存在且位置合法
         if (recyclerView != null && position < recyclerView.getAdapter().getItemCount()) {
             float temp = position * 1.0f / recyclerView.getAdapter().getItemCount();
-            LayoutParams l = (LayoutParams) ivSlider.getLayoutParams();
-            l.topMargin = Math.round(((getHeight() - sliderHeight) * temp));
-            ivSlider.setLayoutParams(l);
+            LayoutParams l = (LayoutParams) ivSlider.getLayoutParams();// 获取滑块的布局参数
+            l.topMargin = Math.round(((getHeight() - sliderHeight) * temp));// 计算新的顶部边距
+            ivSlider.setLayoutParams(l);// 应用新的布局参数
         }
     }
 
+    // 显示滑块
     private void showSlide() {
-        if (ivSlider.getAlpha() < 1) {
+        if (ivSlider.getAlpha() < 1) {// 如果透明度小于1
             if (slideOut != null && slideOut.isRunning()) {
-                slideOut.cancel();
+                slideOut.cancel();// 如果滑出动画正在执行，取消它
             }
             if (slideIn == null) {
-                slideIn = ObjectAnimator.ofFloat(ivSlider, "alpha", ivSlider.getAlpha(), 1f);
-                slideIn.setDuration((long) (SLIDE_ANIM_TIME * (1f - ivSlider.getAlpha())));
+                slideIn = ObjectAnimator.ofFloat(ivSlider, "alpha", ivSlider.getAlpha(), 1f);// 创建滑入动画
+                slideIn.setDuration((long) (SLIDE_ANIM_TIME * (1f - ivSlider.getAlpha())));// 设置动画持续时间
             }
             if (!slideIn.isRunning()) {
-                slideIn.start();
+                slideIn.start();// 启动滑入动画
             }
         }
     }
-
+    // 隐藏滑块
     private void hideSlide() {
-        if (ivSlider.getAlpha() > 0) {
+        if (ivSlider.getAlpha() > 0) {// 如果透明度大于0
             if (slideIn != null && slideIn.isRunning()) {
-                slideIn.cancel();
+                slideIn.cancel();// 如果滑入动画正在执行，取消它
             }
             if (slideOut == null) {
-                slideOut = ObjectAnimator.ofFloat(ivSlider, "alpha", ivSlider.getAlpha(), 0f);
-                slideOut.setDuration((long) (SLIDE_ANIM_TIME * ivSlider.getAlpha()));
+                slideOut = ObjectAnimator.ofFloat(ivSlider, "alpha", ivSlider.getAlpha(), 0f);// 创建滑出动画
+                slideOut.setDuration((long) (SLIDE_ANIM_TIME * ivSlider.getAlpha()));// 设置动画持续时间
             }
             if (!slideOut.isRunning()) {
-                slideOut.start();
+                slideOut.start();// 启动滑出动画
             }
         }
     }
 
+    // 创建计时器，用于滑块的自动隐藏
     private TimeCountDown timeCountDown = new TimeCountDown();
 
+    // 定义倒计时类
     class TimeCountDown extends CountDownTimer {
-
+        // 构造方法，设置计时器
         public TimeCountDown() {
-            this(1000, 1000);
+            this(1000, 1000);// 1000 毫秒后完成，间隔 1000 毫秒
         }
 
         public TimeCountDown(long millisInFuture, long countDownInterval) {
-            super(millisInFuture, countDownInterval);
+            super(millisInFuture, countDownInterval);// 调用父类构造方法
         }
 
         @Override
         public void onTick(long millisUntilFinished) {
-
+            // 每次计时器滴答时调用（可选实现，暂时为空）
         }
 
         @Override
         public void onFinish() {
-            hideSlide();
+            hideSlide();// 计时结束时隐藏滑块
         }
     }
 
+    // 用于存储视图的高度
     private int height = 0;
+    // 全局布局监听器
     private ViewTreeObserver.OnGlobalLayoutListener layoutInitListener = new ViewTreeObserver.OnGlobalLayoutListener() {
         @Override
         public void onGlobalLayout() {
-            if(getHeight()>0){
+            if(getHeight()>0){// 确保当前高度大于0
                 if (height == 0) {
-                    height = getHeight();
+                    height = getHeight();// 保存初始高度
                 } else {
-                    int diff = height -  getHeight();
+                    int diff = height -  getHeight();// 计算高度差
                     if (diff != 0) {
-                        LayoutParams l = (LayoutParams) ivSlider.getLayoutParams();
+                        LayoutParams l = (LayoutParams) ivSlider.getLayoutParams();// 获取滑块的布局参数
                         l.topMargin = (int) ((l.topMargin*1.0f/(height-sliderHeight))*(getHeight()-sliderHeight));
-                        ivSlider.setLayoutParams(l);
-                        height = getHeight();
+                        ivSlider.setLayoutParams(l);// 更新滑块的顶部边距
+                        height = getHeight();// 更新高度
                     }
                 }
             }
-- 
2.34.1


From eb5e25ced8623278759b3f3804e4af7226973b12 Mon Sep 17 00:00:00 2001
From: SYH <1017401752@qq.com>
Date: Tue, 17 Dec 2024 14:11:41 +0800
Subject: [PATCH 08/11] 2

---
 .../monkeybook/widget/ChapterListView.java    | 185 +++++++++---------
 .../monke/monkeybook/widget/MTextView.java    |  36 ++--
 .../monkeybook/widget/RecyclerViewBar.java    |  42 ++--
 3 files changed, 138 insertions(+), 125 deletions(-)

diff --git a/app/src/main/java/com/monke/monkeybook/widget/ChapterListView.java b/app/src/main/java/com/monke/monkeybook/widget/ChapterListView.java
index c6e8840..a872e47 100644
--- a/app/src/main/java/com/monke/monkeybook/widget/ChapterListView.java
+++ b/app/src/main/java/com/monke/monkeybook/widget/ChapterListView.java
@@ -1,40 +1,42 @@
+// 定义包名
 package com.monke.monkeybook.widget;
 
-import android.annotation.TargetApi;
-import android.content.Context;
-import android.os.Build;
-import android.support.annotation.AttrRes;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-import android.support.annotation.StyleRes;
-import android.support.v7.widget.LinearLayoutManager;
-import android.support.v7.widget.RecyclerView;
-import android.util.AttributeSet;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.animation.Animation;
-import android.view.animation.AnimationUtils;
-import android.widget.FrameLayout;
-import android.widget.LinearLayout;
-import android.widget.TextView;
-import com.monke.monkeybook.R;
-import com.monke.monkeybook.bean.BookShelfBean;
-import com.monke.monkeybook.view.adapter.ChapterListAdapter;
-
-public class ChapterListView extends FrameLayout{
-    private TextView tvName;
-    private TextView tvListCount;
-    private RecyclerView rvList;
-    private RecyclerViewBar rvbSlider;
-
-    private FrameLayout flBg;
-    private LinearLayout llContent;
-
-    private ChapterListAdapter chapterListAdapter;
-
-    private Animation animIn;
-    private Animation animOut;
-
+import android.annotation.TargetApi;// 导入 TargetApi 注解，标明特定的 API 级别
+import android.content.Context;// 导入 Context 类，提供应用的上下文
+import android.os.Build;// 导入 Build 类，用于获取当前 Android 版本信息
+import android.support.annotation.AttrRes; // 导入 AttrRes 注解，表示属性资源的类型。
+import android.support.annotation.NonNull;// 导入 NonNull 注解，表示不允许为 null。
+import android.support.annotation.Nullable;// 导入 Nullable 注解，表示可以为 null。
+import android.support.annotation.StyleRes;// 导入 StyleRes 注解，表示样式资源的类型。
+import android.support.v7.widget.LinearLayoutManager;// 导入 LinearLayoutManager，用于 RecyclerView 的线性布局。
+import android.support.v7.widget.RecyclerView;// 导入 RecyclerView 类，适用于高效的列表展示。
+import android.util.AttributeSet;// 导入 AttributeSet 类，用于访问 XML 布局中的自定义属性。
+import android.view.LayoutInflater;// 导入 LayoutInflater 类，用于将布局文件转换为 View 对象。
+import android.view.View;// 导入 View 类，所有 UI 控件的基类。
+import android.view.animation.Animation;// 导入 Animation 类，用于创建动画效果。
+import android.view.animation.AnimationUtils;// 导入 AnimationUtils 类，提供加载动画资源的方法。
+import android.widget.FrameLayout;// 导入 FrameLayout 类，允许堆叠子视图的布局。
+import android.widget.LinearLayout; // 导入 LinearLayout 类，允许在垂直或水平方向上排列子视图。
+import android.widget.TextView;// 导入 TextView 类，用于显示文本。
+import com.monke.monkeybook.R;// 导入应用资源类，访问资源文件。
+import com.monke.monkeybook.bean.BookShelfBean;// 导入 BookShelfBean 类，书架数据模型。
+import com.monke.monkeybook.view.adapter.ChapterListAdapter;// 导入 ChapterListAdapter 类，章节列表适配器。
+
+public class ChapterListView extends FrameLayout{// 创建 ChapterListView 类，继承自 FrameLayout
+    private TextView tvName;// 显示书名的 TextView
+    private TextView tvListCount;// 显示章节数量的 TextView
+    private RecyclerView rvList;// 显示章节列表的 RecyclerView
+    private RecyclerViewBar rvbSlider;// 自定义的 RecyclerView 导航条
+
+    private FrameLayout flBg;// 背景 FrameLayout
+    private LinearLayout llContent;// 内容 LinearLayout
+
+    private ChapterListAdapter chapterListAdapter;// 章节列表适配器
+
+    private Animation animIn; // 动画进入效果
+    private Animation animOut; // 动画退出效果
+
+    // 构造函数
     public ChapterListView(@NonNull Context context) {
         this(context,null);
     }
@@ -45,36 +47,37 @@ public class ChapterListView extends FrameLayout{
 
     public ChapterListView(@NonNull Context context, @Nullable AttributeSet attrs, @AttrRes int defStyleAttr) {
         super(context, attrs, defStyleAttr);
-        init();
+        init();// 调用初始化方法
     }
 
-    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+    @TargetApi(Build.VERSION_CODES.LOLLIPOP)// 指示支持 API 21 及以上
     public ChapterListView(@NonNull Context context, @Nullable AttributeSet attrs, @AttrRes int defStyleAttr, @StyleRes int defStyleRes) {
         super(context, attrs, defStyleAttr, defStyleRes);
-        init();
+        init();// 调用初始化方法
     }
 
     private void init() {
-        setVisibility(INVISIBLE);
-        LayoutInflater.from(getContext()).inflate(R.layout.view_chapterlist,this,true);
-        initData();
-        initView();
+        setVisibility(INVISIBLE);// 默认隐藏视图
+        LayoutInflater.from(getContext()).inflate(R.layout.view_chapterlist, this, true); // 加载布局
+        initData(); // 初始化数据
+        initView(); // 初始化视图组件
     }
 
+    // 初始化数据和动画
     private void initData() {
         animIn = AnimationUtils.loadAnimation(getContext(),R.anim.anim_pop_chapterlist_in);
         animIn.setAnimationListener(new Animation.AnimationListener() {
             @Override
             public void onAnimationStart(Animation animation) {
-                flBg.setOnClickListener(null);
+                flBg.setOnClickListener(null);// 动画开始时禁止点击
             }
 
             @Override
             public void onAnimationEnd(Animation animation) {
-                flBg.setOnClickListener(new OnClickListener() {
+                flBg.setOnClickListener(new OnClickListener() {// 动画结束后允许点击
                     @Override
                     public void onClick(View v) {
-                        dimissChapterList();
+                        dimissChapterList();// 点击背景时关闭章节列表
                     }
                 });
             }
@@ -84,17 +87,17 @@ public class ChapterListView extends FrameLayout{
 
             }
         });
-        animOut = AnimationUtils.loadAnimation(getContext(),R.anim.anim_pop_chapterlist_out);
+        animOut = AnimationUtils.loadAnimation(getContext(),R.anim.anim_pop_chapterlist_out);// 退出动画
         animOut.setAnimationListener(new Animation.AnimationListener() {
             @Override
             public void onAnimationStart(Animation animation) {
-                flBg.setOnClickListener(null);
+                flBg.setOnClickListener(null);// 动画开始时禁止点击
             }
 
             @Override
             public void onAnimationEnd(Animation animation) {
-                llContent.setVisibility(INVISIBLE);
-                setVisibility(INVISIBLE);
+                llContent.setVisibility(INVISIBLE); // 隐藏内容
+                setVisibility(INVISIBLE); // 隐藏视图
             }
 
             @Override
@@ -104,61 +107,61 @@ public class ChapterListView extends FrameLayout{
         });
     }
 
-    public void show(int durChapter) {
-        chapterListAdapter.setIndex(durChapter);
-        ((LinearLayoutManager) rvList.getLayoutManager()).scrollToPositionWithOffset(durChapter,0);
-        if(getVisibility()!=VISIBLE){
-            setVisibility(VISIBLE);
-            animOut.cancel();
-            animIn.cancel();
-            llContent.setVisibility(VISIBLE);
-            llContent.startAnimation(animIn);
+    public void show(int durChapter) { // 显示章节列表
+        chapterListAdapter.setIndex(durChapter); // 设置当前章节索引
+        ((LinearLayoutManager) rvList.getLayoutManager()).scrollToPositionWithOffset(durChapter, 0); // 滚动到特定章节
+        if(getVisibility() != VISIBLE) {
+            setVisibility(VISIBLE); // 显示章节列表
+            animOut.cancel(); // 取消退出动画
+            animIn.cancel(); // 取消进入动画
+            llContent.setVisibility(VISIBLE); // 显示内容
+            llContent.startAnimation(animIn); // 开始进入动画
         }
     }
 
-    public interface OnItemClickListener{
-        public void itemClick(int index);
+    public interface OnItemClickListener{// 点击监听接口
+        public void itemClick(int index);// 点击事件方法
     }
-    private OnItemClickListener itemClickListener;
-    private BookShelfBean bookShelfBean;
-
-    private void initView() {
-        flBg = (FrameLayout) findViewById(R.id.fl_bg);
-        llContent = (LinearLayout) findViewById(R.id.ll_content);
-        tvName = (TextView) findViewById(R.id.tv_name);
-        tvListCount = (TextView) findViewById(R.id.tv_listcount);
-        rvList = (RecyclerView) findViewById(R.id.rv_list);
-        rvList.setLayoutManager(new LinearLayoutManager(getContext()));
-        rvList.setItemAnimator(null);
-        rvbSlider = (RecyclerViewBar) findViewById(R.id.rvb_slider);
+    private OnItemClickListener itemClickListener; // 监听器实例
+    private BookShelfBean bookShelfBean; // 书架数据类实例
+
+    private void initView() { // 初始化视图组件
+        flBg = (FrameLayout) findViewById(R.id.fl_bg); // 获取背景 FrameLayout
+        llContent = (LinearLayout) findViewById(R.id.ll_content); // 获取内容 LinearLayout
+        tvName = (TextView) findViewById(R.id.tv_name); // 获取书名 TextView
+        tvListCount = (TextView) findViewById(R.id.tv_listcount); // 获取章节数量 TextView
+        rvList = (RecyclerView) findViewById(R.id.rv_list); // 获取章节列表 RecyclerView
+        rvList.setLayoutManager(new LinearLayoutManager(getContext())); // 设置布局管理器
+        rvList.setItemAnimator(null); // 关闭动画效果
+        rvbSlider = (RecyclerViewBar) findViewById(R.id.rvb_slider); // 获取自定义滑动条
     }
 
-    public void setData(BookShelfBean bookShelfBean,OnItemClickListener clickListener) {
-        this.itemClickListener = clickListener;
-        this.bookShelfBean = bookShelfBean;
-        tvName.setText(bookShelfBean.getBookInfoBean().getName());
-        tvListCount.setText("共"+bookShelfBean.getBookInfoBean().getChapterlist().size()+"章");
-        chapterListAdapter = new ChapterListAdapter(bookShelfBean, new OnItemClickListener() {
+    public void setData(BookShelfBean bookShelfBean, OnItemClickListener clickListener) { // 设置数据
+        this.itemClickListener = clickListener; // 设置点击监听器
+        this.bookShelfBean = bookShelfBean; // 设置书架数据
+        tvName.setText(bookShelfBean.getBookInfoBean().getName()); // 设置书名
+        tvListCount.setText("共" + bookShelfBean.getBookInfoBean().getChapterlist().size() + "章"); // 设置章节数量
+        chapterListAdapter = new ChapterListAdapter(bookShelfBean, new OnItemClickListener() { // 创建适配器
             @Override
             public void itemClick(int index) {
-                if(itemClickListener!=null){
-                    itemClickListener.itemClick(index);
-                    rvbSlider.scrollToPositionWithOffset(index);
+                if(itemClickListener != null) {
+                    itemClickListener.itemClick(index); // 回调点击事件
+                    rvbSlider.scrollToPositionWithOffset(index); // 滚动到对应位置
                 }
             }
         });
-        rvList.setAdapter(chapterListAdapter);
-        rvbSlider.setRecyclerView(rvList);
+        rvList.setAdapter(chapterListAdapter); // 设置适配器
+        rvbSlider.setRecyclerView(rvList); // 设置滑动条的 RecyclerView
     }
 
-    public Boolean dimissChapterList(){
-        if(getVisibility()!=VISIBLE){
-            return false;
-        }else{
-            animOut.cancel();
-            animIn.cancel();
-            llContent.startAnimation(animOut);
-            return true;
+    public Boolean dimissChapterList() { // 关闭章节列表
+        if(getVisibility() != VISIBLE) {
+            return false; // 如果已经隐藏，返回 false
+        } else {
+            animOut.cancel(); // 取消退出动画
+            animIn.cancel(); // 取消进入动画
+            llContent.startAnimation(animOut); // 开始退出动画
+            return true; // 返回 true 表示正在关闭
         }
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/com/monke/monkeybook/widget/MTextView.java b/app/src/main/java/com/monke/monkeybook/widget/MTextView.java
index 87dbb6b..34edc25 100644
--- a/app/src/main/java/com/monke/monkeybook/widget/MTextView.java
+++ b/app/src/main/java/com/monke/monkeybook/widget/MTextView.java
@@ -1,33 +1,43 @@
 package com.monke.monkeybook.widget;
-
-import android.content.Context;
-import android.graphics.Canvas;
-import android.text.Layout;
-import android.text.StaticLayout;
-import android.text.TextPaint;
-import android.util.AttributeSet;
+// 导入必要的 Android 类
+import android.content.Context;// 导入 Context 类，用于访问应用的环境信息。
+import android.graphics.Canvas;// 导入 Canvas 类，用于进行自定义绘制和图形操作。
+import android.text.Layout;// 导入 Layout 类，用于处理文本的布局，控制文本的排列和格式。
+import android.text.StaticLayout;// 导入 StaticLayout 类，帮助绘制多行静态文本。
+import android.text.TextPaint;// 导入 TextPaint 类，扩展了 Paint 类用于绘制文本并包含字体相关的信息。
+import android.util.AttributeSet;// 导入 AttributeSet 类，处理 XML 布局中定义的自定义属性。
 
 /**
  * Created by ZQH on 2017/4/10.
  */
 
 public class MTextView extends android.support.v7.widget.AppCompatTextView {
-
+    // 构造函数，接收上下文和属性集
     public MTextView(Context context, AttributeSet attrs) {
-        super(context, attrs);
+        super(context, attrs);// 调用父类构造函数
     }
 
+    // 布局方法，处理视图的布局改变
     @Override
     protected void onLayout(boolean changed, int left, int top, int right,
                             int bottom) {
-        super.onLayout(changed, left, top, right, bottom);
+        super.onLayout(changed, left, top, right, bottom);// 调用父类的方法
     }
 
+    // 绘制方法，用于在画布上绘制文本
     @Override
     protected void onDraw(Canvas canvas) {
-        TextPaint paint = getPaint();
-        paint.setColor(getTextColors().getDefaultColor());
-        Layout layout = new StaticLayout(getText(), paint, canvas.getWidth(), Layout.Alignment.ALIGN_NORMAL, getLineSpacingMultiplier(), getLineSpacingExtra(), false);
+        TextPaint paint = getPaint();// 获取 TextPaint 对象
+        paint.setColor(getTextColors().getDefaultColor());// 设置文本颜色为默认颜色
+        // 创建 StaticLayout 用于处理多行文本的绘制
+        Layout layout = new StaticLayout(getText(),
+                paint,// 使用的 Paint 对象
+                canvas.getWidth(),// 输入的宽度
+                Layout.Alignment.ALIGN_NORMAL,// 文本对齐方式
+                getLineSpacingMultiplier(),// 行间距倍数
+                getLineSpacingExtra(),// 行间距额外值
+                false);// 是否需要添加额外的文本行
+        // 在画布上绘制文本
         layout.draw(canvas);
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/com/monke/monkeybook/widget/RecyclerViewBar.java b/app/src/main/java/com/monke/monkeybook/widget/RecyclerViewBar.java
index 74532fd..30d1603 100644
--- a/app/src/main/java/com/monke/monkeybook/widget/RecyclerViewBar.java
+++ b/app/src/main/java/com/monke/monkeybook/widget/RecyclerViewBar.java
@@ -1,28 +1,28 @@
 //定义类所在的包路径,表示该文件属于com.monke.monkeybook.widget包
 package com.monke.monkeybook.widget;
 // 导入必要的类
-import android.animation.Animator;
-import android.animation.ObjectAnimator;
-import android.annotation.TargetApi;
-import android.content.Context;
-import android.content.res.TypedArray;
-import android.graphics.Rect;
-import android.os.Build;
-import android.os.CountDownTimer;
-import android.support.annotation.Nullable;
-import android.support.v7.widget.LinearLayoutManager;
-import android.support.v7.widget.RecyclerView;
-import android.util.AttributeSet;
-import android.view.MotionEvent;
-import android.view.View;
-import android.view.ViewGroup;
-import android.view.ViewTreeObserver;
-import android.widget.FrameLayout;
-import android.widget.ImageView;
-import android.widget.LinearLayout;
+import android.animation.Animator; // 导入 Animator 类，用于实现动画效果的基础类。
+import android.animation.ObjectAnimator; // 导入 ObjectAnimator 类，提供对对象属性的动画效果。
+import android.annotation.TargetApi; // 导入 TargetApi 注解，用于指示特定的 API 级别。
+import android.content.Context; // 导入 Context 类，用于访问应用的环境信息，如资源、数据库等。
+import android.content.res.TypedArray; // 导入 TypedArray 类，帮助从 XML 文件中解析自定义属性。
+import android.graphics.Rect; // 导入 Rect 类，用于表示矩形区域，通常用于图形绘制和布局。
+import android.os.Build; // 导入 Build 类，提供有关当前 Android 版本的静态信息。
+import android.os.CountDownTimer; // 导入 CountDownTimer 类，提供一个倒计时的计时器。
+import android.support.annotation.Nullable; // 导入 Nullable 注解，表示某个元素可以为 null。
+import android.support.v7.widget.LinearLayoutManager; // 导入 LinearLayoutManager，用于 RecyclerView 的线性布局管理。
+import android.support.v7.widget.RecyclerView; // 导入 RecyclerView 类，提供高效的视图列表。
+import android.util.AttributeSet; // 导入 AttributeSet 类，处理 XML 布局中定义的自定义属性。
+import android.view.MotionEvent; // 导入 MotionEvent 类，用于处理触摸事件。
+import android.view.View; // 导入 View 类，Android 中所有视图控件的基类。
+import android.view.ViewGroup; // 导入 ViewGroup 类，所有视图组的基类，用于管理子视图。
+import android.view.ViewTreeObserver; // 导入 ViewTreeObserver 类，提供对视图树的观察功能
+import android.widget.FrameLayout; // 导入 FrameLayout 类，一个可堆叠子视图的布局。
+import android.widget.ImageView; // 导入 ImageView 类，显示图片的控件。
+import android.widget.LinearLayout; // 导入 LinearLayout 类，垂直或水平排列子视图的布局。
 
-import com.monke.monkeybook.R;
-import com.monke.monkeybook.utils.DensityUtil;
+import com.monke.monkeybook.R; // 导入应用资源类，访问资源（如布局、字符串、颜色等）。
+import com.monke.monkeybook.utils.DensityUtil; // 导入 DensityUtil 类，通常用于处理与屏幕密度相关的工具函数。
 
 public class RecyclerViewBar extends LinearLayout {
     // 定义滑动动画的时间常量
-- 
2.34.1


From 15b13afe4165ceff7e837bc1951200b8adf051e1 Mon Sep 17 00:00:00 2001
From: SYH <1017401752@qq.com>
Date: Tue, 17 Dec 2024 14:23:04 +0800
Subject: [PATCH 09/11] 2

---
 .../monkeybook/widget/ChapterListView.java    |  40 ++++---
 .../widget/refreshview/RefreshScrollView.java | 106 ++++++++++--------
 2 files changed, 88 insertions(+), 58 deletions(-)

diff --git a/app/src/main/java/com/monke/monkeybook/widget/ChapterListView.java b/app/src/main/java/com/monke/monkeybook/widget/ChapterListView.java
index a872e47..2fab0d2 100644
--- a/app/src/main/java/com/monke/monkeybook/widget/ChapterListView.java
+++ b/app/src/main/java/com/monke/monkeybook/widget/ChapterListView.java
@@ -36,26 +36,30 @@ public class ChapterListView extends FrameLayout{// 创建 ChapterListView 类
     private Animation animIn; // 动画进入效果
     private Animation animOut; // 动画退出效果
 
-    // 构造函数
+    // 默认构造函数
     public ChapterListView(@NonNull Context context) {
-        this(context,null);
+        this(context,null);// 调用带参构造函数，传递 null
     }
 
+    // 带 AttributeSet 的构造函数
     public ChapterListView(@NonNull Context context, @Nullable AttributeSet attrs) {
-        this(context, attrs,0);
+        this(context, attrs,0);// 调用带风格属性的构造函数
     }
 
+    // 带属性和风格的构造函数
     public ChapterListView(@NonNull Context context, @Nullable AttributeSet attrs, @AttrRes int defStyleAttr) {
-        super(context, attrs, defStyleAttr);
+        super(context, attrs, defStyleAttr);// 调用父类构造函数
         init();// 调用初始化方法
     }
 
+    // 具有更多参数的构造函数
     @TargetApi(Build.VERSION_CODES.LOLLIPOP)// 指示支持 API 21 及以上
     public ChapterListView(@NonNull Context context, @Nullable AttributeSet attrs, @AttrRes int defStyleAttr, @StyleRes int defStyleRes) {
-        super(context, attrs, defStyleAttr, defStyleRes);
+        super(context, attrs, defStyleAttr, defStyleRes);// 调用父类构造函数
         init();// 调用初始化方法
     }
 
+    // 初始化方法
     private void init() {
         setVisibility(INVISIBLE);// 默认隐藏视图
         LayoutInflater.from(getContext()).inflate(R.layout.view_chapterlist, this, true); // 加载布局
@@ -65,7 +69,9 @@ public class ChapterListView extends FrameLayout{// 创建 ChapterListView 类
 
     // 初始化数据和动画
     private void initData() {
+        // 加载进入动画
         animIn = AnimationUtils.loadAnimation(getContext(),R.anim.anim_pop_chapterlist_in);
+        / 设置动画监听器
         animIn.setAnimationListener(new Animation.AnimationListener() {
             @Override
             public void onAnimationStart(Animation animation) {
@@ -84,10 +90,13 @@ public class ChapterListView extends FrameLayout{// 创建 ChapterListView 类
 
             @Override
             public void onAnimationRepeat(Animation animation) {
-
+                // 动画重复时的反应（可根据需要实现
             }
         });
+
+        // 加载退出动画
         animOut = AnimationUtils.loadAnimation(getContext(),R.anim.anim_pop_chapterlist_out);// 退出动画
+        // 设置退出动画监听器
         animOut.setAnimationListener(new Animation.AnimationListener() {
             @Override
             public void onAnimationStart(Animation animation) {
@@ -102,12 +111,13 @@ public class ChapterListView extends FrameLayout{// 创建 ChapterListView 类
 
             @Override
             public void onAnimationRepeat(Animation animation) {
-
+                // 动画重复时的反应（可根据需要实现）
             }
         });
     }
 
-    public void show(int durChapter) { // 显示章节列表
+    // 显示章节列表
+    public void show(int durChapter) {
         chapterListAdapter.setIndex(durChapter); // 设置当前章节索引
         ((LinearLayoutManager) rvList.getLayoutManager()).scrollToPositionWithOffset(durChapter, 0); // 滚动到特定章节
         if(getVisibility() != VISIBLE) {
@@ -119,12 +129,14 @@ public class ChapterListView extends FrameLayout{// 创建 ChapterListView 类
         }
     }
 
+    // 点击监听接口
     public interface OnItemClickListener{// 点击监听接口
         public void itemClick(int index);// 点击事件方法
     }
-    private OnItemClickListener itemClickListener; // 监听器实例
+    private OnItemClickListener itemClickListener; // 用于监听点击事件的实例
     private BookShelfBean bookShelfBean; // 书架数据类实例
 
+    // 初始化视图组件
     private void initView() { // 初始化视图组件
         flBg = (FrameLayout) findViewById(R.id.fl_bg); // 获取背景 FrameLayout
         llContent = (LinearLayout) findViewById(R.id.ll_content); // 获取内容 LinearLayout
@@ -140,9 +152,10 @@ public class ChapterListView extends FrameLayout{// 创建 ChapterListView 类
         this.itemClickListener = clickListener; // 设置点击监听器
         this.bookShelfBean = bookShelfBean; // 设置书架数据
         tvName.setText(bookShelfBean.getBookInfoBean().getName()); // 设置书名
-        tvListCount.setText("共" + bookShelfBean.getBookInfoBean().getChapterlist().size() + "章"); // 设置章节数量
-        chapterListAdapter = new ChapterListAdapter(bookShelfBean, new OnItemClickListener() { // 创建适配器
+        tvListCount.setText("共" + bookShelfBean.getBookInfoBean().getChapterlist().size() + "章"); // 设置章节数量文本
+        chapterListAdapter = new ChapterListAdapter(bookShelfBean, new OnItemClickListener() { // 创建章节列表适配器
             @Override
+            // 处理章节单击事件
             public void itemClick(int index) {
                 if(itemClickListener != null) {
                     itemClickListener.itemClick(index); // 回调点击事件
@@ -150,11 +163,12 @@ public class ChapterListView extends FrameLayout{// 创建 ChapterListView 类
                 }
             }
         });
-        rvList.setAdapter(chapterListAdapter); // 设置适配器
+        rvList.setAdapter(chapterListAdapter); // 设置适配器到 RecyclerView
         rvbSlider.setRecyclerView(rvList); // 设置滑动条的 RecyclerView
     }
 
-    public Boolean dimissChapterList() { // 关闭章节列表
+    // 关闭章节列表
+    public Boolean dimissChapterList() {
         if(getVisibility() != VISIBLE) {
             return false; // 如果已经隐藏，返回 false
         } else {
diff --git a/app/src/main/java/com/monke/monkeybook/widget/refreshview/RefreshScrollView.java b/app/src/main/java/com/monke/monkeybook/widget/refreshview/RefreshScrollView.java
index 49b800d..afcb91b 100644
--- a/app/src/main/java/com/monke/monkeybook/widget/refreshview/RefreshScrollView.java
+++ b/app/src/main/java/com/monke/monkeybook/widget/refreshview/RefreshScrollView.java
@@ -1,101 +1,117 @@
+// 定义包名
 package com.monke.monkeybook.widget.refreshview;
 
-import android.annotation.TargetApi;
-import android.content.Context;
-import android.os.Build;
-import android.support.annotation.NonNull;
-import android.util.AttributeSet;
-import android.view.MotionEvent;
-import android.view.View;
-import android.widget.ScrollView;
+import android.annotation.TargetApi; // 导入 TargetApi 注解，标明特定的 API 级别
+import android.content.Context; // 导入 Context 类，提供应用的上下文
+import android.os.Build; // 导入 Build 类，用于获取当前 Android 版本信息
+import android.support.annotation.NonNull; // 导入 NonNull 注解，表示不允许为 null
+import android.util.AttributeSet; // 导入 AttributeSet 类，用于访问 XML 布局中的自定义属性
+import android.view.MotionEvent; // 导入 MotionEvent 类，处理触摸事件
+import android.view.View; // 导入 View 类，所有 UI 控件的基类
+import android.widget.ScrollView; // 导入 ScrollView 类，支持滚动的布局
 
+// 创建 RefreshScrollView 类，继承自 ScrollView
 public class RefreshScrollView extends ScrollView{
-    private RefreshProgressBar rpb;
-    private float durTouchY = -1000000;
-    private BaseRefreshListener baseRefreshListener;
-    private Boolean isRefreshing = false;
-    private OnTouchListener touchListener;
+    private RefreshProgressBar rpb; // 自定义的刷新进度条
+    private float durTouchY = -1000000; // 记录触摸Y坐标
+    private BaseRefreshListener baseRefreshListener; // 刷新监听器实例
+    private Boolean isRefreshing = false; // 是否正在刷新
+    private OnTouchListener touchListener; // 触摸事件监听器
 
+    // 构造函数
     public RefreshScrollView(Context context) {
-        this(context,null);
+        this(context,null);// 调用带有 AttributeSet 的构造函数
     }
 
     public RefreshScrollView(Context context, AttributeSet attrs) {
-        this(context, attrs,0);
+        this(context, attrs,0);// 调用带有风格属性的构造函数
     }
 
     public RefreshScrollView(Context context, AttributeSet attrs, int defStyleAttr) {
-        super(context, attrs, defStyleAttr);
+        super(context, attrs, defStyleAttr);// 调用父类构造函数
     }
 
-    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+    @TargetApi(Build.VERSION_CODES.LOLLIPOP)// 指示支持 API 21 及以上
     public RefreshScrollView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
-        super(context, attrs, defStyleAttr, defStyleRes);
+        super(context, attrs, defStyleAttr, defStyleRes);// 调用父类构造函数
     }
 
+    // 设置刷新进度条
     public void setRpb(@NonNull RefreshProgressBar rpb) {
-        this.rpb = rpb;
-        init();
+        this.rpb = rpb; // 赋值给 rpb
+        init(); // 初始化
     }
 
+    // 初始化方法
     private void init() {
+        // 设置触摸事件监听器
         touchListener = new OnTouchListener() {
             @Override
             public boolean onTouch(View v, MotionEvent event) {
-                int action = event.getAction();
+                int action = event.getAction(); // 获取当前触摸事件的动作
                 switch (action) {
-                    case MotionEvent.ACTION_DOWN:
-                        durTouchY = event.getY();
+                    case MotionEvent.ACTION_DOWN: // 触摸开始时
+                        durTouchY = event.getY(); // 记录初始触摸Y坐标
                         break;
-                    case MotionEvent.ACTION_MOVE:
-                        if (durTouchY == -1000000)
-                            durTouchY = event.getY();
-                        float dY = event.getY() - durTouchY;  //>0下拉
-                        durTouchY = event.getY();
-                        if (baseRefreshListener != null && !isRefreshing && rpb.getSecondDurProgress() == rpb.getSecondFinalProgress() && getScrollY()<=0) {
+                    case MotionEvent.ACTION_MOVE: // 触摸移动时
+                        if (durTouchY == -1000000) // 确保初始触摸坐标已记录
+                            durTouchY = event.getY(); // 更新触摸Y坐标
+                        float dY = event.getY() - durTouchY; // 计算移动的Y距离（向下则为正值）
+                        durTouchY = event.getY(); // 更新初始触摸坐标
+                        // 如果满足刷新条件
+                        if (baseRefreshListener != null && !isRefreshing && rpb.getSecondDurProgress() == rpb.getSecondFinalProgress() && getScrollY() <= 0) {
+                            // 设置刷新进度条可见
                             if (rpb.getVisibility() != View.VISIBLE) {
                                 rpb.setVisibility(View.VISIBLE);
                             }
+                            // 更新进度条的当前进度
                             rpb.setSecondDurProgress((int) (rpb.getSecondDurProgress() + dY));
+                            // 判断当前进度是否小于等于0
                             if (rpb.getSecondDurProgress() <= 0) {
-                                return false;
+                                return false; // 返回 false 以允许 ScrollView 处理事件
                             } else {
-                                return true;
+                                return true; // 返回 true 表示事件被处理
                             }
                         }
                         break;
-                    case MotionEvent.ACTION_UP:
+                    case MotionEvent.ACTION_UP: // 触摸抬起时
+                        // 如果满足刷新条件且当前进度大于0
                         if (baseRefreshListener != null && rpb.getSecondMaxProgress() > 0 && rpb.getSecondDurProgress() > 0) {
+                            // 如果当前进度达到最大值且不在刷新状态，则开始刷新
                             if (rpb.getSecondDurProgress() >= rpb.getSecondMaxProgress() && !isRefreshing) {
                                 startRefresh();
                             } else {
+                                // 否则，将进度条动画归零
                                 rpb.setSecondDurProgressWithAnim(0);
                             }
                         }
-                        durTouchY = -1000000;
+                        durTouchY = -1000000; // 重置触摸坐标
                         break;
                 }
-                return false;
+                return false; // 事件未完全处理，允许 ScrollView 继续处理
             }
         };
-        this.setOnTouchListener(touchListener);
+        this.setOnTouchListener(touchListener); // 设置触摸监听器
     }
 
+    // 设置刷新监听器
     public void setBaseRefreshListener(BaseRefreshListener baseRefreshListener) {
-        this.baseRefreshListener = baseRefreshListener;
+        this.baseRefreshListener = baseRefreshListener; // 赋值给监听器
     }
 
-    public void startRefresh(){
-        if(baseRefreshListener!=null){
-            isRefreshing = true;
-            rpb.setIsAutoLoading(true);
-            baseRefreshListener.startRefresh();
+    // 开始刷新
+    public void startRefresh() {
+        if (baseRefreshListener != null) {
+            isRefreshing = true; // 设置为正在刷新状态
+            rpb.setIsAutoLoading(true); // 设置进度条为自动加载状态
+            baseRefreshListener.startRefresh(); // 调用监听器的刷新方法
         }
     }
 
-    public void finishRefresh(){
-        isRefreshing = false;
-        rpb.setDurProgress(0);
-        rpb.setIsAutoLoading(false);
+    // 完成刷新
+    public void finishRefresh() {
+        isRefreshing = false; // 设置为未刷新状态
+        rpb.setDurProgress(0); // 重置进度条当前进度
+        rpb.setIsAutoLoading(false); // 退出自动加载状态
     }
 }
-- 
2.34.1


From 308787adffa0200ff9ee0f2fe5341e56d90e09ae Mon Sep 17 00:00:00 2001
From: SYH <1017401752@qq.com>
Date: Tue, 17 Dec 2024 14:27:22 +0800
Subject: [PATCH 10/11] 2

---
 .../RefreshRecyclerViewAdapter.java           | 153 ++++++++++--------
 1 file changed, 90 insertions(+), 63 deletions(-)

diff --git a/app/src/main/java/com/monke/monkeybook/widget/refreshview/RefreshRecyclerViewAdapter.java b/app/src/main/java/com/monke/monkeybook/widget/refreshview/RefreshRecyclerViewAdapter.java
index ef8861d..b2a42dd 100644
--- a/app/src/main/java/com/monke/monkeybook/widget/refreshview/RefreshRecyclerViewAdapter.java
+++ b/app/src/main/java/com/monke/monkeybook/widget/refreshview/RefreshRecyclerViewAdapter.java
@@ -1,177 +1,204 @@
+// 定义包名
 package com.monke.monkeybook.widget.refreshview;
 
-import android.os.Handler;
-import android.os.Looper;
-import android.support.v7.widget.RecyclerView;
-import android.util.Log;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.FrameLayout;
-import android.widget.TextView;
+import android.os.Handler; // 导入 Handler 类，用于处理线程间通信和执行任务
+import android.os.Looper; // 导入 Looper 类，用于控制线程的消息循环
+import android.support.v7.widget.RecyclerView; // 导入 RecyclerView 类，支持高效的列表展示
+import android.util.Log; // 导入 Log 类，用于调试日志
+import android.view.LayoutInflater; // 导入 LayoutInflater 类，用于将布局文件转换为 View 对象
+import android.view.View; // 导入 View 类，所有 UI 控件的基类
+import android.view.ViewGroup; // 导入 ViewGroup 类，视图的容器类
+import android.widget.FrameLayout; // 导入 FrameLayout 类，允许堆叠子视图的布局
+import android.widget.TextView; // 导入 TextView 类，用于显示文本
 
-import com.monke.monkeybook.R;
+import com.monke.monkeybook.R; // 导入应用资源类，访问资源文件
 
+// 创建抽象类 RefreshRecyclerViewAdapter，继承自 RecyclerView.Adapter
 public abstract class RefreshRecyclerViewAdapter extends RecyclerView.Adapter {
-    private final int LOADMORETYPE = 2001;
+    private final int LOADMORETYPE = 2001; // 加载更多的视图类型
 
-    private Handler handler;
-    private int isRequesting = 0;   //0是未执行网络请求  1是正在下拉刷新  2是正在加载更多
-    private Boolean needLoadMore = false;
-    private Boolean isAll = false;  //判断是否还有更多
-    private Boolean loadMoreError = false;
+    private Handler handler; // 处理线程间通信的 Handler
+    private int isRequesting = 0;   // 当前请求状态: 0-未请求，1-正在下拉刷新，2-正在加载更多
+    private Boolean needLoadMore = false; // 是否需要加载更多
+    private Boolean isAll = false;  // 判断是否还有更多数据
+    private Boolean loadMoreError = false; // 判断是否加载更多时发生错误
 
-    private OnClickTryAgainListener clickTryAgainListener;
+    private OnClickTryAgainListener clickTryAgainListener; // 加载失败重试监听器接口
 
+    // 点击重试的监听器接口
     public interface OnClickTryAgainListener {
-        public void loadMoreErrorTryAgain();
+        public void loadMoreErrorTryAgain();// 加载失败时的重试方法
     }
 
+    // 构造函数
     public RefreshRecyclerViewAdapter(Boolean needLoadMore) {
-        this.needLoadMore = needLoadMore;
-        handler = new Handler();
+        this.needLoadMore = needLoadMore; // 设置是否需要加载更多
+        handler = new Handler(); // 初始化 Handler
     }
 
+    // 获取请求状态
     public int getIsRequesting() {
-        return isRequesting;
+        return isRequesting; // 返回当前请求状态
     }
 
+    // 设置请求状态
     public void setIsRequesting(int isRequesting, Boolean needNoti) {
-        this.isRequesting = isRequesting;
-        if (this.isRequesting == 1) {
-            isAll = false;
+        this.isRequesting = isRequesting; // 更新请求状态
+        if (this.isRequesting == 1) { // 如果正在请求刷新
+            isAll = false; // 设置为没有更多数据
         }
+        // 根据需要通知数据变化
         if (needNoti) {
             if (Looper.myLooper() == Looper.getMainLooper()) {
-                notifyItemRangeChanged(getItemCount(), getItemCount() - getItemcount());
+                notifyItemRangeChanged(getItemCount(), getItemCount() - getItemcount()); // 通知数据范围变化
             } else {
                 handler.post(new Runnable() {
                     @Override
                     public void run() {
-                        notifyDataSetChanged();
+                        notifyDataSetChanged(); // 在主线程中通知数据已更新
                     }
                 });
             }
         }
     }
 
+    // 创建视图持有者
     @Override
     public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
-        if (viewType == LOADMORETYPE) {
+        if (viewType == LOADMORETYPE) { // 如果是加载更多类型
             return new LoadMoreViewHolder(LayoutInflater.from(parent.getContext()).inflate(R.layout.view_refresh_loadmore, parent, false));
-        } else
-            return onCreateViewholder(parent, viewType);
+        } else {
+            return onCreateViewholder(parent, viewType); // 否则调用抽象方法创建其他类型的视图持有者
+        }
     }
 
+    // 抽象方法，创建其他类型的视图持有者
     public abstract RecyclerView.ViewHolder onCreateViewholder(ViewGroup parent, int viewType);
 
+    // 绑定视图数据
     @Override
     public void onBindViewHolder(final RecyclerView.ViewHolder holder, int position) {
-        if (holder.getItemViewType() == LOADMORETYPE) {
+        if (holder.getItemViewType() == LOADMORETYPE) { // 如果是加载更多视图
             if (!loadMoreError) {
-                ((LoadMoreViewHolder) holder).tvLoadMore.setText("正在加载...");
+                ((LoadMoreViewHolder) holder).tvLoadMore.setText("正在加载..."); // 显示加载中
             } else {
-                ((LoadMoreViewHolder) holder).tvLoadMore.setText("加载失败,点击重试");
+                ((LoadMoreViewHolder) holder).tvLoadMore.setText("加载失败,点击重试"); // 显示加载失败信息
             }
+            // 设置点击事件
             ((LoadMoreViewHolder) holder).tvLoadMore.setOnClickListener(new View.OnClickListener() {
                 @Override
                 public void onClick(View v) {
                     if (null != clickTryAgainListener && loadMoreError) {
-                        clickTryAgainListener.loadMoreErrorTryAgain();
-                        loadMoreError = false;
-                        ((LoadMoreViewHolder) holder).tvLoadMore.setText("正在加载...");
+                        clickTryAgainListener.loadMoreErrorTryAgain(); // 调用重试方法
+                        loadMoreError = false; // 重置加载错误状态
+                        ((LoadMoreViewHolder) holder).tvLoadMore.setText("正在加载..."); // 更新加载状态
                     }
                 }
             });
-        } else
-            onBindViewholder(holder, position);
+        } else {
+            onBindViewholder(holder, position); // 绑定其他类型视图的数据
+        }
     }
 
+    // 抽象方法，绑定其他类型视图的数据
     public abstract void onBindViewholder(RecyclerView.ViewHolder holder, int position);
 
+    // 获取视图类型
     @Override
     public int getItemViewType(int position) {
         if (needLoadMore && isRequesting != 1 && !isAll && position == getItemCount() - 1 && getItemcount() > 0) {
-            return LOADMORETYPE;
+            return LOADMORETYPE; // 如果满足条件，返回加载更多视图类型
         } else {
-            return getItemViewtype(position);
+            return getItemViewtype(position); // 否则返回其他视图类型
         }
     }
 
+    // 抽象方法，获取其他类型视图的类型
     public abstract int getItemViewtype(int position);
 
+    // 获取项计数
     @Override
     public int getItemCount() {
         if (needLoadMore && isRequesting != 1 && !isAll && getItemcount() > 0) {
-            return getItemcount() + 1;
-        } else
-            return getItemcount();
+            return getItemcount() + 1; // 如果需要加载更多，返回总数 + 1（加载更多视图）
+        } else {
+            return getItemcount(); // 返回正常的项计数
+        }
     }
 
-    public abstract int getItemcount();
+    public abstract int getItemcount(); // 抽象方法，获取正常的项计数
 
+    // 设置是否有更多数据
     public void setIsAll(Boolean isAll, Boolean needNoti) {
-        this.isAll = isAll;
+        this.isAll = isAll; // 更新是否有更多数据
+        // 根据需要通知数据变化
         if (needNoti) {
             if (Looper.myLooper() == Looper.getMainLooper()) {
-//                notifyItemRangeChanged(getItemCount(),getItemCount()-getItemcount());
                 if (getItemCount() > getItemcount()) {
-                    notifyItemRangeChanged(getItemCount(), getItemCount() - getItemcount());
-                } else
-                    notifyItemRemoved(getItemCount() + 1);
+                    notifyItemRangeChanged(getItemCount(), getItemCount() - getItemcount()); // 通知数据范围变化
+                } else {
+                    notifyItemRemoved(getItemCount() + 1); // 通知加载更多视图移除
+                }
             } else {
                 handler.post(new Runnable() {
                     @Override
                     public void run() {
-                        notifyDataSetChanged();
+                        notifyDataSetChanged(); // 在主线程中通知数据已更新
                     }
                 });
             }
         }
     }
 
+    // 加载更多视图持有者类
     class LoadMoreViewHolder extends RecyclerView.ViewHolder {
-        FrameLayout llLoadMore;
-        TextView tvLoadMore;
+        FrameLayout llLoadMore; // 加载更多的容器
+        TextView tvLoadMore; // 加载更多的文本视图
 
+        // 构造函数
         public LoadMoreViewHolder(View itemView) {
             super(itemView);
-            llLoadMore = (FrameLayout) itemView.findViewById(R.id.ll_loadmore);
-            tvLoadMore = (TextView) itemView.findViewById(R.id.tv_loadmore);
+            llLoadMore = (FrameLayout) itemView.findViewById(R.id.ll_loadmore); // 获取加载更多的容器
+            tvLoadMore = (TextView) itemView.findViewById(R.id.tv_loadmore); // 获取加载更多文本视图
         }
     }
 
+    // 判断是否可以加载更多
     public Boolean canLoadMore() {
-        return needLoadMore && isRequesting == 0 && !isAll && getItemcount() > 0;
+        return needLoadMore && isRequesting == 0 && !isAll && getItemcount() > 0; // 返回是否满足加载更多条件
     }
 
+    // 获取重试监听器
     public OnClickTryAgainListener getClickTryAgainListener() {
-        return clickTryAgainListener;
+        return clickTryAgainListener; // 返回重试监听器
     }
 
+    // 设置重试监听器
     public void setClickTryAgainListener(OnClickTryAgainListener clickTryAgainListener) {
-        this.clickTryAgainListener = clickTryAgainListener;
-
+        this.clickTryAgainListener = clickTryAgainListener; // 赋值给重试监听器
     }
 
+    // 获取加载更多错误状态
     public Boolean getLoadMoreError() {
-        return loadMoreError;
+        return loadMoreError; // 返回加载更多错误状态
     }
 
+    // 设置加载更多错误
     public void setLoadMoreError(Boolean loadMoreError, Boolean needNoti) {
-        this.isRequesting = 0;
-        this.loadMoreError = loadMoreError;
+        this.isRequesting = 0; // 重置请求状态
+        this.loadMoreError = loadMoreError; // 设置加载错误状态
+        // 根据需要通知数据变化
         if (needNoti) {
             if (Looper.myLooper() == Looper.getMainLooper()) {
-                notifyDataSetChanged();
+                notifyDataSetChanged(); // 在主线程中通知数据已更新
             } else {
                 handler.post(new Runnable() {
                     @Override
                     public void run() {
-                        notifyDataSetChanged();
+                        notifyDataSetChanged(); // 在主线程中通知数据已更新
                     }
                 });
             }
         }
     }
-}
+}
\ No newline at end of file
-- 
2.34.1


From 09da4839f5658bbba295e3d961db918341fd5f05 Mon Sep 17 00:00:00 2001
From: SYH <1017401752@qq.com>
Date: Tue, 17 Dec 2024 14:30:38 +0800
Subject: [PATCH 11/11] 2

---
 .../refreshview/RefreshRecyclerView.java      | 231 ++++++++++--------
 1 file changed, 127 insertions(+), 104 deletions(-)

diff --git a/app/src/main/java/com/monke/monkeybook/widget/refreshview/RefreshRecyclerView.java b/app/src/main/java/com/monke/monkeybook/widget/refreshview/RefreshRecyclerView.java
index f2a5b4b..59afbd7 100644
--- a/app/src/main/java/com/monke/monkeybook/widget/refreshview/RefreshRecyclerView.java
+++ b/app/src/main/java/com/monke/monkeybook/widget/refreshview/RefreshRecyclerView.java
@@ -1,40 +1,45 @@
-package com.monke.monkeybook.widget.refreshview;
+package com.monke.monkeybook.widget.refreshview; // 定义包名
 
-import android.content.Context;
-import android.content.res.TypedArray;
-import android.support.v7.widget.LinearLayoutManager;
-import android.support.v7.widget.RecyclerView;
-import android.util.AttributeSet;
-import android.view.LayoutInflater;
-import android.view.MotionEvent;
-import android.view.View;
-import android.widget.FrameLayout;
+import android.content.Context; // 导入 Context 类，提供应用的上下文
+import android.content.res.TypedArray; // 导入 TypedArray 类，用于处理自定义属性
+import android.support.v7.widget.LinearLayoutManager; // 导入 LinearLayoutManager 类，用于线性布局管理器
+import android.support.v7.widget.RecyclerView; // 导入 RecyclerView 类，支持高效的列表展示
+import android.util.AttributeSet; // 导入 AttributeSet 类，用于访问 XML 布局中的自定义属性
+import android.view.LayoutInflater; // 导入 LayoutInflater 类，用于将布局文件转换为 View 对象
+import android.view.MotionEvent; // 导入 MotionEvent 类，处理触摸事件
+import android.view.View; // 导入 View 类，所有 UI 控件的基类
+import android.widget.FrameLayout; // 导入 FrameLayout 类，按层次排列子视图
 
-import com.monke.monkeybook.R;
+import com.monke.monkeybook.R; // 导入应用资源类，访问资源文件
 
+// 创建 RefreshRecyclerView 类，继承自 FrameLayout
 public class RefreshRecyclerView extends FrameLayout {
-    private View view;
-    private RefreshProgressBar rpb;
-    private RecyclerView recyclerView;
+    private View view; // 根视图
+    private RefreshProgressBar rpb; // 自定义进度条
+    private RecyclerView recyclerView; // RecyclerView 控件
 
-    private View noDataView;
-    private View refreshErrorView;
+    private View noDataView; // 无数据视图
+    private View refreshErrorView; // 刷新错误视图
 
+    // 构造函数
     public RefreshRecyclerView(Context context) {
-        this(context, null);
+        this(context, null); // 调用带有 AttributeSet 的构造函数
     }
 
     public RefreshRecyclerView(Context context, AttributeSet attrs) {
-        this(context, attrs, 0);
+        this(context, attrs, 0); // 调用带有默认样式的构造函数
     }
 
     public RefreshRecyclerView(Context context, AttributeSet attrs, int defStyleAttr) {
         super(context, attrs, defStyleAttr);
 
+        // 从 XML 布局中加载视图
         view = LayoutInflater.from(context).inflate(R.layout.view_refresh_recyclerview, this, false);
+        // 初始化 UI 组件
         rpb = (RefreshProgressBar) view.findViewById(R.id.rpb);
         recyclerView = (RecyclerView) view.findViewById(R.id.rv);
 
+        // 获取自定义属性并设置给 RefreshProgressBar
         TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.RefreshProgressBar);
         rpb.setSpeed(a.getDimensionPixelSize(R.styleable.RefreshProgressBar_speed, rpb.getSpeed()));
         rpb.setMaxProgress(a.getInt(R.styleable.RefreshProgressBar_max_progress, rpb.getMaxProgress()));
@@ -42,235 +47,253 @@ public class RefreshRecyclerView extends FrameLayout {
         rpb.setBgColor(a.getColor(R.styleable.RefreshProgressBar_bg_color, rpb.getBgColor()));
         rpb.setSecondColor(a.getColor(R.styleable.RefreshProgressBar_second_color, rpb.getSecondColor()));
         rpb.setFontColor(a.getColor(R.styleable.RefreshProgressBar_font_color, rpb.getFontColor()));
-        a.recycle();
+        a.recycle(); // 释放 TypedArray
 
-        bindEvent();
-
-        addView(view);
+        bindEvent(); // 绑定事件
+        addView(view); // 将根视图添加到 FrameLayout 中
     }
 
-    private float durTouchY = -1000000;
-    private BaseRefreshListener baseRefreshListener;
+    private float durTouchY = -1000000; // 记录触摸 Y 坐标
+    private BaseRefreshListener baseRefreshListener; // 刷新监听器
 
+    // 设置刷新监听器
     public void setBaseRefreshListener(BaseRefreshListener baseRefreshListener) {
         this.baseRefreshListener = baseRefreshListener;
     }
 
-    private OnLoadMoreListener loadMoreListener;
+    private OnLoadMoreListener loadMoreListener; // 加载更多监听器
 
+    // 设置加载更多监听器
     public void setLoadMoreListener(OnLoadMoreListener loadMoreListener) {
         this.loadMoreListener = loadMoreListener;
     }
 
+    // 绑定事件
     private void bindEvent() {
         recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
             @Override
             public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
-                super.onScrollStateChanged(recyclerView, newState);
+                super.onScrollStateChanged(recyclerView, newState); // 调用父类方法
             }
 
             @Override
             public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
-                super.onScrolled(recyclerView, dx, dy);
-                if (((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).canLoadMore() && ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).getItemCount() - 1 == ((LinearLayoutManager) recyclerView.getLayoutManager()).findLastVisibleItemPosition()) {
-                    if(!((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).getLoadMoreError()){
+                super.onScrolled(recyclerView, dx, dy); // 调用父类方法
+                // 判断是否可以加载更多
+                if (((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).canLoadMore() &&
+                        ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).getItemCount() - 1
+                                == ((LinearLayoutManager) recyclerView.getLayoutManager()).findLastVisibleItemPosition()) {
+
+                    // 如果没有加载错误，开始加载更多
+                    if (!((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).getLoadMoreError()) {
                         if (null != loadMoreListener) {
-                            ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsRequesting(2, false);
-                            loadMoreListener.startLoadmore();
+                            ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsRequesting(2, false); // 设置为正在加载更多状态
+                            loadMoreListener.startLoadmore(); // 调用加载更多方法
                         }
                     }
                 }
             }
         });
 
-        recyclerView.setOnTouchListener(refreshTouchListener);
+        recyclerView.setOnTouchListener(refreshTouchListener); // 设置触摸事件监听器
     }
 
+    // 获取自定义进度条
     public RefreshProgressBar getRpb() {
         return rpb;
     }
 
+    // 获取 RecyclerView
     public RecyclerView getRecyclerView() {
         return recyclerView;
     }
 
+    // 处理刷新错误
     public void refreshError() {
-        rpb.setIsAutoLoading(false);
-        rpb.clean();
-        ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsRequesting(0, true);
+        rpb.setIsAutoLoading(false); // 设置为非自动加载状态
+        rpb.clean(); // 清空进度
+        ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsRequesting(0, true); // 设置请求状态为未请求
         if (noDataView != null) {
-            noDataView.setVisibility(GONE);
+            noDataView.setVisibility(GONE); // 隐藏无数据视图
         }
         if (refreshErrorView != null) {
-            refreshErrorView.setVisibility(VISIBLE);
+            refreshErrorView.setVisibility(VISIBLE); // 显示刷新错误视图
         }
     }
 
+    // 开始刷新
     public void startRefresh() {
         if (baseRefreshListener != null && baseRefreshListener instanceof OnRefreshWithProgressListener) {
-            ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsAll(false, false);
-            ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsRequesting(1, false);
-            rpb.setSecondDurProgress(rpb.getSecondMaxProgress());
-            rpb.setMaxProgress(((OnRefreshWithProgressListener) baseRefreshListener).getMaxProgress());
+            // 带有进度的刷新
+            ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsAll(false, false); // 设置还有更多数据
+            ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsRequesting(1, false); // 设置为正在刷新状态
+            rpb.setSecondDurProgress(rpb.getSecondMaxProgress()); // 设置当前进度为最大进度
+            rpb.setMaxProgress(((OnRefreshWithProgressListener) baseRefreshListener).getMaxProgress()); // 获取最大进度
         } else {
-            ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsRequesting(1, true);
-            rpb.setIsAutoLoading(true);
+            // 非带进度的刷新
+            ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsRequesting(1, true); // 设置为正在刷新状态
+            rpb.setIsAutoLoading(true); // 设置为自动加载
             if (noDataView != null) {
-                noDataView.setVisibility(GONE);
+                noDataView.setVisibility(GONE); // 隐藏无数据视图
             }
             if (refreshErrorView != null) {
-                refreshErrorView.setVisibility(GONE);
+                refreshErrorView.setVisibility(GONE); // 隐藏刷新错误视图
             }
         }
     }
 
+    // 完成刷新
     public void finishRefresh(Boolean needNoti) {
-        finishRefresh(((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).getItemcount() == 0, needNoti);
+        finishRefresh(((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).getItemcount() == 0, needNoti); // 判断是否有数据并完成刷新
     }
 
+    // 完成刷新，判断是否还有更多数据
     public void finishRefresh(Boolean isAll, Boolean needNoti) {
-        rpb.setDurProgress(0);
+        rpb.setDurProgress(0); // 重置进度条
         if (isAll) {
-            ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsRequesting(0, false);
-            rpb.setIsAutoLoading(false);
-            ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsAll(isAll, needNoti);
+            ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsRequesting(0, false); // 设置请求状态为未请求
+            rpb.setIsAutoLoading(false); // 设置为非自动加载状态
+            ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsAll(isAll, needNoti); // 设置没有更多数据
         } else {
-            rpb.setIsAutoLoading(false);
-            ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsRequesting(0, needNoti);
+            rpb.setIsAutoLoading(false); // 设置为非自动加载状态
+            ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsRequesting(0, needNoti); // 设置请求状态为未请求
         }
 
+        // 根据数据情况显示无数据视图
         if (isAll) {
             if (noDataView != null) {
                 if (((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).getItemcount() == 0)
-                    noDataView.setVisibility(VISIBLE);
+                    noDataView.setVisibility(VISIBLE); // 如果没有数据，则显示无数据视图
                 else
-                    noDataView.setVisibility(GONE);
+                    noDataView.setVisibility(GONE); // 否则隐藏无数据视图
             }
             if (refreshErrorView != null) {
-                refreshErrorView.setVisibility(GONE);
+                refreshErrorView.setVisibility(GONE); // 隐藏刷新错误视图
             }
         }
     }
 
+    // 完成加载更多
     public void finishLoadMore(Boolean isAll, Boolean needNoti) {
         if (isAll) {
-            ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsRequesting(0, false);
-            ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsAll(isAll, needNoti);
+            ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsRequesting(0, false); // 设置请求状态为未请求
+            ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsAll(isAll, needNoti); // 设置没有更多数据
         } else {
-            ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsRequesting(0, needNoti);
+            ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsRequesting(0, needNoti); // 设置请求状态为未请求
         }
 
         if (noDataView != null) {
-            noDataView.setVisibility(GONE);
+            noDataView.setVisibility(GONE); // 隐藏无数据视图
         }
         if (refreshErrorView != null) {
-            refreshErrorView.setVisibility(GONE);
+            refreshErrorView.setVisibility(GONE); // 隐藏刷新错误视图
         }
     }
 
+    // 设置适配器
     public void setRefreshRecyclerViewAdapter(RefreshRecyclerViewAdapter refreshRecyclerViewAdapter, RecyclerView.LayoutManager layoutManager) {
         refreshRecyclerViewAdapter.setClickTryAgainListener(new RefreshRecyclerViewAdapter.OnClickTryAgainListener() {
             @Override
             public void loadMoreErrorTryAgain() {
                 if (loadMoreListener != null)
-                    loadMoreListener.loadMoreErrorTryAgain();
+                    loadMoreListener.loadMoreErrorTryAgain(); // 处理加载更多错误重试
             }
         });
-        recyclerView.setLayoutManager(layoutManager);
-        recyclerView.setAdapter(refreshRecyclerViewAdapter);
+        recyclerView.setLayoutManager(layoutManager); // 设置布局管理器
+        recyclerView.setAdapter(refreshRecyclerViewAdapter); // 设置适配器
     }
 
+    // 加载更多错误
     public void loadMoreError() {
-        rpb.setIsAutoLoading(false);
-        rpb.clean();
-        ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setLoadMoreError(true, true);
+        rpb.setIsAutoLoading(false); // 设置为非自动加载状态
+        rpb.clean(); // 清空进度
+        ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setLoadMoreError(true, true); // 设置加载错误状态
     }
 
+    // 设置无数据视图和刷新错误视图
     public void setNoDataAndrRefreshErrorView(View noData, View refreshError) {
         if (noData != null) {
-            noDataView = noData;
-//            noDataView.setOnTouchListener(refreshTouchListener);
-            noDataView.setVisibility(GONE);
-            addView(noDataView, getChildCount() - 1);
-
+            noDataView = noData; // 设置无数据视图
+            noDataView.setVisibility(GONE); // 隐藏无数据视图
+            addView(noDataView, getChildCount() - 1); // 将视图添加到 FrameLayout 中
         }
         if (refreshError != null) {
-            refreshErrorView = refreshError;
-//            refreshErrorView.setOnTouchListener(refreshTouchListener);
-            addView(refreshErrorView, 2);
-            refreshErrorView.setVisibility(GONE);
+            refreshErrorView = refreshError; // 设置刷新错误视图
+            addView(refreshErrorView, 2); // 将视图添加到 FrameLayout 中
+            refreshErrorView.setVisibility(GONE); // 隐藏刷新错误视图
         }
     }
 
     private OnTouchListener refreshTouchListener = new OnTouchListener() {
         @Override
         public boolean onTouch(View v, MotionEvent event) {
-            int action = event.getAction();
+            int action = event.getAction(); // 获取触摸事件动作
             switch (action) {
-                case MotionEvent.ACTION_DOWN:
-                    durTouchY = event.getY();
+                case MotionEvent.ACTION_DOWN: // 触摸开始时
+                    durTouchY = event.getY(); // 记录 Y 坐标
                     break;
-                case MotionEvent.ACTION_MOVE:
+                case MotionEvent.ACTION_MOVE: // 触摸移动时
                     if (durTouchY == -1000000)
-                        durTouchY = event.getY();
-                    float dY = event.getY() - durTouchY;  //>0下拉
-                    durTouchY = event.getY();
+                        durTouchY = event.getY(); // 初始化 Y 坐标
+                    float dY = event.getY() - durTouchY;  // 计算下拉距离
+                    durTouchY = event.getY(); // 更新 Y 坐标
+                    // 判断是否可以刷新
                     if (baseRefreshListener != null && ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).getIsRequesting() == 0 && rpb.getSecondDurProgress() == rpb.getSecondFinalProgress()) {
                         if (rpb.getVisibility() != View.VISIBLE) {
-                            rpb.setVisibility(View.VISIBLE);
+                            rpb.setVisibility(View.VISIBLE); // 显示进度条
                         }
                         if (recyclerView.getAdapter().getItemCount() > 0) {
                             if (0 == ((LinearLayoutManager) recyclerView.getLayoutManager()).findFirstCompletelyVisibleItemPosition()) {
-                                rpb.setSecondDurProgress((int) (rpb.getSecondDurProgress() + dY));
+                                rpb.setSecondDurProgress((int) (rpb.getSecondDurProgress() + dY)); // 更新进度
                             }
                         } else {
-                            rpb.setSecondDurProgress((int) (rpb.getSecondDurProgress() + dY));
+                            rpb.setSecondDurProgress((int) (rpb.getSecondDurProgress() + dY)); // 更新进度
                         }
                         if (rpb.getSecondDurProgress() <= 0) {
-                            return false;
+                            return false; // 返回 false 继续处理
                         } else {
-                            return true;
+                            return true; // 返回 true 终止触摸事件继续处理
                         }
                     }
                     break;
-                case MotionEvent.ACTION_UP:
+                case MotionEvent.ACTION_UP: // 触摸抬起时
+                    // 判断是否能开始刷新
                     if (baseRefreshListener != null && rpb.getSecondMaxProgress() > 0 && rpb.getSecondDurProgress() > 0) {
                         if (rpb.getSecondDurProgress() >= rpb.getSecondMaxProgress() && ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).getIsRequesting() == 0) {
                             if (baseRefreshListener instanceof OnRefreshWithProgressListener) {
-                                //带有进度的
-                                //执行刷新响应
+                                // 带有进度的刷新
                                 ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsAll(false, false);
-                                ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsRequesting(1, true);
-                                rpb.setMaxProgress(((OnRefreshWithProgressListener) baseRefreshListener).getMaxProgress());
-                                baseRefreshListener.startRefresh();
+                                ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsRequesting(1, true); // 设置为正在刷新状态
+                                rpb.setMaxProgress(((OnRefreshWithProgressListener) baseRefreshListener).getMaxProgress()); // 获取最大进度
+                                baseRefreshListener.startRefresh(); // 执行刷新
                                 if (noDataView != null) {
-                                    noDataView.setVisibility(GONE);
+                                    noDataView.setVisibility(GONE); // 隐藏无数据视图
                                 }
                                 if (refreshErrorView != null) {
-                                    refreshErrorView.setVisibility(GONE);
+                                    refreshErrorView.setVisibility(GONE); // 隐藏刷新错误视图
                                 }
                             } else {
-                                //不带进度的
+                                // 不带进度的刷新
                                 ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsAll(false, false);
-                                ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsRequesting(1, true);
-                                baseRefreshListener.startRefresh();
+                                ((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).setIsRequesting(1, true); // 设置为正在刷新状态
+                                baseRefreshListener.startRefresh(); // 执行刷新
                                 if (noDataView != null) {
-                                    noDataView.setVisibility(GONE);
+                                    noDataView.setVisibility(GONE); // 隐藏无数据视图
                                 }
                                 if (refreshErrorView != null) {
-                                    refreshErrorView.setVisibility(GONE);
+                                    refreshErrorView.setVisibility(GONE); // 隐藏刷新错误视图
                                 }
-                                rpb.setIsAutoLoading(true);
+                                rpb.setIsAutoLoading(true); // 设置为自动加载状态
                             }
                         } else {
                             if (((RefreshRecyclerViewAdapter) recyclerView.getAdapter()).getIsRequesting() != 1)
-                                rpb.setSecondDurProgressWithAnim(0);
+                                rpb.setSecondDurProgressWithAnim(0); // 动画归零
                         }
                     }
-                    durTouchY = -1000000;
+                    durTouchY = -1000000; // 重置 Y 坐标
                     break;
             }
-            return false;
+            return false; // 返回 false 继续处理触摸事件
         }
     };
 }
\ No newline at end of file
-- 
2.34.1