Android CameraX 使用说明的翻译 1.0.0-beta03版本 安卓10.0真机可运行

最新推荐文章于 2025-01-13 01:00:15 发布
最新推荐文章于 2025-01-13 01:00:15 发布
阅读量1k 收藏 1
点赞数 2
分类专栏： 笔记 文章标签： 安卓
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48138289/article/details/106359067
版权

学习Android CameraX 顺便翻译一下 官方给的说明

翻译来源CameraX 使用入门 该链接可能需要科学上网

额 前面那几章权限管理 就比较简单了 不翻了 放上布局文件吧 很简单 一个按钮一个 预览的View

<?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/camera_capture_button"
        android:layout_width="100dp"
        android:layout_height="100dp"
        android:scaleType="fitCenter"
        android:elevation="2dp"
        android:text="Take Photo"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <androidx.camera.view.PreviewView
        android:id="@+id/viewFinder"
        android:layout_width="match_parent"
        android:layout_height="match_parent"/>

</androidx.constraintlayout.widget.ConstraintLayout>

当然AndroidManifest.xml需要注册权限

	<!-- 这个貌似是 app需要相机的类型 此处是任何相机 还可以有其他类型 比如需要聚焦 --!>
    <uses-feature android:name="android.hardware.Camera.any"/>
    <uses-permission android:name="android.permission.CAMERA"/>

以下是翻译正文

前三章 如何构建项目以及权限管理 略

4. 实现预览用例

在相机应用程序中，取景器用于让用户预览将要拍摄的照片。你可以使用Camerax Preview类来实现一个取景器。

要使用Preview，您首先需要定义一个配置，然后用它来创建用例的一个实例。你需要绑定到CameraX生命周期的结果实例。
1.复制代码到startCamera()函数

下面的分析您刚才复制的代码。

private fun startCamera() {
        val cameraProviderFuture = ProcessCameraProvider.getInstance(this)

        cameraProviderFuture.addListener(Runnable {
            //Used to bind the lifecycle of cameras to the lifecycle owner
            val cameraProvider: ProcessCameraProvider = cameraProviderFuture.get()
            preview = Preview.Builder().build()

            //select back camera
            val cameraSelector =
                CameraSelector.Builder().requireLensFacing(CameraSelector.LENS_FACING_BACK)

                    .build()

            try {
                //unbide use cases before rebinding
                cameraProvider.unbindAll()

                //bind use cases to camera
                camera = cameraProvider.bindToLifecycle(this, cameraSelector, preview)
                preview?.setSurfaceProvider(viewFinder.createSurfaceProvider(camera?.cameraInfo))

            } catch (exc: Exception) {
                Log.e(TAG, "Use case binding failed", exc)
            }

        },ContextCompat.getMainExecutor(this))
    }
  • 创建一个ProcessCameraProvider。这用于将相机的生命周期绑定到生命周期所有者。这允许你不用担心打开和关闭相机，因为CameraX是生命周期感知的
val cameraProviderFuture = ProcessCameraProvider.getInstance(this)
  • 添加一个侦听器到cameraProviderFuture。添加一个Runnable作为一个参数，我们稍后将填充它。添加ContextCompat.getMainExecutor() 作为第二个参数，它返回在主线程上运行的执行程序。
cameraProviderFuture.addListener(Runnable {},ContextCompat.getMainExecutor(this))
  • 在这个Runalbe 添加一个ProcessCameraProvider，它用于将相机的生命周期绑定到应用程序进程中的LifecycleOwner。
val cameraProvider: ProcessCameraProvider = cameraProviderFuture.get()
  • 初始化你的Preview
preview = Preview.Builder().build()
  • 创建一个CameraSelector对象和使用CameraSelector.Builder.requireLensFacing()函数来打开你想要的镜头
CameraSelector.Builder().requireLensFacing(CameraSelector.LENS_FACING_BACK)
  • 创建一个try块。在那个块中，确保没有东西绑定到你的cameraProvider，然后绑定你的cameraSelector和preview对象到cameraProvider。将取景器的surface提供程序附加到preview。
            try {
               //unbide use cases before rebinding
               cameraProvider.unbindAll()
               //bind use cases to camera
               camera = cameraProvider.bindToLifecycle(this, cameraSelector, preview)
               preview?.setSurfaceProvider(viewFinder.createSurfaceProvider(camera?.cameraInfo))
           }
  • 这段代码有几种可能失败的情况，比如应用程序不再是焦点。如果出现故障，将此代码包装在catch块中以进行日志记录。
			catch (exc: Exception) {
               Log.e(TAG, "Use case binding failed", exc)
           }

