Android笔记（七）Jetpack组件库

已于 2022-07-08 17:40:28 修改
阅读量971 收藏
点赞数 3
分类专栏： android笔记 文章标签： android kotlin 开发语言 android jetpack
于 2022-07-08 13:08:22 首次发布
// by Frms https://blog.csdn.net/qq_39751227?type=blog
本文链接：https://blog.csdn.net/qq_39751227/article/details/125657046
版权

Jetpack组件库

ViewMode

 是专门存放与界面相关数据的，只要是界面看得到的数据，都应该存放在ViewMode中。
 它的一个重要特性是，只有当界面退出时才会被销毁，界面的旋转不会被重新创建。

一般创建方法

  1. 弃用 ViewModelProviders.of()：已弃用 ViewModelProviders.of()。您可以将 Fragment 或 FragmentActivity 传递给新的 ViewModelProvider(ViewModelStoreOwner)构造函数，以便在使用 Fragment 1.2.0 时实现相同的功能。

  2. 弃用 lifecycle-extensions 工件：在上面弃用ViewModelProviders.of()后，此版本标志着弃用 lifecycle-extensions 中的最后一个 API，因此现在该工件已完全被弃用。我们强烈建议依赖于您需要的特定 Lifecycle 工件（例如，如果您使用的是 LifecycleService，则依赖于 lifecycle-service；如果您使用的是 ProcessLifecycleOwner，则依赖于 lifecycle-process）而不是 lifecycle-extensions，因为将来不会有 lifecycle-extensions 的 2.3.0 版本。

  3. Activity/Frangment只能获取viewMode实例，而不能创建，因为后者周期长于前两者，这样会导致重复创建的可能。

  4. 更多创建用法见：创建ViewMode

先定义一个字段用于计数：

class MainActivityViewMode : ViewModel()
{
	var counter = 0
}

再于mainactivity写入：

class MainActivity : AppCompatActivity()
{
	private lateinit var textView: TextView

	lateinit var viewMode: MainActivityViewMode

	@SuppressLint("SetTextI18n")
	@RequiresApi(Build.VERSION_CODES.S)
	override fun onCreate(savedInstanceState: Bundle?)
	{
		super.onCreate(savedInstanceState)
		// 获取实例，不能创建
		viewMode = ViewModelProvider(this)[MainActivityViewMode::class.java]

		...
		linearLayout.addView(Button(this).apply {
			setOnClickListener {
				viewMode.counter++
				refreshCount()
			}
		})
		// 创建时刷新
		refreshCount()
		...
	}

	private fun refreshCount()
	{
		textView.text = viewMode.counter.toString()
	}

}

向ViewMode传递值

 上文的默认值是0，有没有办法在初始时，赋予默认值给viewMode呢？这就是本篇要介绍的情况。
 下述代码就能保证不管程序进入后台还是退出，计数器值都不会丢失

// 在构造器添加需要初始化赋予的对象或类型
class MainActivityViewMode(countReserved : Int) : ViewModel()
{
	var counter = countReserved
}

class MainViewModeFactory(
		private val countReserved: Int
) : ViewModelProvider.Factory
{
	override fun <T : ViewModel> create(modelClass: Class<T>): T
	{
		// 因为这里实例化执行时机和Activity/Fragment生命周期无关，
		// 所以可以创建
		return MainActivityViewMode(countReserved) as T
	}
}

对应地，只需要修改下列代码就能完成操作：

viewMode = ViewModelProvider(
				this,
				MainViewModeFactory(countReserved)
		)[MainActivityViewMode::class.java]

完整代码：

class MainActivity : AppCompatActivity()
{
	private lateinit var textView: TextView

	lateinit var viewMode: MainActivityViewMode
	lateinit var sp : SharedPreferences

