Android_Jetpack学习之路二（Lifecycle组件）

最新推荐文章于 2024-04-16 03:28:15 发布
最新推荐文章于 2024-04-16 03:28:15 发布
阅读量186 收藏
点赞数
分类专栏： Jetpack 文章标签： android 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuxiangsheng911/article/details/128920535
版权
文章介绍了如何使用AndroidJetpack中的LifeCycle组件来解耦Activity、Service与自定义组件，例如LocationService。通过实现LifecycleObserver接口并在特定生命周期方法上添加注解，自定义组件能自动响应Activity或Service的生命周期变化，从而简化代码并提高组件的复用性。
摘要由CSDN通过智能技术生成

Android_Jetpack学习之路二（LifeCycle组件）

LifeCycle组件

LifeCycle可以让我们自定义的类能主动感知到Activity、Fragment、Application、Service等系统组件的生命周期。
我们以百度定位为例，我们一般在Activity生命周期的oncreate回调函数里调用 自定义类LocationService的start()方法，在onStop回调里调用LocationService的stop() 方法来启动和停止定位服务。
那么，我们可不可以解开Activity生命周期函数与LocationService的耦合性能？
答案是，利用LifeCycle让LocationService作为观察者，能感知到Activity的声明周期,当acitivty执行到onCreate与onStop时，LocationService自动调用它内部的start()与stop()方法来启动和停止定位，而无需再在activity里写调用LocationService.start()与LocationService.stop的代码了。当然这里的被观察者自然就是acitivty了。
,当acitivty执行到onCreate与onStop时，LocationService自动调用它内部的start()与stop()方法来启动和停止定位。

使用LifeCycle解耦Activity与自定义组件

让自定义类（或者称作自定组件）实现LifecycleObserver，在要执行的函数start()和stop()上面添加注解@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)与 @OnLifecycleEvent(Lifecycle.Event.ON_STOP) 。

/**
 * 封装了定位的开启和停止
 */
