I would like to put the camera capture in full screen. Even when setting a ‘Resolution strategy’ to 1280 by 1280, the size does not change. I am using these versions of CameraX.

    def camerax_version = "1.3.4"
    implementation "androidx.camera:camera-camera2:$camerax_version"
    implementation "androidx.camera:camera-lifecycle:$camerax_version"
    implementation "androidx.camera:camera-view:$camerax_version"
    implementation "androidx.camera:camera-extensions:$camerax_version"
    implementation ("androidx.camera:camera-core:${camerax_version}")

This is the code of my camera manager:

package com.quarks.safety.sdsbinder.camera

import android.content.Context
import android.util.Size
import android.view.View
import androidx.camera.core.Camera
import androidx.camera.core.CameraSelector
import androidx.camera.core.ImageAnalysis
import androidx.camera.core.ImageCapture
import androidx.camera.core.Preview
import androidx.camera.core.resolutionselector.ResolutionSelector
import androidx.camera.core.resolutionselector.ResolutionStrategy
import androidx.camera.lifecycle.ProcessCameraProvider
import androidx.camera.view.PreviewView
import androidx.core.content.ContextCompat
import androidx.lifecycle.LifecycleOwner
import com.quarks.safety.sdsbinder.camera.barcode.DetectionCallBack
import com.quarks.safety.sdsbinder.util.L
import java.util.concurrent.Executors

class CameraManager(
    val context: Context,
    private val previewView: PreviewView,
    overlay: GraphicOverlay,
    scope: View,
    private val lifecycleOwner: LifecycleOwner,
) {
    private val qrCodeProcessor = QrCodeScannerProcessor(overlay, scope)
    private val cameraExecutor = Executors.newSingleThreadExecutor()
    private var preview: Preview? = null
    private var imageAnalysis: ImageAnalysis? = null
    private var cameraSelectorOption = CameraSelector.LENS_FACING_BACK
    private lateinit var imageCapture: ImageCapture
    private var camera: Camera? = null

    fun addAnalyserListener(callback: DetectionCallBack) {
        qrCodeProcessor.addListeners(callback)
    }

    fun startCamera() {
        previewView.scaleType = PreviewView.ScaleType.FIT_CENTER
        val resolutionSelector =
            ResolutionSelector.Builder().apply {
                setResolutionStrategy(
                    ResolutionStrategy(
                        Size(1280, 1280),
                        ResolutionStrategy.FALLBACK_RULE_CLOSEST_HIGHER_THEN_LOWER,
                    ),
                )
            }

        val cameraProviderFuture = ProcessCameraProvider.getInstance(context)
        cameraProviderFuture.addListener({
            val cameraProvider = cameraProviderFuture.get()
            preview =
                Preview
                    .Builder()
                    .setResolutionSelector(resolutionSelector.build())
                    .build()

            imageAnalysis =
                ImageAnalysis
                    .Builder()
                    .setTargetResolution(Size(1280, 1280))
                    .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
                    .build()
                    .also {
                        it.setAnalyzer(cameraExecutor, qrCodeProcessor)
                    }

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

            imageCapture =
                ImageCapture
                    .Builder()
                    .setResolutionSelector(resolutionSelector.build())
                    .build()
            setCameraConfig(cameraProvider, cameraSelector)
        }, ContextCompat.getMainExecutor(context))
    }

    private fun setCameraConfig(
        cameraProvider: ProcessCameraProvider?,
        cameraSelector: CameraSelector,
    ) {
        try {
            cameraProvider?.unbindAll()
            camera =
                cameraProvider?.bindToLifecycle(
                    lifecycleOwner,
                    cameraSelector,
                    preview,
                    imageCapture,
                    imageAnalysis,
                )

            preview?.setSurfaceProvider(
                previewView.surfaceProvider,
            )
        } catch (error: Throwable) {
            L.v(error)
        }
    }
}

I have tried setting the ratio to 16:9 or using different sizes in the ‘Resolution strategy’, but it does not change the camera’s ratio.