Paging 库可帮助您加载和显示来自本地存储或网络中更大的数据集中的数据页面。此方法可让您的应用更高效地利用网络带宽和系统资源;

- 分页数据的内存中缓存。该功能有助于确保您的应用在处理分页数据时高效使用系统资源。
- 内置的请求去重功能，可确保您的应用高效利用网络带宽和系统资源。
- 可配置的RecyclerView适配器，会在用户滚动到已加载数据的末尾时自动请求数据。
- 对 Kotlin 协程和数据流以及LiveData和 RxJava 的一流支持。
- 内置对错误处理功能的支持，包括刷新和重试功能。

implementation 'androidx.paging:paging-runtime:2.1.0'

/**
 * PagedList: 数据源获取的数据最终靠PagedList来承载。
 * 对于PagedList,我们可以这样来理解，它就是一页数据的集合。
 * 每请求一页，就是新的一个PagedList对象。
 */
public class StudentViewModel extends ViewModel {

    // 看源码：@1 listLiveData 数据怎么来的
    private final LiveData<PagedList<Student>> listLiveData;

    public StudentViewModel() {
        StudentDataSourceFactory factory = new StudentDataSourceFactory();

        // 初始化 ViewModel,如何生产一页数据出来给我！
        this.listLiveData = new LivePagedListBuilder<Integer, Student>(factory, Flag.SIZE)
                .setBoundaryCallback(new MyBoundaryCallback())
                .build();
    }
    // TODO 暴露数据出去
    public LiveData<PagedList<Student>> getListLiveData() {
        return listLiveData;
    }
}

public class RecyclerPagingAdapter extends PagedListAdapter<Student, RecyclerPagingAdapter.MyRecyclerViewHolder> {
    // TODO 比较的行为
    private static DiffUtil.ItemCallback<Student> DIFF_STUDNET = new
            DiffUtil.ItemCallback<Student>() {
                // 一般是比较 唯一性的内容， ID
                @Override
                public boolean areItemsTheSame(@NonNull Student oldItem, @NonNull Student newItem) {
                    return oldItem.getId().equals(newItem.getId());
                }

                // 对象本身的比较
                @Override
                public boolean areContentsTheSame(@NonNull Student oldItem, @NonNull Student newItem) {
                    return oldItem.equals(newItem);
                }
            };

    protected RecyclerPagingAdapter() {
        super(DIFF_STUDNET);
    }

    @NonNull
    @Override
    public MyRecyclerViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.item, null);
        return new MyRecyclerViewHolder(view);
    }

    @Override
    public void onBindViewHolder(@NonNull MyRecyclerViewHolder holder, int position) {
        Student student = getItem(position);

        // item view 出来了， 分页库还在加载数据中，我就显示 Id加载中
        if (null == student) {
            holder.tvId.setText("Id加载中");
            holder.tvName.setText("Name加载中");
            holder.tvSex.setText("Sex加载中");
        } else {
            holder.tvId.setText(student.getId());
            holder.tvName.setText(student.getName());
            holder.tvSex.setText(student.getSex());
        }
    }

    // Item 优化的 ViewHolder
    public static class MyRecyclerViewHolder extends RecyclerView.ViewHolder {

        TextView tvId;
        TextView tvName;
        TextView tvSex;

        public MyRecyclerViewHolder(View itemView) {
            super(itemView);
            tvId = itemView.findViewById(R.id.tv_id); // ID
            tvName = itemView.findViewById(R.id.tv_name); // 名称
            tvSex = itemView.findViewById(R.id.tv_sex); // 性别
        }
    }

}

public class MainActivity extends AppCompatActivity {
    private RecyclerView recyclerView;
    RecyclerPagingAdapter recyclerPagingAdapter;
    StudentViewModel viewModel;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        recyclerView =  findViewById(R.id.recycle_view);
        recyclerPagingAdapter = new RecyclerPagingAdapter();

        // 最新版本初始化 viewModel
        viewModel = new ViewModelProvider(this, new ViewModelProvider.NewInstanceFactory())
                .get(StudentViewModel.class);