public class LocationService implements LifecycleObserver {
    String TAG = getClass().getSimpleName();
    /**
     * 开始定位
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void start(){
        Log.d(TAG,"location Service start...");
    }
    /**
     * 停止定位
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void stop(){
        Log.d(TAG,"location Service stop...");
    }

}

在一个Activity中new一个自定义类的对象实例，如LocationService类对象locationService.将getLifecycle().addObserver
locationService将观察者与被观察者绑定

        LocationService locationService = new LocationService();
        getLifecycle().addObserver(locationService);

运行项目，对这个Activity进行开启和结束操作就可以得到运行结果：

2023-03-09 11:18:53.622 6528-6528/com.lxs.lifecycle D/TestActivity: Activity onStart...
2023-03-09 11:18:53.622 6528-6528/com.lxs.lifecycle D/LocationService: location Service start...
2023-03-09 11:18:56.353 6528-6528/com.lxs.lifecycle D/LocationService: location Service stop...
2023-03-09 11:18:56.354 6528-6528/com.lxs.lifecycle D/TestActivity: Activity onStop...

LifeCycle中Event中分别对应了activity中的各个生命周期

    public enum Event {
        ON_CREATE,
        ON_START,
        ON_RESUME,
        ON_PAUSE,
        ON_STOP,
        ON_DESTROY,
        ON_ANY
    }

我们可以发现使用Lifecycle提高了自定义组件的复用性，降低可以自定义组件与Activity等系统组件的耦合性，不需要在Activity的onStop()等方法中进行关闭操作等等。

使用LifeCycle解耦Service与自定义组件

关键步骤：build.gradle中引入依赖

implementation “androidx.lifecycle:lifecycle-extensions:2.2.0”
  1. Service处理
    让我们的Service继承于LifecycleService(LifecycleService实际上就是Service 实现LifecycleOwner接口）getLifecycle().addObserve()将观察者与被观察者绑定，即将自定义类与Service绑定。
    在这里插入图片描述
public class MyService extends LifecycleService {
    LocationService locationService;
    String TAG =getClass().getSimpleName();
    public MyService() {
        locationService = new LocationService();
        getLifecycle().addObserver(locationService);
    }
    @Override
    public void onCreate() {
        Log.i(TAG,"onCreate");
        super.onCreate();
    }

    @Override
    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        Log.i(TAG,"onStartCommand");
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        Log.i(TAG,"onDestroy");
        super.onDestroy();
    }
}

自定义类实现LifecycleObserver接口，添加标签注解事件@OnLifecycleEvent，感知Service的声明周期。

public class LocationService implements LifecycleObserver {
    String TAG = getClass().getSimpleName();
    /**
     * 开始定位
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void start(){
        Log.d(TAG,"location Service start...");
    }
    /**
     * 停止定位
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void stop(){
        Log.d(TAG,"location Service stop...");
    }

    /**
     * 停止定位: 用于感知Service的onDestroy声明周期
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void stopLoc()
    {
        Log.i(TAG,"location Service destroy...");
    }
}

启动和停止service可以得到运行结果：

2023-03-09 15:13:42.645 17116-17116/com.lxs.lifecycle I/MyService: onCreate
2023-03-09 15:13:42.646 17116-17116/com.lxs.lifecycle I/MyService: onStartCommand
2023-03-09 15:13:42.646 17116-17116/com.lxs.lifecycle D/LocationService: location Service start...
2023-03-09 15:13:44.574 17116-17116/com.lxs.lifecycle I/MyService: onDestroy
2023-03-09 15:13:44.574 17116-17116/com.lxs.lifecycle D/LocationService: location Service stop...
2023-03-09 15:13:44.575 17116-17116/com.lxs.lifecycle I/LocationService: location Service destroy...

Service销毁时会执行LifecycleService的onDestory()，会同事完成Lifecycle.Event.ON_STOP和Lifecycle.Event.ON_DESTROY两个事件（使用Runnable,所以上面运行结果中LocationService的stop和destroy会出现在MyService的onDestroy()后面）
在这里插入图片描述
在这里插入图片描述

使用ProcessLifecycleOwner感知Application

Lifecycle同样可以观察整个进程的生命周期，就是ProcessLifecycleOwner（即进程生命周期拥有者）.
同样需要依赖：

implementation “androidx.lifecycle:lifecycle-extensions:2.2.0”

MyApplication 继承Application，ProcessLifecycleOwner.getLifecycle().addObserver()将观察者与被观察者绑定，即将自定义类ApplicationObserver与MyApplication绑定。

public class MyApplication extends Application {
    ApplicationObserver applicationObserver;

    @Override
    public void onCreate() {
        Log.d("MyApplication","MyApplication onCreate...");
        applicationObserver = new ApplicationObserver();
        ProcessLifecycleOwner.get().getLifecycle().addObserver(applicationObserver);
        super.onCreate();
    }

}
  1. 自定义类ApplicationObserver实现LifecycleObserver接口，添加标签注解事件，感知Application的声明周期。
public class ApplicationObserver implements LifecycleObserver {
    String TAG = getClass().getSimpleName();

    /**
     * 整个应用程序只感知1次
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate()
    {
        Log.i(TAG,"ApplicationObserver onCreate...");
    }

    /**
     * 应用程序打到前台
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart()
    {
        Log.i(TAG,"ApplicationObserver onStart...");
    }

    /**
     * 应用程序打到前台
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume()
    {
        Log.i(TAG,"ApplicationObserver onResume...");
    }



    /**
     * 应用程序退到后台
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause()
    {
        Log.i(TAG,"ApplicationObserver onPause...");
    }

    /**
     * 应用程序退到后台
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop()
    {
        Log.i(TAG,"ApplicationObserver onStop...");
    }
    /**
     * 应用程序销毁,感知不到
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy()
    {
        Log.i(TAG,"ApplicationObserver onDestroy...");
    }
}

运行项目然后退出前台之后得到运行结果


2023-03-09 16:08:48.438 24071-24071/com.lxs.lifecycle D/MyApplication: MyApplication onCreate...
2023-03-09 16:08:48.441 24071-24071/com.lxs.lifecycle I/ApplicationObserver: ApplicationObserver onCreate...
2023-03-09 16:08:48.555 24071-24071/com.lxs.lifecycle I/MainActivity: onCreate
2023-03-09 16:08:48.558 24071-24071/com.lxs.lifecycle I/MainActivity: onStart
2023-03-09 16:08:48.559 24071-24071/com.lxs.lifecycle I/ApplicationObserver: ApplicationObserver onStart...
2023-03-09 16:08:48.561 24071-24071/com.lxs.lifecycle I/MainActivity: onResume
2023-03-09 16:08:48.564 24071-24071/com.lxs.lifecycle I/ApplicationObserver: ApplicationObserver onResume...
2023-03-09 16:09:04.977 24071-24071/com.lxs.lifecycle I/MainActivity: onResume
2023-03-09 16:09:05.651 24071-24071/com.lxs.lifecycle I/MainActivity: onStop
2023-03-09 16:09:05.655 24071-24071/com.lxs.lifecycle I/MainActivity: onDestroy
2023-03-09 16:09:05.686 24071-24071/com.lxs.lifecycle I/ApplicationObserver: ApplicationObserver onPause...
2023-03-09 16:09:05.686 24071-24071/com.lxs.lifecycle I/ApplicationObserver: ApplicationObserver onStop...

以上就是Lifecycle的基本用法

夏去复立秋
关注
专栏目录
android LifeCycle解耦service 组件
xq610928的博客
04-26 1487
前言： 各位同学大家好，相信各位同学在开发安卓的时候都有用过四大组件之一的service吧 今天我们就通过一个获取gps 定位的小案例来讲一下用 LifeCycle解耦service 组件 需要用到的三方库 implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0' 具体实现： 创建我们的 MylocationObserver 继承 LifecycleObserver package com.example.lifecycle
Android_Jetpack:LifeCycle在Activity/Fragment、Service以及Application中的应用
nanquan11的博客
11-18 803
Android_Jetpack:LifeCycle在Activity/Fragment、Service以及Application中的应用一、使用LifeCycle解耦Activity/Fragment与组件二、使用LifeCycleService解耦Service与组件三、使用ProcessLifecycleOwner监听应用程序的生命周期 最近重新捡起了Android开发，对Jetpack很感兴趣，就专门研究了下。这篇主要讲的就是系统组件与普通组件解耦的LifeCycle。LifeCycle可以帮助开发者
安卓架构组件实战——Lifecycle
king的专栏
11-28 381
注：本文涉及代码请看：项目源码 Lifecycle是谷歌推出的一个架构组件，用于感知组件生命周期，并赋予了非组件对象感知生命周期的能力 Lifecycle组件用来响应另一个组件的生命周期状态变化，例如Activity和Fragment，可以帮助非生命周期组件跟Activity、Fragment或Service的生命周期关联在一起，从而在不同生命周期内执行相应操作。其他说明请参考谷歌官网文档Li...
android Jetpack之Lifecycle的使用
ScottePerk的博客
05-23 1789
Lifecycle是Jetpack提供的一个用于监听生命周期的库。我们知道在使用Activity和Fragment的时候，特别是两者一起使用的时候，生命周期将变得非常的复杂。而且我们需要在Activity和Fragment的生命周期方法里面执行非常多的操作，如地理位置，打开关闭资源等。这会造成很高的耦合。Lifecycle就是为了减低生命周期的耦合而设计的。目的是让各种资源自己监听生命周期变化，在独立的类里面实现相应的生命周期逻辑。 Lifecycle已经包含在androidx里面，也就是下面的包，默认情况
Android-Jetpack架构组件（二）带你了解Lifecycle（使用篇）
最新发布
2401_84121663的博客
04-16 545
如果想实现自定义LifecycleOwner，可以使用LifecycleRegistry，它是Lifecycle的实现类。Android Support Library 26.1.0及其之后的版本，Activity和Fragment已经默认实现了LifecycleOwner接口，因此我们可以这么写：@Override。
Android Jetpack架构组件Lifecycle详解
01-03
Lifecycle是Jetpack架构组件中用来感知生命周期的组件，使用Lifecycles可以帮助我们写出和生命周期相关更简洁更易维护的代码。 生命周期 生命周期这个简单而又重要的知识相信大家早已耳熟能详。假设我们现在有这样...
一文搞懂Android-JetPack组件原理之Lifecycle、LiveData、ViewModel与源码分析技巧
m0_66265031的博客
02-04 1984
2. 手动postValue或setValue触发数据通知 接下来，便以这两个任务链的顺序，对每个方法进行分析。 observer()注册监听者 @MainThread public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) { assertMainThread(“observe”); if (owner.getLifecycle().getCurrentState() =
详解Jetpack 源码分析之Lifecycle 组件
weixin_43901866的博客
02-08 719
Jetpack 介绍 Jetpack 是一系列组件的集合，用于帮助开发者更加容易开发出高质量的 APP，这些组件帮助我们统一遵循最佳实践，这些最佳实践统一由组件实现，开发只需要使用这些组件即可，这样的话开发高质量的 App 就更加简单了。这些组件还可以帮助我们减少模板代码，简化复杂任务，让开发者更加专注于业务代码。 在 Android 开发者官网 中已经将 Jetpack、Kotlin、Andro...
Android_Jetpack:Navigation组件之深层链接DeepLink的使用
nanquan11的博客
11-21 2556
DeepLink有两种应用场景，一种是PendingIntent，另一种是真实的URL链接，利用这两种方式都可以跳转到程序中指定的页面。 一、PendingIntent方式 PendingIntent方式一般用在通知中。当应用程序接收到某个通知时，并且希望用户在单击该通知时直接跳转到到展示该通知的页面，就可以通过PendingIntent来完成。 以下代码实现的功能是，在MainActivity中单击按钮弹出通知栏，点击通知栏跳转到指定NotificationActivity页面中，这里Notificati
Android-Jetpack架构组件（二）带你了解Lifecycle，给2021的移动开发一些建议
flutter001的博客
12-31 266
@Override protected void onResume() { super.onResume(); myPresenter.onResume(); } @Override protected void onPause() { super.onPause(); myPresenter.onPause(); } } class MyPresenter{ 《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》 【docs.qq.com/doc/DSkNLaERkbnFo
Android Jetpack学习（一）--Lifecycles
飞兔的博客
07-23 413
一、Jetpack是什么 Jetpack是Google为了解决Android架构问题而引入的一套库、工具和指南，可以帮助开发者更轻松地编写应用程序。Jetpack包含了架构组件、基础组件、行为组件和界面组件；这里主要介绍架构组件的学习，最后再介绍google官方推出的架构。 架构组件包含了： Lifecycles 生命周期感知型组件可执行操作来响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。 Navigation 它管理应用中多个屏幕之间的复杂导航、过渡动画、深层链接以及
Android Jetpack应用指南学习笔记1之Lifecycle的简单使用
u012556114的博客
08-23 1661
AndroidJetPack应用指南学习笔记1——LifeCycle的简单使用 1.LifeCycle的引入： 在App的build.gradle目录下添加如下依赖： implementation “androidx.lifecycle:lifecycle-extensions:2.2.0” 2.创建Service服务继承LifecycleService，因为LifecycleService是Service子类，和Service使用上没什么区别 创建服务的观察者：
你要的进阶，Jetpack核心组件Lifecycle的使用和源码解析
Gaga246的博客
08-01 215
Lifecycle是Android Architecture Components的一员,这玩意儿挺方便的,它是能感知Activity和Fragment的生命周期的.
Android端MVVM从入门到实战（第六篇） - LifeCycle使用详解
wccadab的博客
04-28 742
相比于DataBinding，剩下的三个组件就要简单的多，这一章我们先来详细了解一下LifeCycle的更多知识。
Android jetpack LifeCycle 在Application中的应用
丿灬安之若死
05-18 565
先写一个类继承观察者 并增加注解 package com.anguomob.jecpack.observer import android.util.Log import androidx.lifecycle.Lifecycle import androidx.lifecycle.LifecycleObserver import androidx.lifecycle.OnLifecycleEvent class ApplicationObserver : LifecycleObserver {
Android~Unable to get provider androidx.lifecycle.ProcessLifecycleOwnerInitializer
热门推荐
Hynson的学习笔记
12-18 1万+
在新项目中已开始迁移到Androidx遇到Unable to get provider androidx.lifecycle.ProcessLifecycleOwnerInitializer错误，APP在安卓4.4上面启动奔溃，记录解决办法。参考原文 在安卓4.4中，这是一个dex问题。解决办法是 1、在app.gradle中，defaultconfig内启用multidex defaultCo...
Jetpack——Lifecycle源码解析
GeofferySun的专栏
11-10 2991
一、Lifecycle是什么？ 传送门：Lifecycle 官网文档是学习最好的资料 Lifecycle 是构建生命周期感知型组件，这些组件可以根据 Activity 或 Fragment 的当前生命周期状态调整行为。生命周期感知型组件可执行操作来响应另一个组件的生命周期状态的变化。这些组件有助于您写出更有条理且往往更精简的代码，这样的代码更易于维护。可以有效避免内存泄漏，解决Android生命周期常见难题。Lifecycle框架使用观察者模式监听被观察者的生命周期的变化。 Lifecycle 框架涉及
Jetpack Lifecycle揭秘：Android组件高效管理的关键
"Jetpack全家桶中的Lifecycle模块是Android开发中的一个重要概念，它旨在帮助开发者更好地管理和组织组件的生命周期，从而提高代码的可维护性和效率。在Android应用中，组件如Activity和Fragment通常会经历一系列的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值