Camera access in Android Kotlin - Mini App: Build & Ship

Build: Camera Access Screen

This screen allows the user to open the device camera and take a photo. The photo is then displayed on the screen.

Target UI

-------------------------
| Camera Access Screen   |
|-----------------------|
| [Open Camera Button]   |
|                       |
| [Photo will appear here]|
|                       |
-------------------------

Add a button labeled 'Open Camera' that opens the device camera when tapped.

Request camera permission at runtime if not already granted.

Display the captured photo below the button after taking a picture.

Handle permission denial gracefully with a message.

Starter Code

Android Kotlin

package com.example.cameraaccess

import android.Manifest
import android.app.Activity
import android.content.Intent
import android.content.pm.PackageManager
import android.graphics.Bitmap
import android.os.Bundle
import android.provider.MediaStore
import android.widget.Button
import android.widget.ImageView
import android.widget.Toast
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AppCompatActivity
import androidx.core.content.ContextCompat

class CameraAccessActivity : AppCompatActivity() {
    private lateinit var openCameraButton: Button
    private lateinit var photoImageView: ImageView

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

        openCameraButton = findViewById(R.id.openCameraButton)
        photoImageView = findViewById(R.id.photoImageView)

        openCameraButton.setOnClickListener {
            // TODO: Check permission and open camera
        }
    }
}

Task 1

Task 2

Task 3

Task 4

Solution

Android Kotlin

package com.example.cameraaccess

import android.Manifest
import android.app.Activity
import android.content.Intent
import android.content.pm.PackageManager
import android.graphics.Bitmap
import android.os.Bundle
import android.provider.MediaStore
import android.widget.Button
import android.widget.ImageView
import android.widget.Toast
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AppCompatActivity
import androidx.core.content.ContextCompat

class CameraAccessActivity : AppCompatActivity() {
    private lateinit var openCameraButton: Button
    private lateinit var photoImageView: ImageView

    private val cameraLauncher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
        if (result.resultCode == Activity.RESULT_OK) {
            val imageBitmap = result.data?.extras?.get("data") as? Bitmap
            if (imageBitmap != null) {
                photoImageView.setImageBitmap(imageBitmap)
            } else {
                Toast.makeText(this, "Failed to capture image", Toast.LENGTH_SHORT).show()
            }
        }
    }

    private val requestPermissionLauncher = registerForActivityResult(
        ActivityResultContracts.RequestPermission()
    ) { isGranted: Boolean ->
        if (isGranted) {
            openCamera()
        } else {
            Toast.makeText(this, "Camera permission denied", Toast.LENGTH_SHORT).show()
        }
    }

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

        openCameraButton = findViewById(R.id.openCameraButton)
        photoImageView = findViewById(R.id.photoImageView)

        openCameraButton.setOnClickListener {
            when {
                ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED -> {
                    openCamera()
                }
                else -> {
                    requestPermissionLauncher.launch(Manifest.permission.CAMERA)
                }
            }
        }
    }

    private fun openCamera() {
        val cameraIntent = Intent(MediaStore.ACTION_IMAGE_CAPTURE)
        cameraLauncher.launch(cameraIntent)
    }
}

This solution uses the modern Activity Result API to handle both permission requests and camera intent results.

When the user taps the 'Open Camera' button, the app checks if the camera permission is granted. If yes, it opens the camera. If not, it requests permission.

When the camera returns a photo, the app extracts the thumbnail bitmap from the intent extras and displays it in the ImageView below the button.

If permission is denied, a Toast message informs the user.

Final Result

Completed Screen

-------------------------
| Camera Access Screen   |
|-----------------------|
| [Open Camera Button]   |
|                       |
| [Captured photo shown] |
|                       |
-------------------------

User taps 'Open Camera' button.

If permission not granted, app asks for camera permission.

If permission granted, camera app opens.

User takes a photo and confirms.

Photo thumbnail appears below the button.

If permission denied, a message 'Camera permission denied' shows.

Stretch Goal

Add a button to save the captured photo to the device gallery.

💡 Hint

Use MediaStore.Images.Media.insertImage() method to save the bitmap.

Practice

1. What is the main purpose of using MediaStore.ACTION_IMAGE_CAPTURE in an Android app?

easy

A. To open the device camera to take a photo

B. To open the device gallery to select a photo

C. To record audio using the microphone

D. To access device location services

Solution

1. Step 1: Understand the intent action

   MediaStore.ACTION_IMAGE_CAPTURE is a predefined intent action to launch the camera app for capturing images.

2. Step 2: Identify the purpose in the app

   This intent opens the camera so the user can take a photo, which the app can then receive.

3. Final Answer:

   To open the device camera to take a photo -> Option A

4. Quick Check:

   Camera intent = open camera [OK]

Hint: Remember: ACTION_IMAGE_CAPTURE means open camera [OK]