        // LiveData 观察者 感应更新
        viewModel.getListLiveData().observe(this, new Observer<PagedList<Student>>() {
            @Override
            public void onChanged(PagedList<Student> students) {
                // 再这里更新适配器数据
                recyclerPagingAdapter.submitList(students);
            }
        });
        recyclerView.setAdapter(recyclerPagingAdapter);
        recyclerView.setLayoutManager(new LinearLayoutManager(this));
    }
}

Hilt 提供了一种合并 Dagger 的标准方法 依赖项注入到 Android 应用程序中。

Hilt 的目标是：
  1.简化 Android 应用的 Dagger 相关基础架构。
  2.要创建一组标准的组件和示波器以简化设置， 可读性/理解力，以及应用程序之间的代码共享。
  3.提供一种简单的方法来为各种生成提供不同的绑定 类型（例如测试、调试或发布）。

Hilt 通过代码为您生成 Dagger 设置代码。这带走了 大多数使用 Dagger 的样板，实际上只留下了 定义如何创建对象以及注入对象的位
	置。Hilt 将生成 Dagger 组件和用于自动注入 Android 类的代码 

//1. 配置Hilt的插件路径(project->build.gradle)
buildscript {
    ...
    dependencies {
        ...
        classpath 'com.google.dagger:hilt-android-gradle-plugin:2.28-alpha'
    }
}
或
buildscript {//需要放在plugins之前
    dependencies {
        classpath 'com.google.dagger:hilt-android-gradle-plugin:2.28-alpha'
    }
}
plugins {
    id 'com.android.application' version '7.1.3' apply false
    id 'com.android.library' version '7.1.3' apply false

}
//2. 引入Hilt的插件(app->build.gradle )
apply plugin: 'com.android.application'
apply plugin: 'dagger.hilt.android.plugin'
或
plugins {
    id 'com.android.application'
    id 'dagger.hilt.android.plugin'
}
//3. 添加Hilt的依赖库及java8
android{
	...
	 compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}
dependencies {
    ...
 		implementation "com.google.dagger:hilt-android:2.28-alpha"
    annotationProcessor "com.google.dagger:hilt-android-compiler:2.28-alpha"
}

1.Application
2.Activity 
3.Fragment
4.View 
5.Service
6.BroadcastReceiver

1.提供一个对象
	public class HttpObject {
}
2.编写Module
@InstallIn(ActivityComponent.class)
@Module
public class HttpModule {
    @Provides
    public HttpObject getHttpObject(){
        return new HttpObject();
    }
}
3.注入到Activity
@AndroidEntryPoint
public class MainActivity extends AppCompatActivity {
    @Inject
    HttpObject httpObject;
    @Inject
    HttpObject httpObject2;
    
4.Application中注册
	@HiltAndroidApp
public class MyApplication extends Application {
}
5.全局单例使用
@InstallIn(ApplicationComponent.class)
@Module
public class HttpModule {

    @Provides
    @Singleton
    public HttpObject getHttpObject(){
        return new HttpObject();
    }
}
注意：Hilt注入的字段是不可以声明成private

//1
public interface AnalyticsService {
  void analyticsMethods();
}
//2
public class AnalyticsServiceImpl implements AnalyticsService {
  ...
  @Inject
  AnalyticsServiceImpl(...) {
    ...
  }
}
//3
@Module
@InstallIn(ActivityComponent.class)
public abstract class AnalyticsModule {