2.运行APP，然后你就能看到相机的预览画面

5. 实现ImageCapture用例

与预览相比，其他用例的工作方式非常类似。首先，您必须定义一个用于实例化实际用例对象的配置对象。要捕获照片，您需要实现takePhoto()方法，该方法在按下捕获按钮时调用

将此代码复制到takePhoto()方法中。

下面的要点将分解您刚才复制的代码。

private fun takePhoto() {
        //Get a stable reference of the modifiable image capture use case
        //获取可修改图像捕获用例的稳定引用
        val imageCapture = imageCapture ?: return

        //Create timestamped output file to hold the image
        val photoFile = File(
            outputDirectory,
            SimpleDateFormat(FILENAME_FORMAT, Locale.CHINA)
                .format(System.currentTimeMillis()) + ".JPG"
        )

        //Create output pptions object which constins file + metadata
        val outputOptions = ImageCapture.OutputFileOptions.Builder(photoFile).build()

        //Setup image capture listener which is triggered after photo has been taken
        //设置图像捕获监听器，在拍照后触发
        imageCapture.takePicture(
            outputOptions,
            ContextCompat.getMainExecutor(this),
            object  : ImageCapture.OnImageSavedCallback{
                override fun onError(exception: ImageCaptureException) {
                    Log.e(TAG, "Photo capture failed: ${exception.message}", exception)
                }

                override fun onImageSaved(outputFileResults: ImageCapture.OutputFileResults) {
                    val savedUri = Uri.fromFile(photoFile)
                    val msg = "Photo caputre succeeded: $savedUri"
                    Toast.makeText(baseContext,msg,Toast.LENGTH_SHORT).show()
                    Log.d(TAG,msg)
                }
            }
        )
    }
  • 首先，获取对ImageCapture用例的引用。如果用例为空，则从函数中返回。如果在设置图像捕获之前点击photo按钮，则该值为null。如果没有return语句，应用程序如果为null就会崩溃。(为啥是崩溃？ 就是拍照没反应吧。。。)
val imageCapture = imageCapture ?: return
  • 接下来创建一个文件来保存图像。添加一个时间戳，这样文件名将是唯一的。
	//Create timestamped output file to hold the image
       val photoFile = File(
           outputDirectory,
           SimpleDateFormat(FILENAME_FORMAT, Locale.CHINA)
               .format(System.currentTimeMillis()) + ".JPG"
       )
  • 创建一个outputFileoptions对象。在这个对象中，您可以指定有关您希望输出如何的内容。您希望将输出保存到我们刚刚创建的文件中，因此添加您的photoFile。
val outputOptions = ImageCapture.OutputFileOptions.Builder(photoFile).build()
  • 在imageCapture对象上调用takePicture()。传入输出、执行程序和映像保存时的回调。接下来将填写回调。
imageCapture.takePicture(
            outputOptions,
            ContextCompat.getMainExecutor(this),
            object  : ImageCapture.OnImageSavedCallback{}
            )
  • 在图像捕获失败或保存图像捕获失败的情况下，添加一个错误情况以记录它失败。
                override fun onError(exception: ImageCaptureException) {
                    Log.e(TAG, "Photo capture failed: ${exception.message}", exception)
                }
  • 如果捕捉没有失败，照片拍摄成功!将照片保存到前面创建的文件中，向用户表示祝贺，并打印一条日志语句。
override fun onImageSaved(outputFileResults: ImageCapture.OutputFileResults) {
                    val savedUri = Uri.fromFile(photoFile)
                    val msg = "Photo caputre succeeded: $savedUri"
                    Toast.makeText(baseContext,msg,Toast.LENGTH_SHORT).show()
                    Log.d(TAG,msg)
                }
  1. 转到startCamera()方法，并在“预览代码”下复制这段代码
imageCapture=ImageCapture.Builder().build()