Common Mistakes:

• Confusing camera intent with gallery intent
• Thinking it records audio
• Assuming it accesses location

2. Which of the following is the correct Kotlin syntax to start the camera intent for result in an Activity?

easy

A. startActivityForResult(Intent(MediaStore.ACTION_IMAGE_CAPTURE), REQUEST_CODE)

B. startActivity(Intent(MediaStore.ACTION_IMAGE_CAPTURE))

C. startActivityForResult(MediaStore.ACTION_IMAGE_CAPTURE, REQUEST_CODE)

D. startActivityForResult(Intent(REQUEST_CODE), MediaStore.ACTION_IMAGE_CAPTURE)

Solution

1. Step 1: Check the method signature

   startActivityForResult requires an Intent and a request code integer.

2. Step 2: Verify the Intent creation

   The Intent must be created with MediaStore.ACTION_IMAGE_CAPTURE as the action.

3. Final Answer:

   startActivityForResult(Intent(MediaStore.ACTION_IMAGE_CAPTURE), REQUEST_CODE) -> Option A

4. Quick Check:

   Intent + request code = startActivityForResult [OK]

Hint: Intent first, then request code in startActivityForResult [OK]

Common Mistakes:

• Passing action string instead of Intent
• Omitting request code
• Swapping Intent and request code parameters

3. Given this code snippet in an Activity, what will be the output when the user takes a photo successfully?

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
  super.onActivityResult(requestCode, resultCode, data)
  if (requestCode == REQUEST_CODE && resultCode == RESULT_OK) {
    val photo = data?.extras?.get("data") as Bitmap
    imageView.setImageBitmap(photo)
  }
}

medium

A. The app will display a default image instead

B. The app will crash due to a null pointer exception

C. Nothing happens because onActivityResult is not called

D. The photo taken by the user will be displayed in imageView

Solution

1. Step 1: Understand onActivityResult behavior

   This method receives the result from the camera intent when the user takes a photo.

2. Step 2: Check the code logic

   If the request and result codes match, it extracts the photo bitmap from the intent extras and sets it to the imageView.

3. Final Answer:

   The photo taken by the user will be displayed in imageView -> Option D

4. Quick Check:

   Photo bitmap set to imageView = display photo [OK]

Hint: Check requestCode and resultCode before using data [OK]

Common Mistakes:

• Not checking requestCode or resultCode
• Casting data extras incorrectly
• Forgetting to call super.onActivityResult

4. Identify the error in this Kotlin code snippet for launching the camera:

val intent = Intent()
intent.action = MediaStore.ACTION_IMAGE_CAPTURE
startActivityForResult(intent)

medium

A. Intent action should be set using setAction() method

B. Missing request code parameter in startActivityForResult

C. Intent should be created with MediaStore.ACTION_IMAGE_CAPTURE in constructor

D. startActivityForResult cannot be used to launch camera

Solution

1. Step 1: Check startActivityForResult usage

   This method requires two parameters: an Intent and a request code integer.

2. Step 2: Identify missing parameter

   The code calls startActivityForResult with only the Intent, missing the request code.

3. Final Answer:

   Missing request code parameter in startActivityForResult -> Option B

4. Quick Check:

   startActivityForResult needs Intent + request code [OK]

Hint: Always pass request code with Intent in startActivityForResult [OK]

Common Mistakes:

• Omitting request code parameter
• Using wrong Intent constructor
• Misunderstanding startActivityForResult signature

5. You want to save a full-size photo taken by the camera to a file in your app. Which approach correctly combines camera intent and file handling in Kotlin?

hard

A. Save photo by reading camera app cache directory after intent finishes

B. Start camera intent without extras, then save thumbnail from data extras

C. Create a file URI, pass it with Intent extra MediaStore.EXTRA_OUTPUT, then start camera intent

D. Use MediaStore.ACTION_VIDEO_CAPTURE intent to save photo file

Solution

1. Step 1: Understand full-size photo saving

   To save a full-size photo, you must provide a file URI where the camera app saves the image.

2. Step 2: Use Intent extra MediaStore.EXTRA_OUTPUT

   Pass the file URI as an extra in the camera intent using MediaStore.EXTRA_OUTPUT before starting the intent.

3. Step 3: Start camera intent with this setup

   This ensures the camera saves the full photo to your file, not just a thumbnail in data extras.

4. Final Answer:

   Create a file URI, pass it with Intent extra MediaStore.EXTRA_OUTPUT, then start camera intent -> Option C

5. Quick Check:

   File URI + EXTRA_OUTPUT = full photo saved [OK]

Hint: Use EXTRA_OUTPUT with file URI for full-size photos [OK]

Common Mistakes:

• Relying on thumbnail from data extras only
• Not providing file URI to camera intent
• Using video capture intent for photos