  @Binds
  public abstract AnalyticsService bindAnalyticsService(
    AnalyticsServiceImpl analyticsServiceImpl
  );
}

@HiltAndroidApp
@HiltAndroidApp 将会触发 Hilt 的代码生成，作为程序依赖项容器的基类
生成的 Hilt 依附于 Application 的生命周期，他是 App 的父组件，提供访问其他组件的依赖
在 Application 中配置好后，就可以使用 Hilt 提供的组件了；组件包含 Application，Activity，Fragment，View，Service 等。
@HiltAndroidApp
创建一个依赖容器，该容器遵循 Android 的生命周期类，目前支持的类型是: Activity, Fragment, View, Service, BroadcastReceiver.
@Inject
使用 @Inject 来告诉 Hilt 如何提供该类的实例，常用于构造方法，非私有字段，方法中。
Hilt 有关如何提供不同类型的实例信息也称之为绑定
@Module
module 是用来提供一些无法用 构造@Inject 的依赖，如第三方库，接口，build 模式的构造等。
使用 @Module 注解的类，需要使用 @InstallIn 注解指定 module 的范围
增加了 @Module 注解的类，其实代表的就是一个模块，并通过指定的组件来告诉在那个容器中可以使用绑定安装。
@InstallIn
使用 @Module 注入的类，需要使用 @InstallIn 注解指定 module 的范围。
例如使用 @InstallIn(ActivityComponent::class) 注解的 module 会绑定到 activity 的生命周期上。
@Provides
常用于被 @Module 注解标记类的内部方法上。并提供依赖项对象。
@EntryPoint
Hilt 支持最常见的 Android 类 Application、Activity、Fragment、View、Service、BroadcastReceiver 等等，但是您可能需要
在Hilt 不支持的类中执行依赖注入，在这种情况下可以使用 @EntryPoint 注解进行创建，Hilt 会提供相应的依赖。

Room 是一个轻量级 orm 数据库，本质上是一个SQLite抽象层，但是使用起来会更加简单，类似于Retrofit库。Room 在开发阶段通过注解
	的方式标记相关功能，编译时自动生成响应的 impl 实现类

对象关系映射(英语:Object Relational Mapping，简称ORM，或0/RM，或0/R mapping),是一种程序设计技术，用于实现面向对象编程
语言里不同类型系统的数据之间的转换。从效果上说，它其实是创建了一个可在编程语言里使用的“虚拟对象数据库”。如今已有很多免费和
付费的ORM产品，而有些程序员更倾向于创建自己的ORM工具。

implementation "androidx.room:room-runtime:2.2.3"
annotationProcessor "androidx.room:room-compiler:2.2.3"

官网的文档也指出，我们需要创建这三个文件，才能正式的使用Room:
1.Entity：普通Java Bean类
2.DAO：定义一个接口类
3.Room Database：定义一个抽象类，并继承Room Database

/**
 * 1.Entity类需要使用@Entity注解标注，并且其中的tableName即数据表名，可以改为自己想取的名字
 * 2.构造函数：构造函数可以允许多个，但只允许只有一个不加@Ignore注解，其它的都得加上@Ignore注解，实际运行发现，若多个构造函数不
 * 加@Ignore，将无法通过编译。至于多个构造函数的存在是因为CRUD的特性决定的，例如删除，只需要id主键就行了。因此提供了多个构造
 * 函数
 * 3.Getter和Setter方法：这些方法是必须要的，否则无法对对象属性进行读取或修改
 */

//Entity类需要使用@Entity注解标注，并且其中的tableName即数据表名，可以改为自己想取的名字
@Entity(tableName = "StudentDao")
public class StudentEntity {
    /**
     * 使用@PrimaryKey声明为主键，并且允许自动生成
     * 使用@ColumnInfo表明这个属性是表中的一列列名，并可以指明列的名称
     */
    @PrimaryKey(autoGenerate = true)//autoGenerate = true 使得主键的值自动生成
    @ColumnInfo(name = "id")
    private int id;
    @ColumnInfo
    private String name;
    @ColumnInfo
    private String pwd;
    @ColumnInfo
    private int age;


    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
}

/**
 * DAO层接口,需要添加@Dao注解声明
 * 所有的操作都以主键为依托进行
 */
@Dao
public interface  StudentDao {

    /**
     * 查询所有的数据，返回List集合
     * @return
     */
    @Query("Select * from StudentDao")
    List<StudentEntity> getAllStudentList();

    /**
     * 传递参数的集合，注意 Room通过参数名称进行匹配，若不匹配，则编译出现错误
     * @param personId
     * @return
     */
    @Query("select * from StudentDao where id in (:personId)")
    List<StudentEntity> getStudentById(int[] personId);

