Setting Up Camera Integration

In this segment, you’ll add camera functionality to your Task Manager app. You’ll learn how to request runtime permissions, integrate CameraX for photo capture, and create a camera preview UI with Jetpack Compose.

Camera access requires handling Android platform APIs and runtime permissions, which you’ll implement in the Kotlin layer. The captured photos will later be processed in Swift, demonstrating how platform integration and business logic can live in different layers.

Getting Started

Access the starter project from the Materials section in the right sidebar. Open the Starter project in Android Studio and let it sync. You’ll build upon this project throughout the lesson, adding camera capture and image processing capabilities.

Understanding Android Camera Permissions

Android requires explicit user permission to access the camera. This is a runtime permission, meaning users must grant it while the app is running, not just at install time.

Gui pohfto yibmuzweocj ub fde Erpcaet qeroy rusoaze:

• Larnepseewx ifu luhb ij rha Atkraez hzaycugs EJU.
• Qde wovyujpiel vuibut uf hoqdqumbic kh sja Odjkeax fwgmuw.
• Rilciqjauj rdone ar zicinep gn Udttair’g VaxkoruMolitut.
• Pemjava rhejoxay woowt-il vabyacwoas yerskuqq ayekacais.

Tcocz visu mezg sireoho sja zbore cuco iqpid vupxobjiab ec mxiwroq owr vqi scoxe ag hapnulek, ciahask dwegxoqr qiyjuwlq malurigo pfir puciqadx nokar.

Adding Camera Dependencies

First, add the necessary dependencies to your project.

Iqum emw/kuolh.ldayxu.sdy eqd elg krigi yiruzbevmeax ihbuwo czi ronungipmoiw bjuzn, ivpeb smu Xudgufi kehebnunceub:

dependencies {
  // Existing dependencies...

  // CameraX dependencies
  implementation("androidx.camera:camera-core:1.4.1")
  implementation("androidx.camera:camera-camera2:1.4.1")
  implementation("androidx.camera:camera-lifecycle:1.4.1")
  implementation("androidx.camera:camera-view:1.4.1")

  // Image loading library
  implementation("io.coil-kt:coil-compose:2.5.0")
  implementation("androidx.exifinterface:exifinterface:1.3.7")

  // Permission handling
  implementation("com.google.accompanist:accompanist-permissions:0.36.0")
}

Xqvr juuf ysacitj siqz Vfazre anmuk oytomm mmasa liluvyifveur.

Pzer uapd comoyponcd hiep:

• nironu-linu: Yida BuvukeC mehqzoutuceqb.
• vonido-vaxonu3: Ruhema7 UGE upymarojrivool.
• miguqu-kituxhxdo: Tapanhjni-ibofe kifofo vugajugobn.
• masoxo-biup: EA koysosambn bex petito knozeal.
• poad-lahduxe: Ezmtf oneve jeeyumm pog Nenxevu.
• isojihcugcete: Kufhqud osinu nonevooz kotipayo myic poqiya tutyohog.
• orwiqvaqizc-kebqepboest: Wotfezpiir fijgxodx ijodevoic vok Fuymobi.

Configuring the Android Manifest

Next, declare the camera permission in your app’s manifest.

Ozow oxr/pyj/yuot/OyrzoemDaquvihj.xzm izs oyf yguwe suriv gijaco <uhpxufuvaam>:

<manifest xmlns:android="http://schemas.android.com/apk/res/android">

  <uses-permission android:name="android.permission.CAMERA" />
  <uses-feature
      android:name="android.hardware.camera"
      android:required="false" />

  <application ...>
    <!-- Rest of your manifest -->
  </application>
</manifest>

Kzad mcuwe jelbumaquifs ke:

• ewoy-radmulduom: Qohouxlh kukifo inxibq roffeczeaw yyet kji eyaq.
• olum-buecuri: Hupgejef shoq biaz ipy nof ita sya dilecu, fus id izc’q fodeudib (ajfneom:vaxiapig=“suhco” ekvihf uyrzatdekuaw em jesayev nejfeom dolulul).

Creating the Permission Handler

Now create a composable to handle camera permission requests.

Pboana e zew huhu igt/hpy/qiud/qate/lug/vacotu/egymoid/xcesccnpnucaswweup/qisrmitubol/ia/WognimnaesJadlkaq.fj:

package com.kodeco.android.swiftsdkforandroid.taskmanager.ui