	@SuppressLint("SetTextI18n")
	@RequiresApi(Build.VERSION_CODES.S)
	override fun onCreate(savedInstanceState: Bundle?)
	{
		super.onCreate(savedInstanceState)

		sp = getPreferences(Context.MODE_PRIVATE)
		val countReserved = sp.getInt("counter", 0)

		viewMode = ViewModelProvider(
				this,
				MainViewModeFactory(countReserved)
		)[MainActivityViewMode::class.java]

		val scrollView = ScrollView(this)
		val linearLayout = LinearLayout(this)
		linearLayout.orientation = LinearLayout.VERTICAL
		scrollView.addView(linearLayout)

		textView = TextView(this).apply {
			textSize = 40f
		}
		linearLayout.addView(textView)

		linearLayout.addView(Button(this).apply {
			setOnClickListener {
				viewMode.counter++
				refreshCount()
			}
		})
		// 创建时刷新
		refreshCount()

		setContentView(scrollView)
	}

	private fun refreshCount()
	{
		textView.text = viewMode.counter.toString()
	}


	override fun onPause()
	{
		super.onPause()
		sp.edit {
			putInt("counter", viewMode.counter)
		}
	}
}

Lifecycles

简介

 Lifecycles可以用来感知Activity生命周期。它独特的地方在于，可以再一个非Activity类中感知Activity的生命周期。
 有一种解决方案是，自己创建一个监听器，重写Activity的onStart()、onCreate()方法等建立监听：

class MyObserver
{
	fun onStart() {}
	
	fun onStop() {}
}

class MyActivity : AppCompatActivity()
{
	lateinit var observer: MyObserver

	override fun onCreate(savedInstanceState: Bundle?)
	{
		super.onCreate(savedInstanceState)
		observer = MyObserver()
	}

	override fun onStart()
	{
		super.onStart()
		observer.onStart()
	}

	override fun onStop()
	{
		super.onStop()
		observer.onStop()
	}
}

而Lifecycles可以轻易实现，又不用些大量逻辑处理。
简单的实现方法是：

class MyObserver : LifecycleObserver
{
	@OnLifecycleEvent(Lifecycle.Event.ON_START)
	fun onStart() {}

	@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
	fun onStop() {}
}

只需要添加注解，就能实现对应方法监听，Lifecycles内置了七种枚举字段，它们分别是：

 public enum Event {
        /**
         *LifecycleOwner的onCreate事件的常量。
         */
        ON_CREATE,
        /**
         * LifecycleOwner的onStart事件的常量。
         */
        ON_START,
        /**
         * LifecycleOwner的onResume事件的常量。
         */
        ON_RESUME,
        /**
         * LifecycleOwner的onPause事件的常量。
         */
        ON_PAUSE,
        /**
         * LifecycleOwner的onStop事件的常量。
         */
        ON_STOP,
        /**
         * LifecycleOwner的onDestroy事件的常量。
         */
        ON_DESTROY,
        /**
         *可用于匹配所有事件的事件常量。
         */
        ON_ANY;
    ....
 }

如何监听？

由于继承自AppCompatActivity或andeoidx的Fragment已经是LifecycleOwner实例，所以可以这么监听：

lifecycle.addObserver(MyObserver())

否则，你需要自己实现一个LifecycleOwner实例，调用方法如下：

lifecycleOwner.lifecycle.addObserver(MyObserver())

主动获取状态

class MyObserver(val lifecycle: Lifecycle) : LifecycleObserver
{
	... 
}

 只需要传递Lifecycle，调用Lifecycle.currentState就能主动获取五种不同的生命周期状态，具体值的意思这里不详细说明，请自行查阅。
 比如，获取的是CAEATED，说明onCreate()已经执行了，但onStart()还没有。获取的是STARTED，则onStart()执行了，而onResume()还没有。

LiveData

 是响应式组件，它能够在数据发生变化时通知给观察者。LiveData大多情况是与ViewMode配合使用，尽管它能单独使用。

基本用法

 如果说，ViewMode的作用是解耦，让Activity界面数据分离的话，那么LiveData就是去给响应数据变化提醒（因为在ViewMode中，并没有主动响应变化的值，而是修改后调用refreshCount()方法）。
 主动提醒值变化，有利于耗时操作和统一管理数据修改，不至于界面数据修改写的一塌糊涂。
比如说，如果ViewMode内部开启了线程去执行耗时逻辑，那么在点击按钮后去执行refreshCount()获取值，显然没有新值，而处理完后的结果值，又恰恰无法主动显示。这就是LiveData重心。
 不要把Activity传给ViewMode这样会导致回收困难，内存泄露。一个周期较短的类不能把实例传给较长的类保管，也不能静态引用周期短的类。

