Working with Camera

val CAMERA_PERMISSION = Manifest.permission.CAMERA
val PERMISSION_REQUEST_CODE = 100

if (ContextCompat.checkSelfPermission(this, CAMERA_PERMISSION) != PackageManager.PERMISSION_GRANTED) {
    ActivityCompat.requestPermissions(this, arrayOf(CAMERA_PERMISSION), PERMISSION_REQUEST_CODE)
} else {
    // Permission already granted, proceed to open camera
}

override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
    when (requestCode) {
        PERMISSION_REQUEST_CODE -> {
            if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                // Permission granted, initialize camera
            } else {
                // Permission denied, show rationale or disable feature
            }
        }
    }
}

val intent = Intent(MediaStore.ACTION_IMAGE_CAPTURE)
val photoFile = File(externalCacheDir, "photo.jpg")
val imageUri = FileProvider.getUriForFile(this, "com.example.fileprovider", photoFile)
intent.putExtra(MediaStore.EXTRA_OUTPUT, imageUri)
startActivityForResult(intent, REQUEST_IMAGE_CAPTURE)

val imageCapture = ImageCapture.Builder()
    .setTargetRotation(viewFinder.display.rotation)
    .build()

val photoFile = File(context.filesDir, "photo.jpg")
val outputFileOptions = ImageCapture.OutputFileOptions.Builder(photoFile).build()

imageCapture.takePicture(
    outputFileOptions,
    ContextCompat.getMainExecutor(context),
    object : ImageCapture.OnImageSavedCallback {
        override fun onImageSaved(output: ImageCapture.OutputFileResults) {
            val savedUri = output.savedUri ?: return
            Log.d("Camera", "Photo saved: $savedUri")
        }

        override fun onError(exception: ImageCaptureException) {
            Log.e("Camera", "Photo capture failed: ${exception.message}")
        }
    }
)

val outputFile = File(context.getExternalFilesDir(null), "captured_image.jpg")
val imageCapture = ImageCapture.Builder()
    .setTargetRotation(Surface.ROTATION_0)
    .setFileOutputFormat(ImageCapture.FORMAT_JPEG)
    .build()

val imageCaptureCallback = ImageCapture.OnImageSavedCallback { output ->
    val savedUri = output.savedUri
    if (savedUri != null) {
        // Notify gallery about new image
        val intent = Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE)
        intent.data = savedUri
        context.sendBroadcast(intent)
    }
}

import androidx.camera.core.CameraProvider
import androidx.camera.lifecycle.ProcessCameraProvider
import androidx.camera.view.PreviewView
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity

class CameraActivity : AppCompatActivity() {
    private lateinit var cameraProvider: ProcessCameraProvider
    private lateinit var previewView: PreviewView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_camera)

        previewView = findViewById(R.id.preview_view)
        startCamera()
    }

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

        cameraProviderFuture.addListener({
            cameraProvider = cameraProviderFuture.get()
            val preview = Preview.Builder().build().apply {
                setSurfaceProvider(previewView.surfaceProvider)
            }
            cameraProvider.bindToLifecycle(this, CameraSelector.DEFAULT_BACK_CAMERA, preview)
        }, ContextCompat.getMainExecutor(this))
    }
}

val preview = Preview.Builder().build()
preview.setSurfaceProvider(viewFinder.surfaceProvider)

val imageCapture = ImageCapture.Builder()
    .setTargetRotation(viewFinder.display.rotation)
    .build()

val videoCapture = VideoCapture.Builder()
    .setTargetRotation(viewFinder.display.rotation)
    .build()

import androidx.camera.core.CameraProvider
import androidx.camera.core.ImageCapture
import androidx.camera.core.PreviewView

class CameraActivity : AppCompatActivity() {
    private lateinit var cameraProvider: CameraProvider
    private lateinit var imageCapture: ImageCapture

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_camera)

        val previewView = findViewById<PreviewView>(R.id.previewView)
        imageCapture = ImageCapture.Builder().build()

        cameraProvider = ProcessCameraProvider.getInstance(this).get()
    }
}

val outputFile = File(context.filesDir, "image.jpg")
val outputOptions = ImageCapture.OutputFileOptions.Builder(outputFile).build()