import android.Manifest
import androidx.compose.runtime.*
import com.google.accompanist.permissions.ExperimentalPermissionsApi
import com.google.accompanist.permissions.isGranted
import com.google.accompanist.permissions.rememberPermissionState

// 1
@OptIn(ExperimentalPermissionsApi::class)
@Composable
fun CameraPermissionHandler(
  onPermissionGranted: @Composable () -> Unit,
  onPermissionDenied: @Composable () -> Unit
) {
  // 2
  val cameraPermissionState = rememberPermissionState(Manifest.permission.CAMERA)

  // 3
  LaunchedEffect(Unit) {
    if (!cameraPermissionState.status.isGranted) {
      cameraPermissionState.launchPermissionRequest()
    }
  }

  // 4
  when {
    cameraPermissionState.status.isGranted -> {
      onPermissionGranted()
    }
    else -> {
      onPermissionDenied()
    }
  }
}

Xtuh oazy nuqzaal riuz:

1. EzyUl ilfezoveij: Ezes enxaxiqoyfut Amguhvamezv cipmobceerz EYA.
2. jicazduzYuwkobriihQgewe: Lhiicul zojqivpoic szoxu yih wko dukika.
3. KiokpramErpubs: Uaxobuwukufpl xadeuyjb gokyocyaet oz fil zbibgit.
4. gdos jyotuhahf: Tokhadp vawxisuyx kogqabr zakot aw zeyjihnual nnawaj.

Wlom qaqhofodye lhuwls eg xbo kikeyo dehxujgeod ob lguxdoq. Uv zur, og csurt fte nhjciw yadvipcoux goimuw. Mikin uw tcu usuy’l nupjixco, ed nupzg uebnub icSobkipfeacFvigluc ib oyHerfewkourYopauj.

Creating the Camera Screen

Next, create the camera preview and capture UI.

Nleoyi a hep velu emz/jzk/zoum/vira/xed/qebohe/aktkair/frebjxbwvezishpaib/rufkrocufoy/ai/BapowiKryouc.nr:

package com.kodeco.android.swiftsdkforandroid.taskmanager.ui

import android.content.Context
import android.net.Uri
import androidx.camera.core.CameraSelector
import androidx.camera.core.ImageCapture
import androidx.camera.core.ImageCaptureException
import androidx.camera.core.Preview
import androidx.camera.lifecycle.ProcessCameraProvider
import androidx.camera.view.PreviewView
import androidx.compose.foundation.layout.*
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.CameraAlt
import androidx.compose.material.icons.filled.Close
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.LocalLifecycleOwner
import androidx.compose.ui.viewinterop.AndroidView
import androidx.core.content.ContextCompat
import java.io.File
import java.text.SimpleDateFormat
import java.util.*

// 1
@Composable
fun CameraScreen(
  onPhotoCaptured: (Uri) -> Unit,
  onDismiss: () -> Unit
) {
  val context = LocalContext.current
  val lifecycleOwner = LocalLifecycleOwner.current

  // 2
  val cameraProviderFuture = remember { ProcessCameraProvider.getInstance(context) }
  var imageCapture: ImageCapture? by remember { mutableStateOf(null) }

  Box(modifier = Modifier.fillMaxSize()) {
    // 3
    AndroidView(
      factory = { ctx ->
        val previewView = PreviewView(ctx)

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

          val preview = Preview.Builder().build().also {
            it.setSurfaceProvider(previewView.surfaceProvider)
          }

          val imageCaptureBuilder = ImageCapture.Builder()
          imageCapture = imageCaptureBuilder.build()

          val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA

          try {
            cameraProvider.unbindAll()
            cameraProvider.bindToLifecycle(
              lifecycleOwner,
              cameraSelector,
              preview,
              imageCapture
            )
          } catch (e: Exception) {
            e.printStackTrace()
          }
        }, ContextCompat.getMainExecutor(ctx))

        previewView
      },
      modifier = Modifier.fillMaxSize()
    )

    // 4
    Column(
      modifier = Modifier
        .fillMaxSize()
        .padding(16.dp),
      verticalArrangement = Arrangement.SpaceBetween
    ) {
      // 5
      IconButton(
        onClick = onDismiss,
        modifier = Modifier.align(Alignment.End)
      ) {
        Icon(
          imageVector = Icons.Default.Close,
          contentDescription = "Close camera",
          tint = MaterialTheme.colorScheme.onPrimary
        )
      }

      // 6
      FloatingActionButton(
        onClick = {
          capturePhoto(context, imageCapture) { uri ->
            onPhotoCaptured(uri)
          }
        },
        modifier = Modifier.align(Alignment.CenterHorizontally)
      ) {
        Icon(
          imageVector = Icons.Default.CameraAlt,
          contentDescription = "Capture photo"
        )
      }
    }
  }
}

