name: portada
class: portada-slide, center, middle

# Camera
## Android

---
# Gradle - camera
```
implementation("androidx.camera:camera-core:1.5.0-alpha06")
implementation("androidx.camera:camera-camera2:1.5.0-alpha06")
implementation("androidx.camera:camera-compose:1.5.0-alpha06")
implementation("androidx.camera:camera-lifecycle:1.5.0-alpha06")
implementation("androidx.camera:camera-extensions:1.5.0-alpha06")
```

---
# Camera ViewModel
```
class CameraViewModel() : ViewModel(){
    val surferRequest = mutableStateOf<SurfaceRequest?>(null)

private val cameraPreviewUseCase = Preview.Builder().build().apply {
        setSurfaceProvider { newSurfaceRequest ->
            surferRequest.value = newSurfaceRequest
        }
    }
    val imageCaptureUseCase: ImageCapture = ImageCapture.Builder().build()

suspend fun bindToCamera(appContext: Context, lifecycleOwner: LifecycleOwner) {
        val processCameraProvider = ProcessCameraProvider.awaitInstance(appContext)
        processCameraProvider.bindToLifecycle(lifecycleOwner, DEFAULT_BACK_CAMERA, cameraPreviewUseCase, imageCaptureUseCase
        )
        try { awaitCancellation() } finally { processCameraProvider.unbindAll() }
    }
}
```

---
# Camera Screen
```
@Composable
fun CameraScreen(){
    FeatureThatRequiresCameraPermission(){
        val viewModel = viewModel{CameraViewModel() }
        val context = LocalContext.current
        val lifecycleOwner = LocalLifecycleOwner.current
        LaunchedEffect(lifecycleOwner) {
            viewModel.bindToCamera(context.applicationContext, lifecycleOwner)
        }

val surfaceRequest = viewModel.surferRequest.value

surfaceRequest?.let { request ->
                CameraXViewfinder(
                    surfaceRequest = request,
                    modifier = Modifier.fillMaxSize()
                )
            }
        }
    }
}
```

---
# Take photo (viewModel)
```
fun takePhoto(context: Context) {
    val name = "photo_"+ System.nanoTime()
    val contentValues = ContentValues().apply {
        put(MediaStore.MediaColumns.DISPLAY_NAME, name)
        put(MediaStore.MediaColumns.MIME_TYPE, "image/jpeg")
        if (Build.VERSION.SDK_INT > Build.VERSION_CODES.P) {
            put(MediaStore.Images.Media.RELATIVE_PATH, "Pictures/CameraX-Image")
        }
    }
    val outputOptions = ImageCapture.OutputFileOptions.Builder(
            context.contentResolver,
            MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
            contentValues
        ).build()
    imageCaptureUseCase.takePicture(
        outputOptions,
        ContextCompat.getMainExecutor(context),
        object : ImageCapture.OnImageSavedCallback {
            override fun onError(exc: ImageCaptureException) {
                Log.e("CameraPreview", "Photo capture failed: ${exc.message}", exc)
            }

override fun onImageSaved(output: ImageCapture.OutputFileResults) {
                Log.d("CameraPreview", "Photo capture succeeded: ${output.savedUri}")
            }
        }
    )
}
```

---
# Take photo - Camera screen
```
@Composable
fun CameraScreen(){
    val viewModel = viewModel{CameraViewModel() }
    val context = LocalContext.current
    val lifecycleOwner = LocalLifecycleOwner.current
    LaunchedEffect(lifecycleOwner) {
        viewModel.bindToCamera(context.applicationContext, lifecycleOwner)
    }

val surfaceRequest = viewModel.surferRequest.value

surfaceRequest?.let { request ->
        Box {

CameraXViewfinder(
                surfaceRequest = request,
                modifier = Modifier.fillMaxSize()
            )
            Button({ takePhoto(context) }){
                Text("Take Photo")
            }
        }
    }
    
}
```