这里显示粘贴代码的方法:

private fun startCamera() {
	...
	preview = Preview.Builder().build()
	//Paste image capture code here!
	val cameraSelector = CameraSelector.Builder().requireLensFacing(CameraSelector.LENS_FACING_BACK).build()
	...
  1. 最后，在try块中更新对bindToLifecycle()的调用，包括新的用例:
camera = cameraProvider.bindToLifecycle(this, cameraSelector, preview, imageCapture)
  1. 重新运行应用程序并按下拍照。您将在屏幕上看到一个Toast，并在日志中看到一条消息。

6. 实现ImageAnalysis用例

如果运行Q或更低，那么同时实现预览、图像捕获和图像分析将不适用于Android Studio的设备模拟器。我们建议使用真实的设备来测试这部分代码。

让你的相机应用程序更有趣的一个好方法是使用ImageAnalysis功能。它允许您定义一个实现ImageAnalysis的自定义类。分析器接口，它将被调用与传入的摄像机帧。您将不必担心管理相机会话状态或甚至处理图像;绑定到我们想要的生命周期就足够了，就像其他生命周期感知组件一样。

  1. 将这个分析器作为main .kt中的一个内部类添加进来。
    这个分析器记录图像的平均亮度。要创建分析程序，您需要在实现ImageAnalysis的类中重写analyze函数。分析仪的接口。
private class LuminosityAnalyzer(private val listener: LumaListener) : ImageAnalysis.Analyzer {

   private fun ByteBuffer.toByteArray(): ByteArray {
       rewind()    // Rewind the buffer to zero
       val data = ByteArray(remaining())
       get(data)   // Copy the buffer into a byte array
       return data // Return the byte array
   }

   override fun analyze(image: ImageProxy) {

       val buffer = image.planes[0].buffer
       val data = buffer.toByteArray()
       val pixels = data.map { it.toInt() and 0xFF }
       val luma = pixels.average()

       listener(luma)

       image.close()
   }
}

用我们的类实现ImageAnalysis。Analyzer接口，所有我们需要做的是在ImageAnalysis中实例化一个LuminosityAnalyzer的实例，就像所有其他的用例一样，在调用CameraX.bindToLifecycle()之前，再次更新’ startCamera() '函数:

  1. 在startCamera()方法中，在imageCapture()代码下添加此代码。
imageAnalyzer = ImageAnalysis.Builder()
  .build()
  .also {
      it.setAnalyzer(cameraExecutor, LuminosityAnalyzer { luma ->
          Log.d(TAG, "Average luminosity: $luma")
      })
  }

这显示了粘贴代码的方法:

private fun startCamera() {
       ... 

       imageCapture = ImageCapture.Builder()
   .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
   .build()

       // Paste image analyzer code here!


       val cameraSelector = CameraSelector.Builder().requireLensFacing(CameraSelector.LENS_FACING_BACK).build()

       ... 
}
  1. 更新bindToLifecycle()调用cameraProvider以包含imageAnalyzer。
camera = cameraProvider.bindToLifecycle(
   this, cameraSelector, preview, imageCapture, imageAnalyzer)
  1. 现在运行应用程序!它大约每秒在logcat中生成一个类似的消息。
D/CameraXApp: Average luminosity: ...

翻译结束

最后把整个MainActivity.kt放上来

package city.carcate.u.myapplication

import android.Manifest
import android.content.pm.PackageManager
import android.net.Uri
import android.os.Bundle
import android.provider.ContactsContract
import android.util.Log
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.camera.core.*
import androidx.camera.lifecycle.ProcessCameraProvider
import androidx.camera.view.PreviewView
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import com.google.common.util.concurrent.ListenableFuture
import kotlinx.android.synthetic.main.activity_main.*
import java.io.File
import java.lang.Exception
import java.text.SimpleDateFormat
import java.util.*
import java.util.concurrent.Executor
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors

/**
 *
 */
class MainActivity : AppCompatActivity() {
    private var preview: Preview? = null
    private var imageCapture: ImageCapture? = null
    private var camera: Camera? = null

    private lateinit var outputDirectory: File
    private lateinit var cameraExecutor: ExecutorService

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        if (allPermissionsGranted()) {
            startCamera()
        } else {
            ActivityCompat.requestPermissions(
                this, REQUIRED_PERMISSIONS, REQUEST_CODE_PREMISSIONS
            )
        }
        //setup the listener for take photo button
        camera_capture_button.setOnClickListener { takePhoto() }
        outputDirectory = getOutputDirectory()
        cameraExecutor = Executors.newSingleThreadExecutor()
    }

    private fun startCamera() {
        val cameraProviderFuture = ProcessCameraProvider.getInstance(this)

        cameraProviderFuture.addListener(Runnable {
            //Used to bind the lifecycle of cameras to the lifecycle owner
            val cameraProvider: ProcessCameraProvider = cameraProviderFuture.get()
            preview = Preview.Builder().build()
            imageCapture = ImageCapture.Builder().build()

            //select back camera  选择后置摄像头
            val cameraSelector =
                CameraSelector.Builder().requireLensFacing(CameraSelector.LENS_FACING_BACK).build()

            try {
                //unbide use cases before rebinding 先解绑一下
                cameraProvider.unbindAll()
                //bind use cases to camera
                camera = cameraProvider.bindToLifecycle(this, cameraSelector, preview, imageCapture)
                preview?.setSurfaceProvider(viewFinder.createSurfaceProvider(camera?.cameraInfo))
            } catch (exc: Exception) {
                Log.e(TAG, "Use case binding failed", exc)
            }

        }, ContextCompat.getMainExecutor(this))

    }

    private fun takePhoto() {
        //Get a stable reference of the modifiable image capture use case
        //获取可修改图像捕获用例的稳定引用
        val imageCapture = imageCapture ?: return

        //Create timestamped output file to hold the image
        val photoFile = File(
            outputDirectory,
            SimpleDateFormat(FILENAME_FORMAT, Locale.CHINA)
                .format(System.currentTimeMillis()) + ".JPG"
        )

        //Create output pptions object which constins file + metadata
        val outputOptions = ImageCapture.OutputFileOptions.Builder(photoFile).build()

        //Setup image capture listener which is triggered after photo has been taken
        //设置图像捕获监听器，在拍照后触发
        imageCapture.takePicture(
            outputOptions,
            ContextCompat.getMainExecutor(this),
            object : ImageCapture.OnImageSavedCallback {
                override fun onError(exception: ImageCaptureException) {
                    Log.e(TAG, "Photo capture failed: ${exception.message}", exception)
                }

                override fun onImageSaved(outputFileResults: ImageCapture.OutputFileResults) {
                    val savedUri = Uri.fromFile(photoFile)
                    val msg = "Photo caputre succeeded: $savedUri"
                    Toast.makeText(baseContext, msg, Toast.LENGTH_SHORT).show()
                    Log.d(TAG, msg)
                }
            }
        )
    }

    private fun allPermissionsGranted() = REQUIRED_PERMISSIONS.all {
        ContextCompat.checkSelfPermission(baseContext, it) == PackageManager.PERMISSION_GRANTED
    }

   private fun getOutputDirectory(): File {
        val mediaDir = externalMediaDirs.firstOrNull()?.let {
            File(it, resources.getString(R.string.app_name)).apply { mkdirs() }
        }
        return if (mediaDir != null && mediaDir.exists()) mediaDir
        else filesDir
    }

    override fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) {
        if (requestCode == REQUEST_CODE_PREMISSIONS) {
            if (allPermissionsGranted()) {
                startCamera()
            } else {
                Toast.makeText(this, "Permissions not granted by the user.", Toast.LENGTH_LONG)
                    .show()
                finish()
            }
        }
    }

    companion object {
        private const val TAG = "CameraXBasic"
        private const val FILENAME_FORMAT = "yyyy-MM-mm-ss-SSS"	//这个时间怪怪的  正常不是这个吗 yyyy-MM-dd HH:mm:ss
        private const val REQUEST_CODE_PREMISSIONS = 10
        private val REQUIRED_PERMISSIONS = arrayOf(Manifest.permission.CAMERA)
    }
}