LiveData基本使用

class MainActivityViewMode(countReserved : Int) : ViewModel()
{
	var counter = MutableLiveData<Int>()

	init {
		// 这样以前保存的默认值就能恢复
		counter.value = countReserved
	}

	fun add() {
		counter.value = counter.value?.plus(1)
	}
}

MutableLiveData 是一种可变的LiveData，他有三种读写数据的方式：

  1. getValue()获取数据
  2. setValue()设置数据，只能在主线程调用
  3. postValue()非主线程中设置数据

这样设置好的值，响应值写法如下：

linearLayout.addView(Button(this).apply {
		setOnClickListener {
			viewMode.add()
		}
})

viewMode.counter.observe(this) {
	textView.text = it.toString()
}

也就是只要修改值即可，不用手动更新。

暴露的问题

counter这个可变的变量暴露出去了，这就导致设置形同虚设：既然想方设法把修改内容局限在只能引用ViewMode的方法以便于响应数据，就不能暴露其他任何修改的可能，解决方法之一是：只暴露不可变的LiveData给外部，因此如下改动：

// 在构造器添加需要初始化赋予的对象或类型
class MainActivityViewMode(countReserved : Int) : ViewModel()
{
	val counter : LiveData<Int>
		get() = privateCounter

	private var privateCounter = MutableLiveData<Int>()

	init {
		privateCounter.value = countReserved
	}

	fun add() {
		privateCounter.value = privateCounter.value?.plus(1)
	}

}

这种写法最为规范，也是官方推荐的写法。

详细代码：

class MainActivity : AppCompatActivity()
{
	private lateinit var textView: TextView

	lateinit var viewMode: MainActivityViewMode
	lateinit var sp : SharedPreferences

	@SuppressLint("SetTextI18n")
	@RequiresApi(Build.VERSION_CODES.S)
	override fun onCreate(savedInstanceState: Bundle?)
	{
		super.onCreate(savedInstanceState)

		
		sp = getPreferences(Context.MODE_PRIVATE)
		val countReserved = sp.getInt("counter", 0)

		viewMode = ViewModelProvider(
				this,
				MainViewModeFactory(countReserved)
		)[MainActivityViewMode::class.java]

		// ui操作
		val scrollView = ScrollView(this)
		val linearLayout = LinearLayout(this)
		linearLayout.orientation = LinearLayout.VERTICAL
		scrollView.addView(linearLayout)

		textView = TextView(this).apply {
			textSize = 40f
		}
		linearLayout.addView(textView)

		linearLayout.addView(Button(this).apply {
			setOnClickListener {
				viewMode.add()
			}
		})

		viewMode.counter.observe(this) {
			textView.text = it.toString()
		}

		setContentView(scrollView)
	}

	override fun onPause()
	{
		super.onPause()
		sp.edit {
			putInt("counter", viewMode.counter.value ?:0 )
		}
	}

}

MainActivityViewMode.kt内：

// 在构造器添加需要初始化赋予的对象或类型
class MainActivityViewMode(countReserved : Int) : ViewModel()
{
	val counter : LiveData<Int>
		get() = privateCounter

	private var privateCounter = MutableLiveData<Int>()

	init {
		privateCounter.value = countReserved
	}

	fun add() {
		privateCounter.value = privateCounter.value?.plus(1)
	}

}

class MainViewModeFactory(
		private val countReserved: Int
) : ViewModelProvider.Factory
{
	override fun <T : ViewModel> create(modelClass: Class<T>): T
	{
		// 因为这里实例化执行时机和Activity/Fragment生命周期无关，
		// 所以可以创建
		return MainActivityViewMode(countReserved) as T
	}
}

map() 与 switchMap()

map()

&emspmap() 方法作用是：将实际包含数据的LiveData转换成仅用于观察的数据，也就是不照搬LiveData内数据，而是进行一定的修改。
 比如说数据类包含了用户的姓名、年龄、性别：

data class User(var name : String, var age : Int, var sex : String)

由上一节内容知道，不能直接暴露，要用一个只读变量做桥梁：