imageCapture.takePicture(
    outputOptions,
    ContextCompat.getMainExecutor(context),
    object : ImageCapture.OnImageSavedCallback {
        override fun onImageSaved(savedImage: ImageCapture.OutputFileResults) {
            val msg = "Image saved successfully"
            Toast.makeText(context, msg, Toast.LENGTH_SHORT).show()
        }

        override fun onError(exception: ImageCaptureException) {
            val msg = "Image capture failed: ${exception.message}"
            Toast.makeText(context, msg, Toast.LENGTH_SHORT).show()
        }
    }
)

val cameraProviderFuture = ProcessCameraProvider.getInstance(this)

cameraProviderFuture.addListener({
    val cameraProvider = cameraProviderFuture.get()

    val preview = Preview.Builder().build()
    val videoCapture = VideoCapture.Builder().build()

    val cameraProviderFuture = ProcessCameraProvider.getInstance(this)
    cameraProviderFuture.addListener({
        val cameraProvider = cameraProviderFuture.get()

        val preview = Preview.Builder().build()
        val videoCapture = VideoCapture.Builder().build()

        cameraProvider.unbindAll()
        cameraProvider.bindToLifecycle(
            this, 
            CameraSelector.DEFAULT_BACK_CAMERA,
            preview,
            videoCapture
        )

        val outputFile = File(filesDir, "video.mp4")
        val outputOptions = VideoCapture.OutputFileOptions.Builder(outputFile).build()

        videoCapture.startRecording(
            outputOptions,
            ContextCompat.getMainExecutor(this)
        )
    }, ContextCompat.getMainExecutor(this))
}, ContextCompat.getMainExecutor(this))

val cameraManager = getSystemService(Context.CAMERA_SERVICE) as CameraManager
val cameraId = cameraManager.cameraIdList[0]
val characteristics = cameraManager.getCameraCharacteristics(cameraId)

// Get supported preview sizes
val previewSizes = characteristics.get(
    CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)
    ?.getOutputSizes(SurfaceTexture::class.java)

// Set preview size
val previewSize = Size(1920, 1080)

// Set picture size
val pictureSize = Size(4032, 3024)

// Set flash mode
val flashMode = CameraMetadata.FLASH_MODE_AUTO

// Set focus mode
val focusMode = CameraMetadata.LENS_FOCUS_DISTANCE

class CameraLifecycleManager {
    private var cameraProvider: CameraProvider? = null
    private var camera: Camera? = null

    fun initializeCamera() {
        // INITIALIZED state
        cameraProvider = CameraProvider()
        camera = cameraProvider?.createCamera()
    }

    fun openCamera() {
        // OPENED state
        camera?.open()
        startPreview()
    }

    fun startPreview() {
        // PREVIEW_STARTED state
        camera?.startPreview()
    }

    fun captureImage() {
        // CAPTURE_STARTED state
        camera?.captureImage()
    }

    fun closeCamera() {
        // CLOSED state
        camera?.close()
        camera = null
        cameraProvider = null
    }
}

import android.graphics.Bitmap
import androidx.camera.core.ImageAnalysis
import androidx.camera.core.ImageAnalysisConfig
import androidx.camera.core.ImageProxy
import java.nio.ByteBuffer

class ImageAnalyzer : ImageAnalysis.Analyzer {
    override fun analyze(image: ImageProxy) {
        val bitmap = image.toBitmap()
        // Process bitmap for analysis
        val buffer = image.planes[0].buffer
        val data = ByteArray(buffer.remaining())
        buffer.get(data)
        // Analyze image data
    }
}

val imageAnalysis = ImageAnalysis.Builder()
    .setTargetResolution(Size(640, 480))
    .build()
imageAnalysis.setAnalyzer(ContextCompat.getMainExecutor(context), ImageAnalyzer())

val cameraProvider = CameraProviderManager.getInstance(context)
val cameraSelector = CameraSelector.Builder()
    .requireLensFacing(CameraSelector.LENS_FACING_BACK)
    .build()

val cameraProviderFuture = cameraProvider.bindToLifecycle(lifecycleOwner, cameraSelector, preview)

// Switch to front camera
val frontCameraSelector = CameraSelector.Builder()
    .requireLensFacing(CameraSelector.LENS_FACING_FRONT)
    .build()

cameraProvider.unbindAll()
cameraProvider.bindToLifecycle(lifecycleOwner, frontCameraSelector, preview)