    /**
     * 返回一定条件约束下的数据，注意参数在查询语句中的写法
     * @param minAge
     * @param maxAge
     */
    @Query("select * from StudentDao where age between :minAge and :maxAge")
    List<StudentEntity> getStudentByAgeRange(int minAge, int maxAge);

    /**
     * 插入数据，onConflict = OnConflictStrategy.REPLACE表明若存在主键相同的情况则直接覆盖
     * 返回的long表示的是插入项新的id
     */
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    long insertStudent(StudentEntity studentEntity);

    /**
     * 更新数据，这意味着可以指定id然后传入新的person对象进行更新
     * 返回的long表示更新的行数
     */
    @Update
    int updatePerson(StudentEntity studentEntity);


    /**
     * 删除数据，根据传入实体的主键进行数据的删除。
     * 也可以返回long型数据，表明从数据库中删除的行数
     */
    @Delete
    int deletePerson(StudentEntity studentEntity);
}

/**
 * 指明是需要从那个class文件中创建数据库，并必须指明版本号
 */
@Database(entities = {StudentEntity.class}, version = 1)
public abstract class StudentDataBase extends RoomDatabase {
    public abstract StudentDao studentDao();
}

public class RoomActivity extends AppCompatActivity {
    private StudentDataBase studentDataBase;
    private StudentDao studentDao;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_room);
        studentDataBase = Room.databaseBuilder(
                getApplicationContext(),
                StudentDataBase.class,
                "StudentDao"
            ).build();
        studentDao = studentDataBase.studentDao();
    }

    private int defaultClick=1;
    public void addData(View view) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                StudentEntity studentEntity = new StudentEntity();
                studentEntity.setName("name:"+defaultClick);
                studentEntity.setAge(defaultClick);
                studentEntity.setPwd("pwd:"+defaultClick);
                long l = studentDao.insertStudent(studentEntity);
                defaultClick++;
                if (l!=0){
                    Log.e("tyl","添加成功");
                }else {
                    Log.e("tyl","添加失败");
                }
            }
        }).start();
    }

    public void deleteData(View view) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                List<StudentEntity> allStudentList = studentDao.getAllStudentList();
                if (allStudentList!=null&&allStudentList.size()!=0){
                    studentDao.deletePerson(allStudentList.get(allStudentList.size()-1));
                }
            }
        }).start();
    }

    public void changeData(View view) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                List<StudentEntity> allStudentList = studentDao.getAllStudentList();
                if (allStudentList!=null&&allStudentList.size()!=0){
                    StudentEntity studentEntity = allStudentList.get(allStudentList.size() - 1);
                    studentEntity.setName("upData");
                    studentEntity.setAge(0);
                    studentDao.updatePerson(studentEntity);
                }
            }
        }).start();
    }

    public void queryData(View view) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                List<StudentEntity> allStudentList = studentDao.getAllStudentList();
                if (allStudentList!=null&&allStudentList.size()!=0){
                    for (int i = 0; i <allStudentList.size() ; i++) {
                        StudentEntity studentEntity = allStudentList.get(i);
                        Log.e("tyl","id:"+studentEntity.getId());
                        Log.e("tyl","name:"+studentEntity.getName());
                        Log.e("tyl","pwd:"+studentEntity.getPwd());
                        Log.e("tyl","age:"+studentEntity.getAge());
                    }
                }
            }
        }).start();
    }
}

implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'

@MyScope
@Component(modules = {DataObject.class})
public interface SecondComponent {
    //使用依赖关系，就不再使用这种语法
//    void inject(MainActivity activity);
    DataObject providerDatabaseObject();
}

@Module
@MyScope
public class DataModule {
    @MyScope
    @Provides
    public DataObject providerDatabaseObject(){
        //........
        return new DataObject();
    }
}

android {
    ...
    buildFeatures {
        dataBinding true
    }
}