class MainActivityViewMode(countReserved : Int) : ViewModel()
{

	val user : LiveData<User>
		get() = privateUser
	
	private val privateUser = MutableLiveData<User>()
}

但假如只需要用户姓名和性别就够了，而再暴露额外的年龄不符合开发规范，map就解决了这个问题：

这里，只需要观察user就可以了

class MainActivityViewMode(countReserved : Int) : ViewModel()
{
	// 顺序不能变 - Bug? 2022/7/7
	private val privateUser = MutableLiveData<User>()
	
	val user : LiveData<String> = Transformations.map(privateUser) {
		"${it.name}, ${it.sex}"
	}
}

switchMap()

  虽然switchMap()比map()使用场景更加固定，但它更为常见：上文的User是在ViewMode创建的，这并不常见，更多的，是调用其他方法获取而来。
这里先定义类：

object Repository
{
	// 每次调用，都会获取新的实例
	fun getUser(userId : Int = 0): LiveData<User>
	{
		val liveData = MutableLiveData<User>()
		liveData.value = User(age = userId)
		return liveData
	}
}

然后再在ViewMode添加方法：

fun getUser(userId: Int): LiveData<User> = Repository.getUser(userId)

这样子在主Activity中，如下引用是完全错误的，因为getUser(id)调用获取的值是不变的，而再次调用，依然会重新观察老的实例，这样的情况下，这个类是不可观察的。

viewMode.getUser(id).observe(this) {}

而switchMap的作用就出来了：将函数 viewMode.getUser(id) 中返回的对象变成一个可观察的对象

这里，在适当的时机调用getUser()，只需要观察user就可以了。

class MainActivityViewMode(countReserved : Int) : ViewModel()
{

	private val userIdData = MutableLiveData<Int>()

	val user : LiveData<User> = Transformations.switchMap(userIdData) {
		Repository.getUser(it)
	}

	fun getUser(userId: Int) {
		userIdData.value = userId
	}
}

工作流程总结

  1. 外部调用MainActivityViewMode的getUser()获取用户数据，不会发送任何对外请求，只是userIdData 数据发生变化而提醒
  2. userIdData 数据发生变化，switchMap就会执行，才会对外请求对象并存放到user变量中。
  3. 对于Activity/Fragment而言，只要观察user就行

没有参数

工作流程中有这么一段话：userIdData 数据发生变化而提醒，假如，并没有传递的参数，是不是无从谈起？答案是否定的，可以如下写：

class MainActivityViewMode(countReserved : Int) : ViewModel()
{

	private val refreshData = MutableLiveData<Any?>()

	val user : LiveData<User> = Transformations.switchMap(refreshData) {
		Repository.refresh()
	}

	fun getUser(userId: Int) {
		refreshData.value = refreshData.value
	}
}

也就是说，LiveData并不关心数据是否相同，只要有调用setValue或postValue，就一定触发数据变化

