Jetpack学习-Lifecycle

已于 2023-05-29 12:35:14 修改
阅读量218 收藏
点赞数
分类专栏： Jetpack 文章标签： 学习 android java
于 2023-05-27 16:20:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a125679880/article/details/130901875
版权
文章介绍了Android中的Lifecycle组件，用于跟踪Activity和Fragment的生命周期状态，以及如何通过实现LifecycleObserver接口来处理生命周期事件。文中提供了MainActivity、LifecycleService和ProcessLifecycleOwner的使用示例，展示了如何在不同场景下管理组件的生命周期，以优化内存管理和性能。Lifecycle的优势在于简化代码、避免内存泄漏和支持组件复用等。
摘要由CSDN通过智能技术生成

目录

一、Lifecycle介绍

二、使用lifecycle跟踪Activity的生命周期：

MainActivity:

 MyLifecycleObserver:

LifecycleLinstener:

运行结果： 

三、LifecycleService

下面是LifecycleService解耦Service的例子：

添加依赖：

MainActivity:

activity_main:

TaskService:

 MyTaskObserver :

四、ProcessLifecycleOwner监听应用程序的生命周期

ProcessLifecycleOwner使用例子：

添加依赖：

 MyApplication类:

  MyApplicationObserver类 :

在manifest文件中：

 运行结果：

五、Lifecycle的优点

一、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的生命周期，确保它们在不同的场景下都能正确地工作。

