目录
下面是LifecycleService解耦Service的例子：
四、ProcessLifecycleOwner监听应用程序的生命周期
一、Lifecycle介绍
Android中的Lifecycle是用来跟踪Activity和Fragment的生命周期状态的。它提供了一种机制，让开发者可以在Activity或Fragment的不同生命周期状态下执行相应的操作，比如在onCreate()方法中初始化数据，在onResume()方法中启动动画等。通过实现LifecycleObserver接口，可以让一个类成为Lifecycle的观察者，从而在Activity或Fragment的生命周期状态发生变化时得到通知。Lifecycle的使用可以帮助开发者更好地管理Activity和Fragment的生命周期，避免内存泄漏等问题。
跟踪生命周期主要由：状态和事件 这两个表示。如下图：
Lifecycle的状态可以分为以下几种：
1. ON_CREATED：组件已经被创建，但是还没有被启动。
2.ON_ STARTED：组件已经被启动，但是还没有被恢复。
3. ON_RESUMED：组件已经被恢复，处于前台运行状态。
4.ON_ PAUSED：组件已经被暂停，但是仍然可见。
5. ON_STOPPED：组件已经被停止，不再可见。
6. ON_DESTROYED：组件已经被销毁，不再存在。
在处理组件状态变化时，可以使用LifecycleObserver接口(该接口里面没有方法)和@OnLifecycleEvent注解来监听组件的生命周期事件。例如：
public class MyActivity extends AppCompatActivity implements LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
public void onCreate() {
// 处理组件创建事件
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
public void onStart() {
// 处理组件启动事件
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
public void onResume() {
// 处理组件恢复事件
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
public void onPause() {
// 处理组件暂停事件
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
public void onStop() {
// 处理组件停止事件
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
public void onDestroy() {
// 处理组件销毁事件
}
}通过实现LifecycleObserver接口和使用@OnLifecycleEvent注解，可以方便地监听组件的生命周期事件，并在相应的事件发生时做出相应的处理。
二、使用lifecycle跟踪Activity的生命周期：
MainActivity:
package com.example.lifecycledemo;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.widget.Toast;
public class MainActivity extends AppCompatActivity {
MyLifecycleObserver mObserver;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mObserver = new MyLifecycleObserver();
// 添加观察者
getLifecycle().addObserver(mObserver);
}
@Override
protected void onStart() {
super.onStart();
showMessage("onStart()");
}
@Override
protected void onResume() {
super.onResume();
showMessage("onResume()");
}
@Override
protected void onPause() {
super.onPause();
showMessage("onPause()");
}
@Override
protected void onStop() {
super.onStop();
showMessage("onStop()");
}
@Override
protected void onDestroy() {
super.onDestroy();
showMessage("onDestroy()");
}
public void showMessage(String msg){
Log.i("MainActivity的生命周期为：", msg);
}
}MyLifecycleObserver:
package com.example.lifecycledemo;
import android.util.Log;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;
public class MyLifecycleObserver implements LifecycleListener,LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_START)
@Override
public void onStart() {
showMessage("ON_START");
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
@Override
public void onResume() {
showMessage("ON_RESUME");
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
@Override
public void onPause() {
showMessage("ON_PAUSE");
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
@Override
public void onStop() {
showMessage("ON_STOP");
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
@Override
public void onDestroy() {
showMessage("ON_DESTROY");
}
public void showMessage(String msg){
Log.i("Observer的生命周期为：", msg);
}
}
LifecycleLinstener:
package com.example.lifecycledemo;
public interface LifecycleListener {
void onStart();
void onResume();
void onPause();
void onStop();
void onDestroy();
}
运行结果：
三、LifecycleService
Android LifecycleService是一个Service，它可以感知应用程序的生命周期并在其生命周期内执行相应的操作。它是在Android 8.0（API级别26）中引入的，旨在帮助开发人员更好地管理应用程序的内存和性能。
LifecycleService继承自Service，并实现了LifecycleOwner和LifecycleObserver接口。LifecycleOwner接口表示具有生命周期的组件，LifecycleObserver接口表示观察生命周期事件的组件。
LifecycleService可以通过LifecycleObserver接口观察应用程序的生命周期事件，例如应用程序进入后台或前台、应用程序被销毁等。开发人员可以在这些事件发生时执行相应的操作，例如释放资源、保存数据等。
使用LifecycleService可以帮助开发人员更好地管理应用程序的内存和性能，提高应用程序的稳定性和用户体验。
下面是LifecycleService解耦Service的例子：
添加依赖：
implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'
MainActivity:
package com.example.lifecycledemo2;
import androidx.appcompat.app.AppCompatActivity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
public void startTask(View view) {
startService(new Intent(this,TaskService.class));
}
public void stopTask(View view) {
stopService(new Intent(this,TaskService.class));
}
}activity_main:
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<Button
android:id="@+id/startGPS"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="开始任务"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
android:onClick="startTask"
/>
<Button
android:id="@+id/button2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="停止任务"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.498"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.617"
android:onClick="stopTask"
/>
</androidx.constraintlayout.widget.ConstraintLayout>
TaskService:
package com.example.lifecycledemo2;
import androidx.lifecycle.LifecycleService;
public class TaskService extends LifecycleService {
public TaskService(){
// 添加观察者
MyTaskObserver observer = new MyTaskObserver(this);
getLifecycle().addObserver(observer);
}
}
MyTaskObserver :
package com.example.lifecycledemo2;
import android.content.Context;
import android.util.Log;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;
import java.util.Timer;
import java.util.TimerTask;
public class MyTaskObserver implements LifecycleObserver {
Context mContext;
Timer mTimer;
TimerTask mTimerTask;
public MyTaskObserver(Context context) {
mContext = context;
}
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
public void startTask() {
mTimer = new Timer();
mTimerTask = new TimerTask() {
int i = 0;
@Override
public void run() {
i++;
Log.d("MyTaskObserver", "startTask: " + i);
}
};
mTimer.schedule(mTimerTask, 0, 1000);
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
public void stopTask() {
if (mTimer != null) {
mTimer.cancel();
}
Log.d("MyTaskObserver", "stopTask: ");
}}上述代码实现了一个后台任务的生命周期管理，通过实现LifecycleObserver接口和使用@OnLifecycleEvent注解，可以在任务开始和结束时执行相应的操作。TaskService继承自LifecycleService，可以获取到当前任务的生命周期状态，并且添加MyTaskObserver观察者，实现任务的启动和停止。MyTaskObserver中定义了一个定时器任务，在任务启动时开始执行，每隔1秒输出一次日志，任务停止时取消定时器任务。这样可以保证任务在后台运行时不会一直占用资源，同时在任务不需要时及时释放资源。
四、ProcessLifecycleOwner监听应用程序的生命周期
Android ProcessLifecycleOwner 是 Android Architecture Components 中的一个类，用于帮助开发者管理应用程序的生命周期。它是一个单例类，可以在应用程序的整个生命周期中跟踪应用程序的前台和后台状态，并在应用程序进入后台时触发回调方法。
ProcessLifecycleOwner 可以通过添加依赖库 "androidx.lifecycle:lifecycle-process" 来使用。在应用程序的 Application 类中，可以通过以下方式获取 ProcessLifecycleOwner 实例：
ProcessLifecycleOwner.get().getLifecycle().addObserver(yourObserver);
其中，yourObserver 是实现了 LifecycleObserver 接口的观察者对象，可以在其回调方法中处理应用程序的前台和后台状态变化。
ProcessLifecycleOwner 可以帮助开发者更好地管理应用程序的生命周期，例如在应用程序进入后台时停止一些后台任务，以节省资源和电量。
ProcessLifecycleOwner使用例子：
添加依赖：
implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'MyApplication类:
package com.example.lifecycle_location_demo;
import android.app.Application;
import androidx.lifecycle.ProcessLifecycleOwner;
public class MyApplication extends Application {
@Override
public void onCreate() {
super.onCreate();
// 监听程序的生命周期
MyApplicationObserver mObserver = new MyApplicationObserver();
ProcessLifecycleOwner.get().getLifecycle().addObserver(mObserver);
}
}
MyApplicationObserver类 :
package com.example.lifecycle_location_demo;
import android.util.Log;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;
public class MyApplicationObserver implements LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
public void onCreate(){
showMessage("Lifecycle.Event.ON_CREATE");
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
public void onStart(){
showMessage("Lifecycle.Event.ON_START");
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
public void onResume(){
showMessage("Lifecycle.Event.ON_RESUME");
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
public void onPause(){
showMessage("Lifecycle.Event.ON_PAUSE");
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
public void onStop(){
showMessage("Lifecycle.Event.ON_STOP");
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
public void onDestroy(){
showMessage("Lifecycle.Event.ON_DESTROY");
}
public void showMessage(String msg){
Log.d("MyApplicationObserver", "showMessage: "+msg);
}
}
在manifest文件中：
运行结果：
（1）、打开程序：
（2）、退出程序:
(3)、重新打开程序：
由此可见：程序不会执行onDestroy()方法。
五、Lifecycle的优点
Android中的Lifecycle是一个非常重要的组件，它可以帮助开发者更好地管理Activity和Fragment的生命周期。以下是Lifecycle的优点：
1. 简化代码：
使用Lifecycle可以让开发者更轻松地管理Activity和Fragment的生命周期，避免了手动管理生命周期的繁琐代码。
2. 避免内存泄漏：
Lifecycle可以帮助开发者避免内存泄漏，因为它可以自动处理Activity和Fragment的生命周期，确保它们在不需要时被正确地销毁。
3. 支持组件复用：
Lifecycle可以帮助开发者更好地支持组件复用，因为它可以自动处理组件的生命周期，确保它们在不同的场景下都能正确地工作。
4. 支持异步任务：
Lifecycle可以帮助开发者更好地支持异步任务，因为它可以自动处理Activity和Fragment的生命周期，确保它们在异步任务完成后正确地处理结果。
5. 支持测试：
Lifecycle可以帮助开发者更好地进行单元测试，因为它可以模拟Activity和Fragment的生命周期，确保它们在不同的场景下都能正确地工作。
扫一扫
513
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
