(5)
376 | private val listeners = ArrayList<(luma: Double) -> Unit>()
377 | private var lastAnalyzedTimestamp = 0L
378 | var framesPerSecond: Double = -1.0
379 | private set
380 |
381 | /**
382 | * Used to add listeners that will be called with each luma computed
383 | */
384 | fun onFrameAnalyzed(listener: (luma: Double) -> Unit) = listeners.add(listener)
385 |
386 | /**
387 | * Helper extension function used to extract a byte array from an image plane buffer
388 | */
389 | private fun ByteBuffer.toByteArray(): ByteArray {
390 | rewind() // Rewind the buffer to zero
391 | val data = ByteArray(remaining())
392 | get(data) // Copy the buffer into a byte array
393 | return data // Return the byte array
394 | }
395 |
396 | /**
397 | * Analyzes an image to produce a result.
398 | *
399 | * The caller is responsible for ensuring this analysis method can be executed quickly
400 | * enough to prevent stalls in the image acquisition pipeline. Otherwise, newly available
401 | * images will not be acquired and analyzed.
402 | *
403 | *
The image passed to this method becomes invalid after this method returns. The caller
404 | * should not store external references to this image, as these references will become
405 | * invalid.
406 | *
407 | * @param image image being analyzed VERY IMPORTANT: do not close the image, it will be
408 | * automatically closed after this method returns
409 | * @return the image analysis result
410 | */
411 | override fun analyze(image: ImageProxy, rotationDegrees: Int) {
412 | // If there are no listeners attached, we don't need to perform analysis
413 | if (listeners.isEmpty()) return
414 |
415 | // Keep track of frames analyzed
416 | frameTimestamps.push(System.currentTimeMillis())
417 |
418 | // Compute the FPS using a moving average
419 | while (frameTimestamps.size >= frameRateWindow) frameTimestamps.removeLast()
420 | framesPerSecond = 1.0 / ((frameTimestamps.peekFirst() -
421 | frameTimestamps.peekLast()) / frameTimestamps.size.toDouble()) * 1000.0
422 |
423 | // Calculate the average luma no more often than every second
424 | if (frameTimestamps.first - lastAnalyzedTimestamp >= TimeUnit.SECONDS.toMillis(1)) {
425 | // Since format in ImageAnalysis is YUV, image.planes[0] contains the Y
426 | // (luminance) plane
427 | val buffer = image.planes[0].buffer
428 |
429 | // Extract image data from callback object
430 | val data = buffer.toByteArray()
431 |
432 | // Convert the data into an array of pixel values
433 | val pixels = data.map { it.toInt() and 0xFF }
434 |
435 | // Compute average luminance for the image
436 | val luma = pixels.average()
437 |
438 | // Call all listeners with new value
439 | listeners.forEach { it(luma) }
440 |
441 | lastAnalyzedTimestamp = frameTimestamps.first
442 | }
443 | }
444 | }
445 | }
446 |
--------------------------------------------------------------------------------
/CameraXBasic/app/src/main/java/com/android/example/cameraxbasic/fragments/GalleryFragment.kt:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2019 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * https://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.android.example.cameraxbasic.fragments
18 |
19 | import android.os.Bundle
20 | import android.view.LayoutInflater
21 | import android.view.View
22 | import android.view.ViewGroup
23 | import android.widget.ImageButton
24 | import androidx.fragment.app.Fragment
25 | import androidx.fragment.app.FragmentManager
26 | import androidx.fragment.app.FragmentStatePagerAdapter
27 | import androidx.viewpager.widget.ViewPager
28 | import java.io.File
29 | import android.content.Intent
30 | import android.os.Build
31 | import android.webkit.MimeTypeMap
32 | import androidx.constraintlayout.widget.ConstraintLayout
33 | import androidx.core.content.FileProvider
34 | import com.android.example.cameraxbasic.BuildConfig
35 | import com.android.example.cameraxbasic.utils.padWithDisplayCutout
36 | import androidx.appcompat.app.AlertDialog
37 | import com.android.example.cameraxbasic.utils.showImmersive
38 | import com.android.example.cameraxbasic.R
39 |
40 |
41 | const val KEY_ROOT_DIRECTORY = "root_folder"
42 | val EXTENSION_WHITELIST = arrayOf("JPG")
43 |
44 | /** Fragment used to present the user with a gallery of photos taken */
45 | class GalleryFragment internal constructor() : Fragment() {
46 | private lateinit var rootDirectory: File
47 | private lateinit var mediaList: MutableList
48 | private lateinit var mediaViewPager: ViewPager
49 |
50 | /** Adapter class used to present a fragment containing one photo or video as a page */
51 | inner class MediaPagerAdapter(fm: FragmentManager) : FragmentStatePagerAdapter(fm) {
52 | override fun getCount(): Int = mediaList.size
53 | override fun getItem(position: Int): Fragment = PhotoFragment.create(mediaList[position])
54 | override fun getItemPosition(obj: Any): Int = POSITION_NONE
55 | }
56 |
57 | override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
58 | savedInstanceState: Bundle?): View? {
59 | // Inflate the layout for this fragment
60 | return inflater.inflate(R.layout.fragment_gallery, container, false)
61 | }
62 |
63 | override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
64 | super.onViewCreated(view, savedInstanceState)
65 |
66 | // Mark this as a retain fragment, so the lifecycle does not get restarted on config change
67 | retainInstance = true
68 |
69 | arguments?.let {
70 | rootDirectory = File(it.getString(KEY_ROOT_DIRECTORY))
71 |
72 | // Walk through all files in the root directory
73 | // We reverse the order of the list to present the last photos first
74 | mediaList = rootDirectory.listFiles { file ->
75 | EXTENSION_WHITELIST.contains(file.extension.toUpperCase())
76 | }.sorted().reversed().toMutableList()
77 |
78 | // Populate the ViewPager and implement a cache of two media items
79 | mediaViewPager = view.findViewById(R.id.photo_view_pager).apply {
80 | offscreenPageLimit = 2
81 | adapter = MediaPagerAdapter(childFragmentManager)
82 | }
83 | }
84 |
85 | // Make sure that the cutout "safe area" avoids the screen notch if any
86 | if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
87 | // Use extension method to pad "inside" view containing UI using display cutout's bounds
88 | view.findViewById(R.id.cutout_safe_area).padWithDisplayCutout()
89 | }
90 |
91 | // Handle back button press
92 | view.findViewById(R.id.back_button).setOnClickListener {
93 | fragmentManager?.popBackStack()
94 | }
95 |
96 | // Handle share button press
97 | view.findViewById(R.id.share_button).setOnClickListener {
98 | // Make sure that we have a file to share
99 | mediaList.getOrNull(mediaViewPager.currentItem)?.let { mediaFile ->
100 | val appContext = requireContext().applicationContext
101 |
102 | // Create a sharing intent
103 | val intent = Intent().apply {
104 | // Infer media type from file extension
105 | val mediaType = MimeTypeMap.getSingleton()
106 | .getMimeTypeFromExtension(mediaFile.extension)
107 | // Get URI from our FileProvider implementation
108 | val uri = FileProvider.getUriForFile(
109 | appContext, BuildConfig.APPLICATION_ID + ".provider", mediaFile)
110 | // Set the appropriate intent extra, type, action and flags
111 | putExtra(Intent.EXTRA_STREAM, uri)
112 | type = mediaType
113 | action = Intent.ACTION_SEND
114 | flags = Intent.FLAG_GRANT_READ_URI_PERMISSION
115 | }
116 |
117 | // Launch the intent letting the user choose which app to share with
118 | startActivity(Intent.createChooser(intent, getString(R.string.share_hint)))
119 | }
120 | }
121 |
122 | // Handle delete button press
123 | view.findViewById(R.id.delete_button).setOnClickListener {
124 | val context = requireContext()
125 | AlertDialog.Builder(context, android.R.style.Theme_Material_Dialog)
126 | .setTitle(getString(R.string.delete_title))
127 | .setMessage(getString(R.string.delete_dialog))
128 | .setIcon(android.R.drawable.ic_dialog_alert)
129 | .setPositiveButton(android.R.string.yes) { _, _ ->
130 | mediaList.getOrNull(mediaViewPager.currentItem)?.let { mediaFile ->
131 |
132 | // Delete current photo
133 | mediaFile.delete()
134 |
135 | // Notify our view pager
136 | mediaList.removeAt(mediaViewPager.currentItem)
137 | mediaViewPager.adapter?.notifyDataSetChanged()
138 |
139 | // If all photos have been deleted, return to camera
140 | if (mediaList.isEmpty()) {
141 | fragmentManager?.popBackStack()
142 | }
143 | }}
144 |
145 | .setNegativeButton(android.R.string.no, null)
146 | .create().showImmersive()
147 | }
148 | }
149 | }
--------------------------------------------------------------------------------
/CameraXBasic/app/src/main/java/com/android/example/cameraxbasic/fragments/PermissionsFragment.kt:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2019 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * https://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.android.example.cameraxbasic.fragments
18 |
19 | import android.Manifest
20 | import android.content.pm.PackageManager
21 | import android.os.Bundle
22 | import android.widget.Toast
23 | import androidx.core.content.ContextCompat
24 | import androidx.fragment.app.Fragment
25 | import androidx.navigation.NavOptions
26 | import androidx.navigation.Navigation
27 | import com.android.example.cameraxbasic.R
28 |
29 | private const val PERMISSIONS_REQUEST_CODE = 10
30 | private val PERMISSIONS_REQUIRED = arrayOf(
31 | Manifest.permission.CAMERA,
32 | Manifest.permission.RECORD_AUDIO)
33 |
34 | /**
35 | * The sole purpose of this fragment is to request permissions and, once granted, display the
36 | * camera fragment to the user.
37 | */
38 | class PermissionsFragment : Fragment() {
39 | val navOptions = NavOptions.Builder().setPopUpTo(R.id.permissionsFragment, true).build()
40 |
41 | override fun onCreate(savedInstanceState: Bundle?) {
42 | super.onCreate(savedInstanceState)
43 |
44 | if (!hasPermissions()) {
45 | // Request camera-related permissions
46 | requestPermissions(PERMISSIONS_REQUIRED, PERMISSIONS_REQUEST_CODE)
47 | } else {
48 | // If permissions have already been granted, proceed
49 | Navigation.findNavController(requireActivity(), R.id.fragment_container)
50 | .navigate(R.id.action_permissions_to_camera, null,
51 | navOptions)
52 | }
53 |
54 | }
55 |
56 | private fun hasPermissions(): Boolean {
57 | for (permission in PERMISSIONS_REQUIRED) {
58 | if (ContextCompat.checkSelfPermission(requireContext(), permission) !=
59 | PackageManager.PERMISSION_GRANTED) {
60 | return false
61 | }
62 | }
63 | return true
64 | }
65 |
66 | override fun onRequestPermissionsResult(
67 | requestCode: Int, permissions: Array, grantResults: IntArray) {
68 | super.onRequestPermissionsResult(requestCode, permissions, grantResults)
69 | if (requestCode == PERMISSIONS_REQUEST_CODE) {
70 | if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
71 | // Take the user to the success fragment when permission is granted
72 | Toast.makeText(context, "Permission request granted", Toast.LENGTH_LONG).show()
73 | Navigation.findNavController(requireActivity(), R.id.fragment_container)
74 | .navigate(R.id.action_permissions_to_camera, null,
75 | navOptions)
76 | } else {
77 | Toast.makeText(context, "Permission request denied", Toast.LENGTH_LONG).show()
78 | }
79 | }
80 | }
81 | }
82 |
--------------------------------------------------------------------------------
/CameraXBasic/app/src/main/java/com/android/example/cameraxbasic/fragments/PhotoFragment.kt:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2019 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * https://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.android.example.cameraxbasic.fragments
18 |
19 | import android.os.Bundle
20 | import android.view.LayoutInflater
21 | import android.view.View
22 | import android.view.ViewGroup
23 | import android.widget.ImageView
24 | import androidx.fragment.app.Fragment
25 | import com.bumptech.glide.Glide
26 | import java.io.File
27 |
28 | private const val FILE_NAME_KEY = "file_name"
29 |
30 | /** Fragment used for each individual page showing a photo inside of [GalleryFragment] */
31 | class PhotoFragment internal constructor() : Fragment() {
32 |
33 | override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
34 | savedInstanceState: Bundle?) = ImageView(context)
35 |
36 | override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
37 | super.onViewCreated(view, savedInstanceState)
38 | arguments?.let {
39 | val file = File(it.getString(FILE_NAME_KEY))
40 | Glide.with(this).load(file).into(view as ImageView)
41 | }
42 | }
43 |
44 | companion object {
45 | fun create(image: File) = PhotoFragment().apply {
46 | arguments = Bundle().apply {
47 | putString(FILE_NAME_KEY, image.absolutePath)
48 | }
49 | }
50 | }
51 | }
--------------------------------------------------------------------------------
/CameraXBasic/app/src/main/java/com/android/example/cameraxbasic/fragments/Renderer.kt:
--------------------------------------------------------------------------------
1 | package com.android.example.cameraxbasic.fragments
2 |
3 | import android.graphics.SurfaceTexture
4 | import android.opengl.EGL14
5 | import android.opengl.GLES20
6 | import android.os.Handler
7 | import android.os.HandlerThread
8 | import android.os.Message
9 | import android.view.TextureView
10 | import java.nio.FloatBuffer
11 | import javax.microedition.khronos.egl.EGL10
12 | import javax.microedition.khronos.egl.EGLConfig
13 | import javax.microedition.khronos.egl.EGLContext
14 | import javax.microedition.khronos.egl.EGLSurface
15 |
16 |
17 | class Renderer : SurfaceTexture.OnFrameAvailableListener {
18 | private var mHandlerThread: HandlerThread? = null
19 | private var mHandler: Handler? = null
20 | private var mTextureView: TextureView? = null
21 | private var mOESTextureId: Int = 0
22 | private var mFilterEngine: TextureDrawer? = null
23 | private var mDataBuffer: FloatBuffer? = null
24 | private var mShaderProgram = -1
25 | private val transformMatrix = FloatArray(16)
26 |
27 | private var mEgl: EGL10? = null
28 | private var mEGLDisplay = EGL10.EGL_NO_DISPLAY
29 | private var mEGLContext = EGL10.EGL_NO_CONTEXT
30 | private val mEGLConfig = arrayOfNulls(1)
31 | private var mEglSurface: EGLSurface? = null
32 | private var mOESSurfaceTexture: SurfaceTexture? = null
33 |
34 | fun init(textureView: TextureView, oesTextureId: Int) {
35 | mTextureView = textureView
36 | mOESTextureId = oesTextureId
37 | mHandlerThread = HandlerThread("Renderer Thread")
38 | mHandlerThread!!.start()
39 | mHandler = object : Handler(mHandlerThread!!.looper) {
40 | override fun handleMessage(msg: Message) {
41 | when (msg.what) {
42 | MSG_INIT -> {
43 | initEGL()
44 | return
45 | }
46 | MSG_RENDER -> {
47 | drawFrame()
48 | return
49 | }
50 | MSG_INIT_SURFACE -> {
51 | initSurfaceTexture()
52 | return
53 | }
54 | MSG_DEINIT -> {
55 | deInitSurfaceTexture()
56 | }
57 | else -> return
58 | }
59 | }
60 | }
61 | mHandler!!.sendEmptyMessage(MSG_INIT)
62 | }
63 |
64 | private fun deInitSurfaceTexture() {
65 | mOESSurfaceTexture?.detachFromGLContext()
66 | }
67 |
68 | private fun initSurfaceTexture() {
69 | mOESSurfaceTexture!!.attachToGLContext(mOESTextureId)
70 | mOESSurfaceTexture!!.setOnFrameAvailableListener(this)
71 | }
72 |
73 |
74 | private fun initEGL() {
75 | mEgl = EGLContext.getEGL() as EGL10
76 |
77 | //获取显示设备
78 | mEGLDisplay = mEgl!!.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY)
79 | if (mEGLDisplay === EGL10.EGL_NO_DISPLAY) {
80 | throw RuntimeException("eglGetDisplay failed! " + mEgl!!.eglGetError())
81 | }
82 |
83 | //version中存放EGL版本号
84 | val version = IntArray(2)
85 |
86 | //初始化EGL
87 | if (!mEgl!!.eglInitialize(mEGLDisplay, version)) {
88 | throw RuntimeException("eglInitialize failed! " + mEgl!!.eglGetError())
89 | }
90 |
91 | //构造需要的配置列表
92 | val attributes = intArrayOf(EGL10.EGL_RED_SIZE, 8, EGL10.EGL_GREEN_SIZE, 8, EGL10.EGL_BLUE_SIZE, 8, EGL10.EGL_ALPHA_SIZE, 8, EGL10.EGL_BUFFER_SIZE, 32, EGL10.EGL_RENDERABLE_TYPE, 4, EGL10.EGL_SURFACE_TYPE, EGL10.EGL_WINDOW_BIT, EGL10.EGL_NONE)
93 | val configsNum = IntArray(1)
94 |
95 | //EGL选择配置
96 | if (!mEgl!!.eglChooseConfig(mEGLDisplay, attributes, mEGLConfig, 1, configsNum)) {
97 | throw RuntimeException("eglChooseConfig failed! " + mEgl!!.eglGetError())
98 | }
99 | val surfaceTexture = mTextureView!!.surfaceTexture ?: return
100 |
101 | //创建EGL显示窗口
102 | mEglSurface = mEgl!!.eglCreateWindowSurface(mEGLDisplay, mEGLConfig[0], surfaceTexture, null)
103 |
104 | //创建上下文
105 | val contextAttribs = intArrayOf(EGL14.EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE)
106 | mEGLContext = mEgl!!.eglCreateContext(mEGLDisplay, mEGLConfig[0], EGL10.EGL_NO_CONTEXT, contextAttribs)
107 |
108 | if (mEGLDisplay === EGL10.EGL_NO_DISPLAY || mEGLContext === EGL10.EGL_NO_CONTEXT) {
109 | throw RuntimeException("eglCreateContext fail failed! " + mEgl!!.eglGetError())
110 | }
111 |
112 | if (!mEgl!!.eglMakeCurrent(mEGLDisplay, mEglSurface, mEglSurface, mEGLContext)) {
113 | throw RuntimeException("eglMakeCurrent failed! " + mEgl!!.eglGetError())
114 | }
115 |
116 | mFilterEngine = TextureDrawer(mOESTextureId)
117 | mDataBuffer = mFilterEngine!!.buffer
118 | mShaderProgram = mFilterEngine!!.shaderProgram
119 | }
120 |
121 | private fun drawFrame() {
122 | if (mOESSurfaceTexture != null) {
123 | mOESSurfaceTexture!!.updateTexImage()
124 | mOESSurfaceTexture!!.getTransformMatrix(transformMatrix)
125 | }
126 | mEgl!!.eglMakeCurrent(mEGLDisplay, mEglSurface, mEglSurface, mEGLContext)
127 | GLES20.glViewport(0, 0, mTextureView!!.width, mTextureView!!.height)
128 | GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT)
129 | GLES20.glClearColor(1f, 1f, 0f, 0f)
130 | mFilterEngine!!.drawTexture(transformMatrix)
131 | mEgl!!.eglSwapBuffers(mEGLDisplay, mEglSurface)
132 | }
133 |
134 | override fun onFrameAvailable(surfaceTexture: SurfaceTexture) {
135 | if (mHandler != null) {
136 | mHandler!!.sendEmptyMessage(MSG_RENDER)
137 | }
138 | }
139 |
140 | fun initOESTexture(st: SurfaceTexture) {
141 | mOESSurfaceTexture = st
142 |
143 | if (mHandler != null) {
144 | mHandler!!.sendEmptyMessage(MSG_INIT_SURFACE)
145 | }
146 | }
147 |
148 | companion object {
149 | private val MSG_INIT = 1
150 | private val MSG_RENDER = 2
151 | private val MSG_DEINIT = 3
152 | private val MSG_INIT_SURFACE = 4
153 | }
154 | }
155 |
--------------------------------------------------------------------------------
/CameraXBasic/app/src/main/java/com/android/example/cameraxbasic/fragments/TextureDrawer.kt:
--------------------------------------------------------------------------------
1 | package com.android.example.cameraxbasic.fragments
2 |
3 | import android.opengl.GLES11Ext
4 | import android.opengl.GLES20
5 | import android.opengl.GLES20.*
6 | import java.nio.ByteBuffer
7 | import java.nio.ByteOrder
8 | import java.nio.FloatBuffer
9 | import javax.microedition.khronos.opengles.GL10
10 |
11 | class TextureDrawer(OESTextureId: Int) {
12 | val buffer: FloatBuffer?
13 | private var mOESTextureId = -1
14 | private var vertexShader = -1
15 | private var fragmentShader = -1
16 | var shaderProgram = -1
17 |
18 | private var aPositionLocation = -1
19 | private var aTextureCoordLocation = -1
20 | private var uTextureMatrixLocation = -1
21 | private var uTextureSamplerLocation = -1
22 |
23 | init {
24 | mOESTextureId = OESTextureId
25 | buffer = createBuffer(vertexData)
26 | vertexShader = loadShader(GL_VERTEX_SHADER, VERTEX_SHADER)
27 | fragmentShader = loadShader(GL_FRAGMENT_SHADER, FRAGMENT_SHADER)
28 | shaderProgram = linkProgram(vertexShader, fragmentShader)
29 | }
30 |
31 | private fun createBuffer(vertexData: FloatArray): FloatBuffer {
32 | val buffer = ByteBuffer.allocateDirect(vertexData.size * 4)
33 | .order(ByteOrder.nativeOrder())
34 | .asFloatBuffer()
35 | buffer.put(vertexData, 0, vertexData.size).position(0)
36 | return buffer
37 | }
38 |
39 | private fun loadShader(type: Int, shaderSource: String): Int {
40 | val shader = glCreateShader(type)
41 | if (shader == 0) {
42 | throw RuntimeException("Create Shader Failed!" + glGetError())
43 | }
44 | glShaderSource(shader, shaderSource)
45 | glCompileShader(shader)
46 | return shader
47 | }
48 |
49 | private fun linkProgram(verShader: Int, fragShader: Int): Int {
50 | val program = glCreateProgram()
51 | if (program == 0) {
52 | throw RuntimeException("Create Program Failed!" + glGetError())
53 | }
54 | glAttachShader(program, verShader)
55 | glAttachShader(program, fragShader)
56 | glLinkProgram(program)
57 |
58 | glUseProgram(program)
59 | return program
60 | }
61 |
62 | fun drawTexture(transformMatrix: FloatArray) {
63 | aPositionLocation = glGetAttribLocation(shaderProgram, TextureDrawer.POSITION_ATTRIBUTE)
64 | aTextureCoordLocation = glGetAttribLocation(shaderProgram, TextureDrawer.TEXTURE_COORD_ATTRIBUTE)
65 | uTextureMatrixLocation = glGetUniformLocation(shaderProgram, TextureDrawer.TEXTURE_MATRIX_UNIFORM)
66 | uTextureSamplerLocation = glGetUniformLocation(shaderProgram, TextureDrawer.TEXTURE_SAMPLER_UNIFORM)
67 |
68 | glActiveTexture(GLES20.GL_TEXTURE0)
69 | glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, mOESTextureId)
70 | glUniform1i(uTextureSamplerLocation, 0)
71 | glUniformMatrix4fv(uTextureMatrixLocation, 1, false, transformMatrix, 0)
72 |
73 | if (buffer != null) {
74 | buffer.position(0)
75 | glEnableVertexAttribArray(aPositionLocation)
76 | glVertexAttribPointer(aPositionLocation, 2, GL_FLOAT, false, 16, buffer)
77 |
78 | buffer.position(2)
79 | glEnableVertexAttribArray(aTextureCoordLocation)
80 | glVertexAttribPointer(aTextureCoordLocation, 2, GL_FLOAT, false, 16, buffer)
81 |
82 | glDrawArrays(GL_TRIANGLES, 0, 6)
83 | }
84 | }
85 |
86 | companion object {
87 |
88 | private val vertexData = floatArrayOf(
89 | 1f, 1f, 1f, 1f,
90 | -1f, 1f, 0f, 1f,
91 | -1f, -1f, 0f, 0f,
92 | 1f, 1f, 1f, 1f,
93 | -1f, -1f, 0f, 0f,
94 | 1f, -1f, 1f, 0f)
95 |
96 | private val POSITION_ATTRIBUTE = "aPosition"
97 | private val TEXTURE_COORD_ATTRIBUTE = "aTextureCoordinate"
98 | private val TEXTURE_MATRIX_UNIFORM = "uTextureMatrix"
99 | private val TEXTURE_SAMPLER_UNIFORM = "uTextureSampler"
100 |
101 | private val VERTEX_SHADER = "attribute vec4 aPosition;\n" +
102 | "uniform mat4 uTextureMatrix;\n" +
103 | "attribute vec4 aTextureCoordinate;\n" +
104 | "varying vec2 vTextureCoord;\n" +
105 | "void main()\n" +
106 | "{\n" +
107 | " vTextureCoord = (uTextureMatrix * aTextureCoordinate).xy;\n" +
108 | " gl_Position = aPosition;\n" +
109 | "}"
110 |
111 | private val FRAGMENT_SHADER = "#extension GL_OES_EGL_image_external : require\n" +
112 | "precision mediump float;\n" +
113 | "uniform samplerExternalOES uTextureSampler;\n" +
114 | "varying vec2 vTextureCoord;\n" +
115 | "void main()\n" +
116 | "{\n" +
117 | " vec4 vCameraColor = texture2D(uTextureSampler, vTextureCoord);\n" +
118 | " float fGrayColor = (0.3*vCameraColor.r + 0.59*vCameraColor.g + 0.11*vCameraColor.b);\n" +
119 | " gl_FragColor = vec4(fGrayColor, fGrayColor, fGrayColor, 1.0);\n" +
120 | "}\n"
121 |
122 |
123 | fun createOESTextureObject(): Int {
124 | val tex = IntArray(1)
125 | GLES20.glGenTextures(1, tex, 0)
126 | GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, tex[0])
127 | GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
128 | GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_NEAREST.toFloat())
129 | GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
130 | GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR.toFloat())
131 | GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
132 | GL10.GL_TEXTURE_WRAP_S, GL10.GL_CLAMP_TO_EDGE.toFloat())
133 | GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
134 | GL10.GL_TEXTURE_WRAP_T, GL10.GL_CLAMP_TO_EDGE.toFloat())
135 | GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, 0)
136 | return tex[0]
137 | }
138 | }
139 | }
140 |
141 |
--------------------------------------------------------------------------------
/CameraXBasic/app/src/main/java/com/android/example/cameraxbasic/utils/AutoFitPreviewBuilder.kt:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2019 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * https://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.android.example.cameraxbasic.utils
18 |
19 | import android.content.Context
20 | import android.graphics.Matrix
21 | import android.graphics.SurfaceTexture
22 | import android.hardware.display.DisplayManager
23 | import android.util.Log
24 | import android.util.Size
25 | import android.view.*
26 | import androidx.camera.core.Preview
27 | import androidx.camera.core.PreviewConfig
28 | import com.android.example.cameraxbasic.fragments.Renderer
29 | import com.android.example.cameraxbasic.fragments.TextureDrawer
30 | import java.lang.IllegalArgumentException
31 | import java.lang.ref.WeakReference
32 | import java.util.Objects
33 |
34 | /**
35 | * Builder for [Preview] that takes in a [WeakReference] of the view finder and
36 | * [PreviewConfig], then instantiates a [Preview] which automatically
37 | * resizes and rotates reacting to config changes.
38 | */
39 | class AutoFitPreviewBuilder private constructor(config: PreviewConfig,
40 | viewFinderRef: WeakReference) {
41 | /** Public instance of preview use-case which can be used by consumers of this adapter */
42 | val useCase: Preview
43 |
44 | /** Internal variable used to keep track of the use-case's output rotation */
45 | private var bufferRotation: Int = 0
46 | /** Internal variable used to keep track of the view's rotation */
47 | private var viewFinderRotation: Int? = null
48 | /** Internal variable used to keep track of the use-case's output dimension */
49 | private var bufferDimens: Size = Size(0, 0)
50 | /** Internal variable used to keep track of the view's dimension */
51 | private var viewFinderDimens: Size = Size(0, 0)
52 | /** Internal variable used to keep track of the view's display */
53 | private var viewFinderDisplay: Int = -1
54 |
55 | private lateinit var displayManager: DisplayManager
56 | /** We need a display listener for 180 degree device orientation changes */
57 | private val displayListener = object : DisplayManager.DisplayListener {
58 | override fun onDisplayAdded(displayId: Int) = Unit
59 | override fun onDisplayRemoved(displayId: Int) = Unit
60 | override fun onDisplayChanged(displayId: Int) {
61 | val viewFinder = viewFinderRef.get() ?: return
62 | if (displayId != viewFinderDisplay) {
63 | val display = displayManager.getDisplay(displayId)
64 | val rotation = getDisplaySurfaceRotation(display)
65 | updateTransform(viewFinder, rotation, bufferDimens, viewFinderDimens)
66 | }
67 | }
68 | }
69 |
70 | private var mOESTextureId = -1
71 | private var mRenderer: Renderer = Renderer()
72 |
73 | init {
74 | // Make sure that the view finder reference is valid
75 | val viewFinder = viewFinderRef.get() ?: throw IllegalArgumentException(
76 | "Invalid reference to view finder used")
77 |
78 | // Initialize the display and rotation from texture view information
79 | viewFinderDisplay = viewFinder.display.displayId
80 | viewFinderRotation = getDisplaySurfaceRotation(viewFinder.display) ?: 0
81 |
82 | // Initialize public use-case with the given config
83 | useCase = Preview(config)
84 |
85 |
86 | // Every time the view finder is updated, recompute layout
87 | useCase.onPreviewOutputUpdateListener = Preview.OnPreviewOutputUpdateListener {
88 | val viewFinder =
89 | viewFinderRef.get() ?: return@OnPreviewOutputUpdateListener
90 |
91 | // To update the SurfaceTexture, we have to remove it and re-add it
92 | val parent = viewFinder.parent as ViewGroup
93 | parent.removeView(viewFinder)
94 | parent.addView(viewFinder, 0)
95 |
96 | Log.d("zhy", "OnPreviewOutputUpdateListener")
97 |
98 | // 启用下面的代码正常显示内容
99 | // viewFinder.surfaceTexture = it.surfaceTexture
100 |
101 | // 启用下面的代码，走 GL 线程，图像经过黑白滤镜处理
102 | viewFinder.surfaceTextureListener = object : TextureView.SurfaceTextureListener {
103 |
104 | override fun onSurfaceTextureSizeChanged(surface: SurfaceTexture?, width: Int, height: Int) {
105 | }
106 |
107 | override fun onSurfaceTextureUpdated(surface: SurfaceTexture?) {
108 | }
109 |
110 | override fun onSurfaceTextureDestroyed(surface: SurfaceTexture?): Boolean {
111 | return true
112 | }
113 |
114 | override fun onSurfaceTextureAvailable(surface: SurfaceTexture?, width: Int, height: Int) {
115 | mOESTextureId = TextureDrawer.createOESTextureObject()
116 | mRenderer.init(viewFinder, mOESTextureId)
117 | mRenderer.initOESTexture(it.surfaceTexture)
118 | }
119 | }
120 |
121 | bufferRotation = it.rotationDegrees
122 | val rotation = getDisplaySurfaceRotation(viewFinder.display)
123 | updateTransform(viewFinder, rotation, it.textureSize, viewFinderDimens)
124 | }
125 |
126 | // Every time the provided texture view changes, recompute layout
127 | viewFinder.addOnLayoutChangeListener { view, left, top, right, bottom, _, _, _, _ ->
128 | val viewFinder = view as TextureView
129 | val newViewFinderDimens = Size(right - left, bottom - top)
130 | val rotation = getDisplaySurfaceRotation(viewFinder.display)
131 | updateTransform(viewFinder, rotation, bufferDimens, newViewFinderDimens)
132 | }
133 |
134 | // Every time the orientation of device changes, recompute layout
135 | displayManager = viewFinder.context
136 | .getSystemService(Context.DISPLAY_SERVICE) as DisplayManager
137 | displayManager.registerDisplayListener(displayListener, null)
138 |
139 | // Remove the display listeners when the view is detached to avoid
140 | // holding a reference to the View outside of a Fragment.
141 | // NOTE: Even though using a weak reference should take care of this,
142 | // we still try to avoid unnecessary calls to the listener this way.
143 | viewFinder.addOnAttachStateChangeListener(object : View.OnAttachStateChangeListener {
144 | override fun onViewAttachedToWindow(view: View?) = Unit
145 | override fun onViewDetachedFromWindow(view: View?) {
146 | displayManager.unregisterDisplayListener(displayListener)
147 | }
148 |
149 | })
150 | }
151 |
152 | /** Helper function that fits a camera preview into the given [TextureView] */
153 | private fun updateTransform(textureView: TextureView?, rotation: Int?, newBufferDimens: Size,
154 | newViewFinderDimens: Size) {
155 | // This should happen anyway, but now the linter knows
156 | val textureView = textureView ?: return
157 |
158 | if (rotation == viewFinderRotation &&
159 | Objects.equals(newBufferDimens, bufferDimens) &&
160 | Objects.equals(newViewFinderDimens, viewFinderDimens)) {
161 | // Nothing has changed, no need to transform output again
162 | return
163 | }
164 |
165 | if (rotation == null) {
166 | // Invalid rotation - wait for valid inputs before setting matrix
167 | return
168 | } else {
169 | // Update internal field with new inputs
170 | viewFinderRotation = rotation
171 | }
172 |
173 | if (newBufferDimens.width == 0 || newBufferDimens.height == 0) {
174 | // Invalid buffer dimens - wait for valid inputs before setting matrix
175 | return
176 | } else {
177 | // Update internal field with new inputs
178 | bufferDimens = newBufferDimens
179 | }
180 |
181 | if (newViewFinderDimens.width == 0 || newViewFinderDimens.height == 0) {
182 | // Invalid view finder dimens - wait for valid inputs before setting matrix
183 | return
184 | } else {
185 | // Update internal field with new inputs
186 | viewFinderDimens = newViewFinderDimens
187 | }
188 |
189 | val matrix = Matrix()
190 |
191 | // Compute the center of the view finder
192 | val centerX = viewFinderDimens.width / 2f
193 | val centerY = viewFinderDimens.height / 2f
194 |
195 | // Correct preview output to account for display rotation
196 | matrix.postRotate(-viewFinderRotation!!.toFloat(), centerX, centerY)
197 |
198 | // Buffers are rotated relative to the device's 'natural' orientation: swap width and height
199 | val bufferRatio = bufferDimens.height / bufferDimens.width.toFloat()
200 |
201 | val scaledWidth: Int
202 | val scaledHeight: Int
203 | // Match longest sides together -- i.e. apply center-crop transformation
204 | if (viewFinderDimens.width > viewFinderDimens.height) {
205 | scaledHeight = viewFinderDimens.width
206 | scaledWidth = Math.round(viewFinderDimens.width * bufferRatio)
207 | } else {
208 | scaledHeight = viewFinderDimens.height
209 | scaledWidth = Math.round(viewFinderDimens.height * bufferRatio)
210 | }
211 |
212 | // Compute the relative scale value
213 | val xScale = scaledWidth / viewFinderDimens.width.toFloat()
214 | val yScale = scaledHeight / viewFinderDimens.height.toFloat()
215 |
216 | // Scale input buffers to fill the view finder
217 | matrix.preScale(xScale, yScale, centerX, centerY)
218 |
219 | // Finally, apply transformations to our TextureView
220 | textureView.setTransform(matrix)
221 | }
222 |
223 | companion object {
224 | /** Helper function that gets the rotation of a [Display] in degrees */
225 | fun getDisplaySurfaceRotation(display: Display?) = when (display?.rotation) {
226 | Surface.ROTATION_0 -> 0
227 | Surface.ROTATION_90 -> 90
228 | Surface.ROTATION_180 -> 180
229 | Surface.ROTATION_270 -> 270
230 | else -> null
231 | }
232 |
233 | /**
234 | * Main entrypoint for users of this class: instantiates the adapter and returns an instance
235 | * of [Preview] which automatically adjusts in size and rotation to compensate for
236 | * config changes.
237 | */
238 | fun build(config: PreviewConfig, viewFinder: TextureView) =
239 | AutoFitPreviewBuilder(config, WeakReference(viewFinder)).useCase
240 | }
241 | }
--------------------------------------------------------------------------------
/CameraXBasic/app/src/main/java/com/android/example/cameraxbasic/utils/ImageUtils.kt:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2019 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * https://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.android.example.cameraxbasic.utils
18 |
19 | import android.graphics.Bitmap
20 | import android.graphics.BitmapFactory
21 | import android.graphics.Canvas
22 | import android.graphics.Color
23 | import android.graphics.Matrix
24 | import android.graphics.Paint
25 | import android.graphics.PorterDuff
26 | import android.graphics.PorterDuffXfermode
27 | import android.graphics.Rect
28 | import android.media.ThumbnailUtils
29 | import androidx.camera.core.ImageProxy
30 | import androidx.exifinterface.media.ExifInterface
31 | import java.io.File
32 |
33 | /**
34 | * Collection of image reading and manipulation utilities in the form of static functions.
35 | */
36 | abstract class ImageUtils {
37 | companion object {
38 |
39 | /**
40 | * Helper function used to convert an EXIF orientation enum into a transformation matrix
41 | * that can be applied to a bitmap.
42 | *
43 | * @param orientation - One of the constants from [ExifInterface]
44 | */
45 | private fun decodeExifOrientation(orientation: Int): Matrix {
46 | val matrix = Matrix()
47 |
48 | // Apply transformation corresponding to declared EXIF orientation
49 | when (orientation) {
50 | ExifInterface.ORIENTATION_NORMAL -> Unit
51 | ExifInterface.ORIENTATION_UNDEFINED -> Unit
52 | ExifInterface.ORIENTATION_ROTATE_90 -> matrix.postRotate(90F)
53 | ExifInterface.ORIENTATION_ROTATE_180 -> matrix.postRotate(180F)
54 | ExifInterface.ORIENTATION_ROTATE_270 -> matrix.postRotate(270F)
55 | ExifInterface.ORIENTATION_FLIP_HORIZONTAL -> matrix.postScale(-1F, 1F)
56 | ExifInterface.ORIENTATION_FLIP_VERTICAL -> matrix.postScale(1F, -1F)
57 | ExifInterface.ORIENTATION_TRANSPOSE -> {
58 | matrix.postScale(-1F, 1F)
59 | matrix.postRotate(270F)
60 | }
61 | ExifInterface.ORIENTATION_TRANSVERSE -> {
62 | matrix.postScale(-1F, 1F)
63 | matrix.postRotate(90F)
64 | }
65 |
66 | // Error out if the EXIF orientation is invalid
67 | else -> throw IllegalArgumentException("Invalid orientation: $orientation")
68 | }
69 |
70 | // Return the resulting matrix
71 | return matrix
72 | }
73 |
74 | /**
75 | * Decode a bitmap from a file and apply the transformations described in its EXIF data
76 | *
77 | * @param file - The image file to be read using [BitmapFactory.decodeFile]
78 | */
79 | fun decodeBitmap(file: File): Bitmap {
80 | // First, decode EXIF data and retrieve transformation matrix
81 | val exif = ExifInterface(file.absolutePath)
82 | val transformation = decodeExifOrientation(exif.getAttributeInt(
83 | ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_ROTATE_90))
84 |
85 | // Read bitmap using factory methods, and transform it using EXIF data
86 | val bitmap = BitmapFactory.decodeFile(file.absolutePath)
87 | return Bitmap.createBitmap(
88 | BitmapFactory.decodeFile(file.absolutePath),
89 | 0, 0, bitmap.width, bitmap.height, transformation, true)
90 | }
91 |
92 | fun decodeBitmap(image: ImageProxy): Bitmap {
93 | val buffer = image.planes[0].buffer
94 | val bytes = ByteArray(buffer.capacity()).also { buffer.get(it) }
95 | return BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
96 | }
97 |
98 | /**
99 | * This function cuts out a circular thumbnail from the provided bitmap. This is done by
100 | * first scaling the image down to a square with width of [diameter], and then marking all
101 | * pixels outside of the inner circle as transparent.
102 | *
103 | * @param bitmap - The [Bitmap] to be taken a thumbnail of
104 | * @param diameter - Size in pixels for the diameter of the resulting circle
105 | */
106 | fun cropCircularThumbnail(bitmap: Bitmap, diameter: Int = 128): Bitmap {
107 | // Extract a much smaller bitmap to serve as thumbnail
108 | val thumbnail = ThumbnailUtils.extractThumbnail(bitmap, diameter, diameter)
109 |
110 | // Create an additional bitmap of same size as thumbnail to carve a circle out of
111 | val circular = Bitmap.createBitmap(
112 | diameter, diameter, Bitmap.Config.ARGB_8888)
113 |
114 | // Paint will be used as a mask to cut out the circle
115 | val paint = Paint().apply {
116 | color = Color.BLACK
117 | }
118 |
119 | Canvas(circular).apply {
120 | drawARGB(0, 0, 0, 0)
121 | drawCircle(diameter / 2F, diameter / 2F, diameter / 2F - 8, paint)
122 | paint.xfermode = PorterDuffXfermode(PorterDuff.Mode.SRC_IN)
123 | val rect = Rect(0, 0, diameter, diameter)
124 | drawBitmap(thumbnail, rect, rect, paint)
125 | }
126 |
127 | return circular
128 | }
129 | }
130 | }
--------------------------------------------------------------------------------
/CameraXBasic/app/src/main/java/com/android/example/cameraxbasic/utils/ViewExtensions.kt:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2019 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * https://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.android.example.cameraxbasic.utils
18 |
19 | import android.os.Build
20 | import android.view.DisplayCutout
21 | import android.view.View
22 | import android.view.WindowManager
23 | import android.widget.ImageButton
24 | import androidx.annotation.RequiresApi
25 | import androidx.appcompat.app.AlertDialog
26 |
27 | /** Combination of all flags required to put activity into immersive mode */
28 | const val FLAGS_FULLSCREEN =
29 | View.SYSTEM_UI_FLAG_LOW_PROFILE or
30 | View.SYSTEM_UI_FLAG_FULLSCREEN or
31 | View.SYSTEM_UI_FLAG_LAYOUT_STABLE or
32 | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY or
33 | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION or
34 | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
35 |
36 | /** Milliseconds used for UI animations */
37 | const val ANIMATION_FAST_MILLIS = 50L
38 | const val ANIMATION_SLOW_MILLIS = 100L
39 |
40 | /**
41 | * Simulate a button click, including a small delay while it is being pressed to trigger the
42 | * appropriate animations.
43 | */
44 | fun ImageButton.simulateClick(delay: Long = ANIMATION_FAST_MILLIS) {
45 | performClick()
46 | isPressed = true
47 | invalidate()
48 | postDelayed({
49 | invalidate()
50 | isPressed = false
51 | }, delay)
52 | }
53 |
54 | /** Pad this view with the insets provided by the device cutout (i.e. notch) */
55 | @RequiresApi(Build.VERSION_CODES.P)
56 | fun View.padWithDisplayCutout() {
57 |
58 | /** Helper method that applies padding from cutout's safe insets */
59 | fun doPadding(cutout: DisplayCutout) = setPadding(
60 | cutout.safeInsetLeft,
61 | cutout.safeInsetTop,
62 | cutout.safeInsetRight,
63 | cutout.safeInsetBottom)
64 |
65 | // Apply padding using the display cutout designated "safe area"
66 | rootWindowInsets?.displayCutout?.let { doPadding(it) }
67 |
68 | // Set a listener for window insets since view.rootWindowInsets may not be ready yet
69 | setOnApplyWindowInsetsListener { view, insets ->
70 | insets.displayCutout?.let { doPadding(it) }
71 | insets
72 | }
73 | }
74 |
75 | /** Same as [AlertDialog.show] but setting immersive mode in the dialog's window */
76 | fun AlertDialog.showImmersive() {
77 | // Set the dialog to not focusable
78 | window.setFlags(
79 | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE,
80 | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE)
81 |
82 | // Make sure that the dialog's window is in full screen
83 | window.decorView.systemUiVisibility = FLAGS_FULLSCREEN
84 |
85 | // Show the dialog while still in immersive mode
86 | show()
87 |
88 | // Set the dialog to focusable again
89 | window.clearFlags(WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE)
90 | }
91 |
--------------------------------------------------------------------------------
/CameraXBasic/app/src/main/res/color/selector_button_text.xml:
--------------------------------------------------------------------------------
1 |
2 |
17 |
18 | -
19 |
20 |
21 |
22 |
23 |
24 | -
25 |
26 |
27 |
28 |
29 |
30 | -
31 |
32 |
33 |
34 |
35 |
36 | -
37 |
38 |
39 |
40 |
41 |
42 |
--------------------------------------------------------------------------------
/CameraXBasic/app/src/main/res/drawable/ic_back.xml:
--------------------------------------------------------------------------------
1 |
2 |
17 |
23 |
26 |
27 |
--------------------------------------------------------------------------------
/CameraXBasic/app/src/main/res/drawable/ic_delete.xml:
--------------------------------------------------------------------------------
1 |
2 |
17 |
23 |
26 |
27 |
--------------------------------------------------------------------------------
/CameraXBasic/app/src/main/res/drawable/ic_launcher_background.xml:
--------------------------------------------------------------------------------
1 |
2 |
17 |
22 |
25 |
30 |
35 |
40 |
45 |
50 |
55 |
60 |
65 |
70 |
75 |
80 |
85 |
90 |
95 |
100 |
105 |
110 |
115 |
120 |
125 |
130 |
135 |
140 |
145 |
150 |
155 |
160 |
165 |
170 |
175 |
180 |
185 |
186 |
--------------------------------------------------------------------------------
/CameraXBasic/app/src/main/res/drawable/ic_outer_circle.xml:
--------------------------------------------------------------------------------
1 |
2 |
17 |
18 | -
19 |
20 |
23 |
26 |
27 |
28 | -
29 |
30 |
33 |
36 |
37 |
38 | -
39 |
40 |
43 |
46 |
47 |
48 |
--------------------------------------------------------------------------------
/CameraXBasic/app/src/main/res/drawable/ic_photo.xml:
--------------------------------------------------------------------------------
1 |
2 |
17 |
23 |
26 |
--------------------------------------------------------------------------------
/CameraXBasic/app/src/main/res/drawable/ic_share.xml:
--------------------------------------------------------------------------------
1 |
2 |
17 |
23 |
26 |
--------------------------------------------------------------------------------
/CameraXBasic/app/src/main/res/drawable/ic_shutter.xml:
--------------------------------------------------------------------------------
1 |
2 |
17 |
18 |