敬往事一杯酒哈
关注
专栏目录
Jetpack系列之 ---- Lifecycle原理分析
Lespayne的博客
01-24 1007
Lifecycle的使用和实现原理 这篇文章做为一个Jetpack的学习笔记，用来记录一部分源码原理的学习理解。其中大多数是阅读完源码和别人的文章之后自己总结的，主要为了方便后面的复习，如有不正确的地方，请大佬指出。 一、Lifecycle用来干嘛的？ Lifecycle基于观察者模式设计的，用来监听Activity/Fragment生命周期。 在我们实际代码中 activity fragment 会设计成被观察者，实现lifecycleOwner userClass FromeWorkClass
Jetpack ---- Lifecycle源码解析（2）Lifecycle 的 Event & State
aha_jasper的博客
12-14 521
Jetpack ---- Lifecycle 篇（2）源码分析之 Event & State正文Lifecycle的State和Event分析结语 正文 其实我们知道，归根到底其实源码讲解主要就：基础类介绍，注册源码，发送源码，响应源码 在 Lifecyele 篇 -（1）基础讲解 中，我们讲过三种集成Lifecycle方式,我们上面讲了三种集成方式，其实一个集成方式源码通了，其他都都类似。 本文我们会介绍Lifecycle这个基础类，同时着重讲解State和Event相关知识，因为很多人看过之后，
LifecycleObserver的使用
riqthen的博客
02-09 3316
LifecycleObserver是一个接口, 实现之后可以通过注解, 在activity的生命周期中, 会回调相关的方法 public class ProcessLifecycleObserver implements LifecycleObserver { @OnLifecycleEvent(Lifecycle.Event.ON_CREATE) void onCreate() { } @OnLifecycleEvent(Lifecycle.Event.ON_START
Android架构组件Lifecycle-Aware介绍及使用
秦川小将
03-14 667
关于Lifecycle Lifecycle 是一个持有(如 Activity 或 Fragment )生命周期状态信息的类，并且允许其它对象观察这个状态。从而在外部实现监听，能够使我们及时释放资源，避免内存泄露和程序崩溃。 为什么要使用Lifecycle？ 常见的观察生命周期的方式，如MVP中在 Presenter 中对 Activity 或 Fragment 的生命周期进行观察，我们要...
android LifeCycle-简单使用和详细原理解析
最新发布
2401_86372512的博客
09-05 1011
fun any(){
lifecycle基本使用
qq_52019658的博客
08-24 716
Lifecycle 简单使用
Android生命周期组件Lifecycle使用详解(1)
2401_84121980的博客
04-04 1086
！最后放上一个大概的Android学习方向及思路（详细的内容太多了~），提供给大家：对于程序员来说，要学习的知识内容、技术有太多太多，这里就先放上一部分，其他的内容有机会在后面的文章向大家呈现出来，不过我自己所有的学习资料都整理成了一个文档，一直在不断学习，希望能帮助到大家，也节省大家在网上搜索资料的时间来学习，也可以分享动态给身边好友一起学习！为什么某些人会一直比你优秀，是因为他本身就很优秀还一直在持续努力变得更优秀，而你是不是还在满足于现状内心在窃喜！Android架构师之路很漫长，一起共勉吧！
Lifecycle使用与分析-基础
weixin_34081595的博客
06-16 1940
Lifecycle是一个持有组件生命周期状态信息的类,并且允许其他对象观察该状态. 本文基于 Lifecycle 2.0.0版本，Android API 28. 首先我们先看一下如何使用Lifecycle实现生命周期的监听. 基础用法 public class HippoX implements LifecycleObserver { private static final Str...
Jetpack学习之Lifecycle
gxlgxjhll的博客
02-26 177
  Jetpack是Google为了解决Android架构问题而引入的，Google官方说的说法：“Jetpack是一套库、工具和指南，可以帮助开发者更轻松地编写应用程序。Jetpack中的组件可以帮助开发者遵循最佳做法、摆脱编写样板代码的工作并简化复杂的任务，以便他们能将精力集中放在业务所需的代码上。”   Jetpack主要包括4个方面，分别是架构（Architecture）、界面（UI）、行为（Behavior）和基础（Foundation）。 在项目中的gradle.properties文件中， /
Jetpack学习之 Lifecycle
RikkaTheWorld
03-14 239
Lifecycle 用于帮助开发者管理 Activity 和 Fragment 的生命周期，由于 Lifecycle 是 LiveData 和 ViewModel的基础， 所以要了解后面那两位，需要先学习 Lifecycle。 目录1. 概述1.1 Lifecycle定义1.2 为什么使用Lifecycle2. 使用2.1 导入 1. 概述 1.1 Lifecycle定义 Lifecycle 组件用来感知另外一个组件（Activity、Application、Fragment）的生命周期。 1.2 为什么
使用lifecycle解耦组件和service
qq_43867812的博客
11-17 950
使用lifecycle解耦组件和service，这里使用的是通过service获取位置信息，点击按钮获取，点击按钮结束获取。这里的逻辑就是获取位置信息。有两个方法：startGetLocation()和startGetLocation()。Service代码，这里我们需要继承lifecycleService，这个库需要我们导入依赖。Activity代码，开启service和结束service。信息打印成功，实现了组件和service的解耦。
JetPack 查漏补缺
OCNYang
04-16 334
JetPack 查漏补缺JetPack 查漏补缺LifeCycle 相关LifecycleServiceProcessLifecycleOwnerNavigation 相关NavigationUIDeepLinkViewModel 相关原理实例化AndroidViewModelLiveData 相关数据共享LiveData.observeForever() JetPack 查漏补缺 本文只介绍 JetPack 学习中你可能需要注意或者你注意不到的知识点，需要你需要你有一定的 JetPack 基础。 Lif
Jetpack 之 LifeCycle 组件使用详解
鸿蒙开发知识记录
09-16 2458
一、LifeCycle 简介 LifeCycle 是一个可以感知宿主生命周期变化的组件。常见的宿主包括 Activity/Fragment、Service 和 Application。LifeCycle 会持有宿主的生命周期状态的信息，当宿主生命周期发生变化时，会通知监听宿主的观察者。 LifeCycle 的出现主要是为了解决： 系统组件的生命周期与普通组件之间的耦合性。 系统组件指：Activity/Fragment、Service 和 Application。 普通组件指：将代码按照功能或者作用封装成
Android-Lifecycle超能解析-生命周期的那些事儿
weixin_42822760的博客
09-15 749
众所周知，Android凡是需要展示给用户看的，都包含着生命周期这个概念，例如Activity、Fragment、View等都与生命周期息息相关，在生命周期函数里，它们各自完成创建、渲染、销毁等工作。 但是一旦我们往某个生命周期函数中，加入我们自己的逻辑，若是处理不当，就有可能破坏其原有的生命周期，造成内存泄漏甚至应用崩溃等问题。 Android官方似乎也注意到了这一点，...
JetPack组件--LifeCycle生命周期组件详解
2401_84010836的博客
03-31 636
它是JetPack其他组件的基础，如JetPack中的LiveData就用到了该组件，实现了Activity在后台时不回调事件，在Activity销毁时自动取消对Activity解除观察的功能为什么要进行生命分发我们使用具备Android生命周期组件时经常可能遇到以下场景1，需要在Activity的onCreate()方法通知成员变量进行初始化（如MVP中的presenter,AudioManager等）
Jetpack 之 LifeCycle 组件使用详解，最新BAT大厂面试者整理的Android面试题目模板
code8889的博客
03-28 796
Android 中拥有生命周期的组件除了 Activity/Fragment ，还有一个非常重要的组件就是 Service。LifecycleService 就是用来监听和解耦 Service 组件的。@Override@NonNull/**在应用程序的整个生命周期中只会被调用一次*//**永远不会被调用，系统不会分发调用 ON_DESTROY 事件*/
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值