public class User {
    private String name;
    private String pwd;
    public User(String name, String pwd) {
        this.name = name;
        this.pwd = pwd;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
}

LiveData是Jetpack组件的一部分，更多的时候是搭配ViewModel来使用，相对于Observable，LiveData的最大优势是其具有生命感知的，
	换句话说，LiveData可以保证只有在组件（ Activity、Fragment、Service）处于活动生命周期状态的时候才会更新数据。
LiveData是一个可观察的数据持有者类，与常规的Observable不同，LiveData可感知Activity、Fragment、Service的生命周期，确保
	LiveData仅更新处于活动生命周期状态的组件观察者。如果应用程序组件观察者处于started或者resumed，则LiveData认为该组件处于
	活跃状态，该组件会收到LiveData的数据更新，而其他注册的组件观察者将不会收到任何数据更新。

1.确保界面符合数据状态
LiveData 遵循观察者模式。当底层数据发生变化时，LiveData 会通知 Observer 对象。您可以整合代码以在这些 Observer 对象中
	更新界面。这样一来，您无需在每次应用数据发生变化时更新界面，因为观察者会替您完成更新。
2.不会发生内存泄漏
观察者会绑定到 Lifecycle 对象，并在其关联的生命周期遭到销毁后进行自我清理。
3.不会因 Activity 停止而导致崩溃
如果观察者的生命周期处于非活跃状态（如返回堆栈中的 activity），它便不会接收任何 LiveData 事件。
4.不再需要手动处理生命周期
界面组件只是观察相关数据，不会停止或恢复观察。LiveData 将自动管理所有这些操作，因为它在观察时可以感知相关的生命周期状态变化。
5.数据始终保持最新状态
如果生命周期变为非活跃状态，它会在再次变为活跃状态时接收最新的数据。例如，曾经在后台的 Activity 会在返回前台后立即接收最新的
数据。
6.适当的配置更改
如果由于配置更改（如设备旋转）而重新创建了 activity 或 fragment，它会立即接收最新的可用数据。
7.共享资源
您可以使用单例模式扩展 LiveData 对象以封装系统服务，以便在应用中共享它们。LiveData 对象连接到系统服务一次，然后需要相应资
源的任何观察者只需观察 LiveData 对象。

请按照以下步骤使用LiveData对象：

1. 创建 LiveData的实例以存储某种类型的数据。这通常在ViewModel类中完成。

2. 创建可定义 onChanged()对象，该方法可以控制当LiveData对象存储的数据更改时会发生什么。通常情况下，您可以在界面控制器
	（如 activity 或 fragment）中创建 Observer对象。

3. 使用 observe()方法将Observer对象附加到 LiveData对象。observe()方法会采用LifecycleOwner对象。这样会使Observer对象
	订阅LiveData对象，以使其收到有关更改的通知。通常情况下，您可以在界面控制器（如 activity 或 fragment）中附加Observer对象。
	
当您更新存储在LiveData对象中的值时，它会触发所有已注册的观察者（只要附加的LifecycleOwner处于活跃状态）。
LiveData允许界面控制器观察者订阅更新。当LiveData对象存储的数据发生更改时，界面会自动更新以做出响应。

public class NameViewModel extends ViewModel {
    // 使用字符串创建LiveData
    private MutableLiveData<String> currentName;
    public MutableLiveData<String> getCurrentName() {
        if (currentName == null) {
            currentName = new MutableLiveData<String>();
        }
        return currentName;
    }
}

public class LiveDataActiviry extends BaseActivity {
    private NameViewModel model;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button button=findViewById(R.id.button);
        Button button2=findViewById(R.id.button2);
        model = new ViewModelProvider(this).get(NameViewModel.class);
        // 创建用于更新UI的观察者
        Observer<String> nameObserver = new Observer<String>() {
            @Override
            public void onChanged(@Nullable String newName) {
                // 更新UI
                button.setText(newName);
            }
        };
        // 观察LiveData，将此活动作为LifecycleOwner和observer传入
        model.getCurrentName().observe(this, nameObserver);
        //更新LiveData对象的值
        button2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String anotherName = "John Doe";
                //主线程传值
                model.getCurrentName().setValue(anotherName);
                //子线程传值
//                new Thread(new Runnable() {
//                    @Override
//                    public void run() {
//                        model.getCurrentName().postValue("anotherName");
//                    }
//                }).start();
            }
        });
    }
}