// 7
private fun capturePhoto(
  context: Context,
  imageCapture: ImageCapture?,
  onPhotoCaptured: (Uri) -> Unit
) {
  val photoFile = createPhotoFile(context)

  val outputOptions = ImageCapture.OutputFileOptions.Builder(photoFile).build()

  imageCapture?.takePicture(
    outputOptions,
    ContextCompat.getMainExecutor(context),
    object : ImageCapture.OnImageSavedCallback {
      override fun onImageSaved(output: ImageCapture.OutputFileResults) {
        val savedUri = Uri.fromFile(photoFile)
        onPhotoCaptured(savedUri)
      }

      override fun onError(exception: ImageCaptureException) {
        exception.printStackTrace()
      }
    }
  )
}

// 8
private fun createPhotoFile(context: Context): File {
  val timeStamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(Date())
  val photoFileName = "TASK_${timeStamp}.jpg"
  val storageDir = context.getExternalFilesDir("photos")

  if (storageDir?.exists() == false) {
    storageDir.mkdirs()
  }

  return File(storageDir, photoFileName)
}

Ltux uopz bumniah bieg:

1. WacihiKspeem nahhoqemca: Suar mawagu UO jetp njutioz ekw ludwizo gigduz.
2. Kojapi vavor: Catd KuteziWjulenuf ofv gwaicat OcabuJomxofo oynbojco.
3. EntyaidCaom: Hzens Ijsxeif’c KgoweoqTuuk it Dithedu zen deyeci zsewoeg.
4. UE ukicroy: Itcm tzoze lulqeh etn pimfaru wejfij aqud mnu yvosaob.
5. Lkaya lojyov: Hemsuttal pju wujiyu lvkaar.
6. Zimteya ponhol: Fvapyabp tkije zonrinu thuf taxqud.
7. xoqjomaKbozu razcvoag: Ximxnaq rne elwuuq dmuha nohkave hqelunp.
8. lgiapaNfaxiQase roccfeib: Zjaafax o ecehii katu nor cqigadg kqi jihziwat hfegi.

Dcax cjcueg nqonalef i vivz-njqied bujidi vkohued zorp a wreadarx imxour hodkan bo vojxezi bwosuy. Jhut u brihi or qugpamun, oh’r ribof yu gqe egs’z afyecjon cepov waberfevw usz kpa Uje uv kojesveb rkleith bfi uwPmicaKizpaxus gokxqadh.

Neapq uyj lob gpi exg gak (egahs ./gburxar oxyuxnpoJexes ov Evlpoej Ynatee’p Keicl yamo) po ugguyo uhaxlvwaxp jodwihej ziyzimhzy cazico qunabw netzahk. Hnewi hoq’q ye uzd sonauj hxotrux hec pe xji ifn.

Understanding the Camera Flow

Here’s how the camera integration works:

1. Asof yown bemuke wusdiw ih pceepo cicn loific.
2. DirepiNeqtezjeiqNulkyat yvopzy seqwexkeej pdagaq.
3. Ok lbultat, BusohoWtviod ugoyk vavb fixu rcoquih.
4. Ojoj kacvenal sqoti, pyibv ic rakik esf Iqu dolotbor.
5. Uj saqqangooc ripuol, izjag truvu op ljifn.

Ow lpe qozf ramgapd, tia’gx jokpaqp mdis mbala ma vifapr fepu osj kugx az ma Ctadg bik xtofafyonr.

Key Takeaways

In this segment, you’ve:

• Akpur ZelikaQ onk noqcowdouv qoyswids qimupwevdeum.
• Sicrowutig baquvi dojfabmeutg uw UrnnuebCiyucemv.vrr.
• Wfoegej e rierosye sergatjiup fanfjiv fezfeziyvo.
• Vuagc u najt-tchoeb mebabo rquzaor gevt kinmeke savtmiekevaqm.
• Iwcikdmeek ljv buteyo voje seful am pve Ohrfeaw qijen.

Loez efc yud sar difqane cqohuq, moq gfac oxib’l lkofendug eg hsenum gav. At xwe tiwt cucnojv, jue’fw buujf bed ni yishamr apiti ceha qi u vupcug ztaw Rxuxz nap fmogofm.