后记

  1. LiveData能作为Activity与ViewMode之间的通信桥梁，并且不存在内存泄漏的风险，靠的就是Lifecycles组件进行自我感知，在Activity销毁时及时释放，避免产生内存泄露放入问题
  2. Activity在不可见的时候(息屏、被其他Activity遮挡），LiveData如果数据发生变化，也不会通知给观察者，只有恢复时，才进行通知
  3. Activity在不可见的时候，如果数据发生了多次变化，当Activity恢复时，LiveData只会保留最新的一份数据并提供给观察者，其他旧的数据会被丢弃，这些功能也少不了Lifecycles组件

Room

这是一个基于数据库的ORM框架。这部分自行百度。

WorkManager

 WorkManager适用于处理一些定时任务，他可以根据操作系统版本自动选择底层是AlarmManager实现还是JobScheduler，从而减低使用成本。它还支持周期性任务、链式任务处理等。

 与Service没有直接联系，并不相同。Serivce在没有被销毁时是一直保持后台运行的，而WorkManager只是一个定时处理工具，它可以保证即使应用程序退出，甚至手机重启，之前的任务仍然会得到执行，因此适合执行一些定期和服务器交互内容。

 另外，它所注册的周期性任务不一定准时执行。系统为了减少电池消耗，可能会触发时间临近的几个任务一起执行，这样以减少CPU被唤醒次数。

基本用法

添加依赖：

implementation 'androidx.work:work-runtime:2.7.0-alpha04'

主要工作分三步：

  1. 定义一个后台任务，实现具体业务逻辑
  2. 配置后台任务运行条件和约束信息，并构建后台任务请求
  3. 将后台任务传递给WorkManager的enqueue()方法，系统就能得以执行。

第一步：

class SimpleWork(context: Context, params: WorkerParameters) : Worker(context, params)
{
	override fun doWork(): Result
	{
		return Result.success()
	}
}

 doWork()不会在主线程运行，要求返回的对象，可以有Result.success()、Result.failure()，此外，还有Result.retry()，在表示失败的同时，可以结合WorkResult.Builder的 setBackoffCriteria() 重新执行任务，之后会说。

第二步，这里只进行简单配置：

val request = OneTimeWorkRequest.Builder(SimpleWork::class.java).build()

OneTimeWorkRequest用于一次请求，是WorkRequest的子类。也有子类PeriodicWorkRequest，用于创建周期性后台任务请求，下列示例代码是周期不小于15分钟的写法：

val request = PeriodicWorkRequest.Builder(
		SimpleWork::class.java, 
		15,
		TimeUnit.MINUTES
).build()

最后提交就行：

WorkManager.getInstance(context).enqueue(request)

使用WorkManager处理复杂任务

上文并不能控制具体时间，其实用处也不大，这里进行更复杂的控制设置。

延时执行

延时5分钟

val request = OneTimeWorkRequest.Builder(SimpleWork::class.java)
		.apply {
			setInitialDelay(5, TimeUnit.MINUTES)
			build()
		}

标签与关闭

添加标签，最主要的功能是通过标签取消后台请求：

val request = OneTimeWorkRequest.Builder(SimpleWork::class.java)
		.apply {
			setInitialDelay(5, TimeUnit.MINUTES)
			addTag("tag")
			build()
		}

没有标签，也可以用id来取消：

WorkManager.getInstance(this).apply { 
			cancelAllWorkByTag("tag")
			cancelWorkById(request.id)
			// 取消所有任务
			cancelAllWork()
		}

使用标签，可以把同一标签的所有任务取消（也就是标签可以重复命名，区别于id）

Result.retry()

  结合WorkResult.Builder的 setBackoffCriteria() 重新执行任务:

val request = OneTimeWorkRequest.Builder(SimpleWork::class.java)
		.apply {
			setBackoffCriteria(
					BackoffPolicy.LINEAR,
					10,
					TimeUnit.MINUTES
			)
			build()
		}

setBackoffCriteria()后两个参数很好理解，就是指定多久后执行任务。第一个参数是，多次失败后，下次执行失败后，以什么样的延迟方式执行。LINEAR表示线性延迟，EXPONENTIAL则是指数型。

Result的success和failure

 这两个返回值是用于通知任务运行结果的，可以如下对后台监听：

WorkManager.getInstance(this).apply {
			getWorkInfoByIdLiveData(request.id).observe(this@MainActivity) {
				when(it.state)
				{
					WorkInfo.State.SUCCEEDED -> {
						TODO("成功时执行")
					}
					
					WorkInfo.State.FAILED -> {
						TODO("失败时执行")
					}
					
					else -> {}
				}
			}
		}

这样就能监听数据结果了，当然，你知道了有getWorkInfoByIdLiveData() 自然也有基于Target的方法。

链式任务（任务链）

https://juejin.cn/post/6966852605825777678

总结

 前面介绍的WorkManager功能，在国产手机上都可能得不到正确运行，因为大多数厂商会给予用户一键清除所有非白名单的功能，被杀死的程序既没法接收广播，也不能运行WorkManager任务。
 所以建议是，不要依赖它实现核心功能，这不可靠。

Frms
关注
专栏目录
Android Jetpack架构组件（一）带你了解Android Jetpack
Android进阶三部曲 - 刘望舒
10-24 6799
本文首发于微信公众号「后厂村码农」 前言 Android已经发展了11年，可以说是比较成熟的技术了，一开始时框架很少，也没有什么规范，所有的代码都是要自己写，比如网络请求，数据库请求，数据解析等等。后来出现了一些框架来帮助开发者快速进行开发，比如XUtils、Volley、OKHttp、EventBus等，随着框架越来越多，一个应用可以有多种技术选型，直接导致应用开发越来越不规范，导致做出来的...
Android-Jetpack架构组件（一）带你了解Android-Jetpack
2401_84122965的博客
04-08 1146
下面分享的腾讯、头条、阿里、美团、字节跳动等公司2019-2021年的高频面试题全套解析，博主还把这些技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，下面只是以图片的形式给大家展示一部分。ViewModel: 以生命周期的方式管理界面相关的数据，通常和DataBinding配合使用，为开发者实现MVVM架构提供了强有力的支持。基础组件提供横向功能，例如向后兼容性、测试、安全、Kotlin 语言支持，并包括多个多个平台开发的组件。
Android开发:Jetpack组件库
喜狼狼与灰太杨的博客
07-05 701
Jetpack里都有什么?Jetpack 是什么？分类核心库架构组件UI组件特殊业务组件游戏、车载、TV 等或平时极少使用的组件弃用组件测试组件 Jetpack 是什么？ Jetpack 是一套组件库，可帮助开发人员遵循最佳实践，减少样板代码并编写可在 Android 版本和设备上一致工作的代码，以便开发人员可以专注于他们关心的代码。 分类 核心库 库 描述 activity.* Activity相关 arch.core 架构组件辅助包 annotation 注解,提升代码可读性
【安卓开发系列 -- APP】JetPack -- 组件库简介
CopperSun 技术博客
09-11 1126
【安卓开发系列 -- APP】JetPack -- 组件库简介 【1】JetPack 概念 Jetpack 与 AndroidX Jetpack 是众多组件库的统称，AndroidX 是这些组件的统一包名Jetpack 的优势 Jetpack 拥有基于生命周期感知的能力，可以减少 NPE(空指针异常) 崩溃、内存泄漏，为开发出健壮且流畅的程序提供强力保障； Jetpack 可以消除大量重复样板式的代码，可以加速 Android 的开发进程，组件可搭配工作，也可单独使用，同时配合 Kotlin 语言特性能
Jetpack架构组件库
wang_yong_hui_1234的博客
02-28 6462
Jetpack是众多优秀组件的集合。是谷歌推出的一套引领Android开发者逐渐统一开发规范的架构。
Android开发之——JetPack组件
我的博客
09-03 656
一什么是JetPack Jetpack 是一套库、工具和指南，可帮助开发者更轻松地编写优质应用。这些组件可帮助您遵循最佳做法、让您摆脱编写样板代码的工作并简化复杂任务，以便您将精力集中放在所需的代码上。 Jetpack 包含与平台 API 解除捆绑的 androidx.* 软件包库。这意味着，它可以提供向后兼容性，且比 Android 平台的更新频率更高，以此确保您始终可以获取最新且最好的 ...
NoteKeeper:基于androidx和jetpack库的android应用程序
04-12
NoteKeeper是一款专为Android平台设计的应用程序，它充分利用了AndroidX库和Jetpack组件的优势，为用户提供了一个便捷的笔记管理工具。本文将深入探讨NoteKeeper的开发背景、核心技术和实现细节，帮助开发者更好地...
Android Jetpack从入门到精通（深度好文，值得收藏）
最新发布
2401_84123094的博客
04-22 980
ViewModel。
一文读懂 Jetpack 组件开源库中 MVVM 框架架构
m0_62167422的博客
09-08 1197
当然这些事 ViewModel 已经帮我们做了，它可以取出 Model 的数据同时帮忙处理 View 中由于需要展示内容而涉及的业务逻辑。（ DO 的属性值不是一个 string ，而是一个 Object ，且这个 Object 可能还嵌套多层 Obejct 的时候）的。ViewModel 层负责将请求到的数据做业务逻辑处理，最后交给 View 层去展示，与 View 一一对应。在做项目或者在学习的时候，或多或少会听到 MVVM 这个架构，那么现在来简单讲一下 MVVM 架构。，包含点的字段是一个。
Android Jetpack组件（一）Jetpack组件概述
maguifen2012的博客
04-25 893
以上是jetpack组件的概述，后续会总结和分析Jetpack 中一些常用的组件。
还不知道Android Jetpack是什么？你就out了
Android开发之旅
11-19 1640
本文首发于微信公众号「Android开发之旅」，欢迎关注 ，获取更多技术干货 简介 谷歌在 2018​ I/O 大会上发布了一系列辅助android开发者的实用工具，这套工具就是Jetpack，它是一套库、工具和指南的合集，可以帮助开发者更轻松地编写和构建出色的 Android 应用程序。 Jetpack中的有些组件并不是第一次推出，其中LifeCycle、LiveData、ViewModel...
Jetpack架构组件库：DataStore
热门推荐
川峰的博客
01-29 6万+
Jetpack DataStore 是一种经过改进的新数据存储解决方案，旨在取代 SharedPreferences。DataStore 基于 Kotlin 协程和 Flow 构建而成，提供以下两种不同的实现： Preferences DataStore 用于键值对存储。数据以异步、一致和事务性的方式存储，有助于避免 SharedPreferences 的一些缺点。此实现不需要预定义的架构，也不确保类型安全。 Proto DataStore 用于存储类型化对象，数据作为自定义数据类型的实例进行存储。此实现
Android Jetpack组件库(第一部分）---Paging
工宗浩生财指南针
06-03 1055
Android Jetpack 是 Google 推出的一整套帮助 Android 应用程序开发的库、工具包和架构指南，旨在为 Android 应用程序提供更快，更轻松，更稳定的开发体验。
Jetpack架构组件库-LiveData实战与应用-总有适合你的方案
erhtre的博客
04-05 422
其实客户端开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。（以下体系的复习资料是我从各路大佬收集整理好的）《Android开发七大模块核心知识笔记》《960全网最全Android开发笔记》《379页Android开发面试宝典》历时半年，我们整理了这份市面上最全面的安卓面试题解析大全包含了腾讯、百度、小米、阿里、乐视、美团、58、猎豹、360、新浪、搜狐等一线互联网公司面试被问到的题目。
Jetpack架构组件库-LiveData只一篇你就会用
heiyl的专栏
12-08 220
WhenandwhytouseAndroidLiveDataheiyulong，公众号：Android进化之路Jetpack架构组件库-介绍与基本用法前言==本次主要讲解的内...
Android Jetpack 组件最新变化，全面解析（附源码）
老皮的博客
05-27 508
前言 今年的 I/O 大会既是谷歌各种新产品发布会，同时也是谷歌开发者们的技术交流会。不少 Android 开发者希望通过本次 I/O 了解到有关 Jetpack 的最新动态。 Jetpack 早已成为我们日常开发中的必备工具，根据本次大会上发布的数据，目前 GooglePlay 排名前 1000 的应用中，使用至少两个以上 Jetpack 库的占比从 79% 提升到 90%。 ​​Android Jetpack​​ 作为 ​​Android 开发​​的关键支柱，目前它已经包含了 100 多个库、工具和指
jetpack组件_Jetpack导航组件入门
weixin_26727575的博客
08-24 254
jetpack组件Navigation has always been a key component in every app, however, it has presented many challenges for Android developers to ponder over. Common among these challenges is fragment transaction...
JetPack及常用组件
weixin_50005657的博客
06-27 1266
一、Jetpack 介绍 1、什么是Jetpack Google 官方解释: Jetpack 是一个由多个库组成的套件，可帮助开发者遵循最佳做法，减少样板代码并编写可在各种 Android 版本和设备中一致运行的代码，让开发者精力集中编写重要的代码。 Jetpack 是 Google 为解决 Android 开发碎片化，打造成熟健康生态圈提出的战略规划，是 Google 对 Android 未来提出的发展方向，同时它也是众多优秀 Android 组件的集合。 2、为何使用 Android Jetpack G
Android开发入门指南与学习笔记
学习Android开发不仅需要掌握上述技术点，还需要不断关注最新的API变化和开发趋势，例如Jetpack组件库的使用、Kotlin语言的引入、Flutter框架等。随着Android系统的持续演进，开发者应保持学习和实践，以适应不断...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值