lifecycle 是属于Android Jetpack（官方开发工具包）—— Architecture（架构组件）中的一员。

官方介绍:构建生命周期感知型组件，这些组件可以根据 Activity 或 Fragment 的当前生命周期状态调整行为。
白话:lifecycle可以和Activity或Fragment生命周期绑定，方便我们做一些跟生命周期相关的业务逻辑。

1.生命周期感知：Lifecycle 可以感知应用组件的生命周期状态，包括活动状态、暂停状态、停止状态等。
2.简化生命周期回调：使用 Lifecycle，可以避免在应用组件中手动实现繁琐的生命周期回调。
3.灵活性：Lifecycle 可以与其他 Jetpack 组件（如 ViewModel、LiveData 等）结合使用，提供更灵活的生命周期管理方案。
4.生命周期安全性：Lifecycle 能够确保在正确的生命周期状态下执行相应的操作，避免了可能导致崩溃或内存泄漏的问题。

通过 Lifecycle，开发者可以更好地管理和控制应用组件的生命周期，执行与生命周期相关的操作，如初始化资源、释放资源、注册/注销观
察者等。它可以帮助开发者编写更健壮、可维护的代码，并提供更好的用户体验。

//androidx
implementation 'androidx.appcompat:appcompat:1.3.0'

   //非androidx
  dependencies {
    def lifecycle_version = "1.1.1"
    // 包含ViewModel和LiveData
    implementation "android.arch.lifecycle:extensions:$lifecycle_version"
    // 仅仅包含ViewModel
    implementation "android.arch.lifecycle:viewmodel:$lifecycle_version" // For Kotlin use viewmodel-ktx
    // 仅仅包含LiveData
    implementation "android.arch.lifecycle:livedata:$lifecycle_version"
    // 仅仅包含Lifecycles
    implementation "android.arch.lifecycle:runtime:$lifecycle_version"
    annotationProcessor "android.arch.lifecycle:compiler:$lifecycle_version" // For Kotlin use kapt instead of annotationProcessor
    // 如果用Java8, 用于替代compiler
    implementation "android.arch.lifecycle:common-java8:$lifecycle_version"
    // 可选，ReactiveStreams对LiveData的支持
    implementation "android.arch.lifecycle:reactivestreams:$lifecycle_version"
    // 可选，LiveData的测试
    testImplementation "android.arch.core:core-testing:$lifecycle_version"
}

package com.example.lifecycledemo1;

import android.arch.lifecycle.Lifecycle;
import android.arch.lifecycle.LifecycleObserver;
import android.arch.lifecycle.OnLifecycleEvent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        getLifecycle().addObserver(new MyObserver());//1
    }
    public class MyObserver implements LifecycleObserver{
        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
        void onResume(){
            Log.d(TAG, "Lifecycle call onResume");
        }
        @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
        void onPause(){
            Log.d(TAG, "Lifecycle call onPause");
        }
    }
    @Override
    protected void onResume() {
        super.onResume();
        Log.d(TAG, "onResume");
    }
    @Override
    protected void onPause() {
        super.onPause();
        Log.d(TAG, "onPause");
    }
}

//使用：被观察者继承BaseActivity或者添加getLifecycle().addObserver(new BaseLifeCycle());即可
public abstract class BaseActivity <T extends BaseLifeCycle> extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getLifecycle().addObserver(new BaseLifeCycle());
    }
}
		