还有app配置文件下引入的库

// CameraX core library
    def camerax_version = '1.0.0-beta03'
    implementation "androidx.camera:camera-core:$camerax_version"

    // CameraX Camera2 extensions
    implementation "androidx.camera:camera-camera2:$camerax_version"

    // CameraX Lifecycle library
    implementation "androidx.camera:camera-lifecycle:$camerax_version"

    // CameraX View class
    implementation 'androidx.camera:camera-view:1.0.0-alpha10'

    // CameraX Extensions library
     implementation "androidx.camera:camera-extensions:1.0.0-alpha10"
最后运行OK 基本实现了拍照的 功能
android camera拍照简书,【Android】使用CameraX实现拍照和录制视频
weixin_42372510的博客
05-27 1145
AndroidX是Jetpack包下的组件，谷歌帮你考虑好了很多细节，用就完事了。这些细节想自己设置的话也可以，不设置使用默认值照样很舒服。导包implementation "androidx.camera:camera-camera2:1.0.0-beta07"implementation "androidx.camera:camera-view:1.0.0-alpha14"implementa...
Android CameraX（一）
2301_76622697的博客
05-26 608
借助名为“用例”的抽象概念与设备的相机进行交互。预览：接受用于显示的surface 例如图片分析：为分析（例如机器学习）提供CPU可访问的缓冲区图片拍摄：拍摄并保存图片视频拍摄：通过VideoCapture拍摄 视频 或 音频。
Android CameraX适配Android13的踩坑之路
u012556114的博客
08-16 1803
与早期版本一样，Android 13 包含一些行为变更，这些变更可能会影响您的应用。以下行为变更仅影响以 Android 13 或更高版本为目标平台的应用。如果您的应用以 Android 13 或更高版本为目标平台，您应该修改自己的应用以适当地支持这些行为（如果适用）。
Google Jetpack 新组件 CameraX 介绍与实践 | 开发者说·DTalk
谷歌开发者
11-09 972
本文原作者: glumes，原文发布于公众号纸上浅谈:https://mp.weixin.qq.com/s/geCmI9XovmxyaA437JIewg近期，Googl...
Android音视频全面介绍与代码实践之CameraX(三)
徐福记456
04-02 2万+
Android在应用层提供丰富的音视频多媒体接口，本文主要介绍CameraX，背景是在Camera2基础上，提供Lifecycler生命周期管理，提供更加简洁易用接口，包括摄像头预览、拍照、录像、图片分析，另外支持扩展接口：自动切换弱光模式、焦外成像、HDR拍摄等。
uiautomator2使用教程
weixin_43709411的博客
08-20 1万+
UiAutomator是Google提供的用来做安卓自动化测试的一个Java库，基于Accessibility服务。功能很强，可以对第三方App进行测试，获取屏幕上任意一个APP的任意一个控件属性，并对其进行任意操作，但有两个缺点：1. 测试脚本只能使用Java语言 2. 测试脚本要打包成jar或者apk包上传到设备上才能运行。 我们希望测试逻辑能够用Python编写，能够在电脑上运行的时候就控制...
Cesium基础使用介绍
weixin_30535843的博客
12-07 1438
既然给我发了参与方式，不参加似乎有点不给人面子，反正也没多少人看我的博客，那我就试试吧，也欢迎大家自己参与：2017年度全网原创IT博主评选活动投票：http://www.itbang.me/goVote/215 前言 最近折腾了一下三维地球，本文简单为大家介绍一款开源的三维地球软件——Cesium，以及如何快速上手Cesium。当然三维地球重要的肯定不是数据显示，这只是数据可视化的一小部分，重要...
CameraX系统二：配置选项
qq_33209777的博客
11-18 4434
配置选项 您可以配置每个 CameraX 用例，以控制用例操作的不同方面。 例如，对于图片拍摄用例，您可以设置目标宽高比和闪光灯模式。以下代码显示了一个示例： KotlinJava ImageCapture imageCapture = new ImageCapture.Builder() .setFlashMode(...) .setTargetAspectRatio(...) .build(); 除配置选项之外，一些用例会公开 A...
APP使用相机CameraX
许浑的博客
08-13 2006
APP使用相机CameraX
bindToLifecycle
最新发布
01-13 177
然后会自己去定义一个CameraProider. 但是后来会发现没有这个bindToLifecycle函数。在有些代码里面，看到cameraProvider.bindToLifecycle()，而不是CameraProvider的函数。
Camera CTS failed 解决方法汇总
Alexson_Wang的博客
08-23 1万+
1.android.hardware.camera2.cts.ExtendedCameraCharacteristicsTest--testAvailableStreamConfigs junit.framework.AssertionFailedError: Required FULLHD size not found for format 100 for: ID 1 : No eleme
【Android实战】2、用 CameraX 实现：preview 预览、imageCapture 拍照、videoCapture 录像、videoAnalysis 分析各帧
呆呆的猫的博客
10-01 6355
其实是通过 LuminosityAnalyzer.analyze() 函数内的 listener(luma) 将 luma 参数传给 listener() 函数，然后我们通过 setAnalyzer() 自定义了 listener() 函数，其接收亮度，并通过 Logcat 打印。来初始化摄像头的 use case，并绑定到 cameraProvider.bindToLifecycle() 中，完整代码如下。在 MainActivity 的 startCamera() 函数中，添加如下。
使用CameraX Extensions API，让你的照片美一点
郭霖
11-01 575
/ 今日科技快讯 /10月29日，国家市场监督管理总局公布了《互联网平台分类分级指南（征求意见稿）》《互联网平台落实主体责任指南（征求意见稿）》。其中提出，互联网平台拟划分为网络销...
[译]Android的多摄像头支持
weixin_33901843的博客
09-10 741
原文地址：Camera Enumeration on Android 原文作者：Oscar Wahltinez 译文出自：掘金翻译计划 本文永久链接：github.com/xitu/gold-m… 译者：luoqiuyu 校对者：hanliuxin5 Android 的多摄像头支持 从 Android P 开始，添加了对逻辑多摄像头和 USB 摄像头的支持。这对 Android 开发者来说...
Android CameraX的基础使用
llfjfz的专栏
04-10 4497
本博客介绍CamaraX的基本使用，主要基于。CameraX是一个 Jetpack 库，能够快速的开发相机应用，并且有良好兼容性。CameraX支持最低API level 21，并且本教程要求Android Studio Arctic Fox 2020.3.1 或更高版本。
Android CameraX 使用入门
热门推荐
luo_boke的博客
06-09 2万+
在 Android 应用中要实现 Camera 功能还是比较困难的，为了保证在各品牌手机设备上的兼容性、响应速度等体验细节，Camera 应用的开发者往往需要花很大的时间和精力进行测试，甚至需要手动在数百种不同设备上进行测试。CameraX 正是为解决这个痛点而诞生的。
Android开发笔记（一百八十一）使用CameraX拍照
aqi00的博客
02-11 3719
常言道，眼睛是心灵的窗户，那么相机便是手机的窗户了，主打美颜相机功能的拍照手机大行其道，可见对于手机App来说，如何恰如其分地运用相机开发至关重要。 Android的SDK一开始就自带了相机工具Camera，从Android5.0开始又推出了升级版的camera2，然而不管是初代的Camera还是二代的camera2，编码过程都比较繁琐，对于新手而言有点艰深。为此谷歌公司在Jetpack库中集成了增强的相机库CameraX，想让相机编码（包括拍照和录像）变得更加方便。CameraX基于camera2开发，它
【Android】源码分析Activity如何实现LifecycleOwner
移动端开发干货分享
05-23 3209
我们都知道Activity可作为LifecycleOwner为LiveData的使用提供条件，那么Activity是如何实现LifecycleOwner的呢？ Activity虽然实现了LifecycleOwner接口，但是并没有实现相关处理，而是通过添加一个Fragment来代理Lifecycle的分发。这种通过Fragment代理Activity行为的设计在其他一些库也经常出现，相对来说更加无侵和优雅。 SupportActivity Activity通过继承SupportActivity实现Life
Android ProcessLifecycleOwner 简单使用
xq610928的博客
04-26 1740
笔记 针对整个应用程序的监听 与Activity 的数量无关 Lifecycle.Event.ON_CREATE 只会被调用一次 Lifecycle.Event.ON_DESTROY 永远不会被调用 具体代码 package com.cbhx.myapplicationobserver; import android.util.Log; import androidx.lifecycle.Lifecycle; import androidx.lifecycle.LifecycleObserver
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值