//观察者类
public class BaseLifeCycle implements LifecycleObserver{
    private String TAG="tyl";
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    void onCreate(LifecycleOwner owner) {
        Log.e(TAG, "BaseLifeCycle-onCreate:"+owner.getClass().toString());
    }
		
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void onStart(LifecycleOwner owner) {
        Log.e(TAG, "BaseLifeCycle-onStart:"+owner.getClass().toString());
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    void onStop(LifecycleOwner owner) {
        Log.e(TAG, "BaseLifeCycle-onStop:"+owner.getClass().toString());
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    void onResume(LifecycleOwner owner) {
        Log.e(TAG, "BaseLifeCycle-onResume:"+owner.getClass().toString());
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    void onPause(LifecycleOwner owner) {
        Log.e(TAG, "BaseLifeCycle-onPause:"+owner.getClass().toString());
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    void onDestory(LifecycleOwner owner) {
        Log.e(TAG, "BaseLifeCycle-onDestory:"+owner.getClass().toString());
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    void onAny(LifecycleOwner owner) {//无论当前活动处于何种生命周期状态，都会触发相应的生命周期方法
//        Log.e(TAG, "BaseLifeCycle-onAny:"+owner.getClass().toString());
    }

}

Wine是一个允许在Linux和其他类Unix操作系统上运行Windows应用程序的兼容层。它通过将Windows API转换为本地系统调用来实现这
一目标。使用Wine，用户可以在Linux系统上运行许多Windows应用程序，而无需安装Windows操作系统。
要使用Wine，用户需要首先安装Wine软件包。然后，他们可以使用“wine”命令来运行Windows应用程序。

官网主页：https://wiki.winehq.org/%E4%B8%BB%E9%A1%B5
官网：https://wiki.winehq.org/Download
官网 ubuntu 安装步骤链接：https://wiki.winehq.org/Ubuntu_zhcn

1、如果您使用的是 64 位系统，请开启 32 bit 架构支持（如果您之前没有开启的话）：
   sudo dpkg --add-architecture i386 

2、下载添加仓库密钥：
   sudo mkdir -pm755 /etc/apt/keyrings
   sudo wget -O /etc/apt/keyrings/winehq-archive.key https://dl.winehq.org/wine-builds/winehq.key

3、并添加仓库：
   Ubuntu 22.04:	
      sudo wget -NP /etc/apt/sources.list.d/ https://dl.winehq.org/wine-builds/ubuntu/dists/jammy/winehq-jammy.sources

4、更新安装包：
    sudo apt update

5、然后安装 以下任一一个安装包：
    稳定分支：
        sudo apt install --install-recommends winehq-stable
    开发分支：
        sudo apt install --install-recommends winehq-devel
    Staging 分支：	
        sudo apt install --install-recommends winehq-staging
                
如果 apt-get 提示缺少依赖，请先安装缺少的依赖，然后重复以上两步（update 和 install）。

//遇到依赖问题：
0468:err:mscoree:CLRRuntimeInfo_GetRuntimeHost Wine Mono is not installed
解决方案：
1.将所有软件及系统更新到最新；
2.sudo apt-get install mono-complete
3.上面还是没有安装成功的话则： sudo aptitude install mono-complete //aptitude可能需要安装

1.在软件商城里面搜索安装winetricks。安装后在终端输入winetricks，会打开图形界面设置。
 在winetricks选择一些常用的元件保证常用windows程式的运行。
2.推荐选择的Windows部件主要有：riched20，riched30，ie8，vcrun6，flash11，gdiplus，msls31，msxml6，vcrun2005，vcrun2008，
 winhttp元件。
//有些部件没有，可不安装

winetricks上可以安装字体。也可手动将 Windows 下面的字体复制到~/.wine/drive_c/windows/Fonts/ 。

安装：在exe文件目录，执行：wine xx.exe
卸载：
  运行 wine uninstall.exe往往没用。直接手动删除。
    1、进入 ~/.wine/drive_c(wine的虚拟C盘) 在Program Files 和 Program Files (x86) 找到相应目录删除
    2、进入 ~/.local/share/applications/wine/Programs/ 删除
    3、进入~/.config/menus/applications-merged删除对应文件（这里对应显示的图标）
  如果同时使用 deepin-wine 和 wine，wine下安装的软件目录可能跑到deepin-wine的目录下。 

winelauncher-尝试智能地管理使用Wine启动程序的程序。

wineserver-为Wine提供与Windows内核在Windows上提供的服务大致相同的守护进程。    

这些工具是帮助Wine开发的脚本和可执行文件的集合。在工具目录（例如~/wine git/tools/wineinstall）中，它们作为独立命令调用。

这些命令的完整列表可以在wine-<version>/tools的源代码中找到/

buildimage - 从SVG文件生成位图和图标文件
c2man.pl - 生成API文档
config.guess - 尝试猜测规范系统名称
findfunc - 尝试查找指定的Wine程序/工具
install-sh - 安装程序、脚本或数据文件
makedep - 在构建Wine之前生成makefile和依赖项
make_fir - 生成dsound使用的fir滤波器
make_makefiles - 根据对源树的更改更新configure和Makefile.in文件
make_requests - 更新Wine服务器协议描述文件
make_specfiles - 在发生更改时更新.spec文件
make_unicode - 基于unicode.org中的文件重建unicode表
make_xftmpl - 从.x源文件生成二进制标头
runtest - wapper脚本，用于从构建树内部运行Wine回归测试之一
sfnt2fon - 仅将位图ttf转换为窗口字体文件
wineapploader - 安装Winelib应用程序后启动该应用程序的包装器脚本
wineinstall - Wine安装脚本（上次更新于2009年；不推荐）
winemaker - 帮助将Windows源代码转换为Winelib程序

在Android系统中SystemUI是以应用的形式运行在Android系统当中，即编译SystemUI模块会生产APK文件，源代码路径
在frameworks/base/packages/SystemUI/，安装路径system/priv-app/-SystemUI。

在前文1.1章节中可知，SystemUI是一个普通的APK文件，即是一个普通的APP，但是，手机使用者看见的所有SystemUI的内容都不像是
一个APP，为什么？既然是一个应用，就是完成特定的功能，SystemUI主要完成的功能有：
（1）、Status bars
（2）、Navigation bars
（3）、Notification
（4）、Lockscreen
（5）、Quick settings
（6）、Overview（recent task switcher）
（7）、VolumeUI

状态栏（Status Bar）：显示系统状态信息，如时间、电池电量、信号强度等，并提供快速访问通知和快捷设置的入口。

导航栏（Navigation Bar）：提供设备导航和操作控制，包括返回、主页和最近任务等按钮。

通知管理器（Notification Manager）：负责接收、管理和展示通知，包括应用推送的通知和系统事件的通知。

快捷设置（Quick Settings）：提供快速访问常用系统设置的面板，如Wi-Fi、蓝牙、亮度等，以方便用户进行快速调整。

锁屏界面（Lock Screen）：显示在设备锁定状态下的界面，提供时间、日期、通知预览和快速启动应用等功能。

系统UI控制器（System UI Controller）：作为整个SystemUI的控制中心，负责协调各个组件之间的交互和管理。

其他辅助组件：还有一些辅助组件，如电源管理器、音量控制器等，用于管理设备的电源和音量控制。

Android系统启动流程:
  1.按下电源，系统上电
  2.从固定地址启动固化在ROM的BootLoader程序
  3.启动Linux内核，加载init进程
  4.启动init进程，fork出zygote进程
  5.启动SystemServer，启动Binder线程池以及各种服务
  6.AMS启动Launcher， 然后你就看到该看到的了

//frameworks/base/packages/SystemUI/src/com/android/systemui/SystemUIApplication.java
 public void startServicesIfNeeded() {
        final String vendorComponent = SystemUIFactory.getInstance()
                .getVendorComponent(getResources());
        // Sort the startables so that we get a deterministic ordering.
        // TODO: make #start idempotent and require users of CoreStartable to call it.
        Map<Class<?>, Provider<CoreStartable>> sortedStartables = new TreeMap<>(
                Comparator.comparing(Class::getName));
        sortedStartables.putAll(SystemUIFactory.getInstance().getStartableComponents());
        sortedStartables.putAll(SystemUIFactory.getInstance().getStartableComponentsPerUser());
        startServicesIfNeeded(
                sortedStartables, "StartServices", vendorComponent);
    }