Camera access in Flutter - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What happens when this Flutter camera preview widget is displayed?

Consider this Flutter widget that shows a camera preview. What will the user see when this widget is rendered?

Flutter

import 'package:camera/camera.dart';
import 'package:flutter/material.dart';

class CameraPreviewWidget extends StatefulWidget {
  final CameraController controller;
  const CameraPreviewWidget({required this.controller, super.key});

  @override
  State<CameraPreviewWidget> createState() => _CameraPreviewWidgetState();
}

class _CameraPreviewWidgetState extends State<CameraPreviewWidget> {
  @override
  Widget build(BuildContext context) {
    if (!widget.controller.value.isInitialized) {
      return const Center(child: CircularProgressIndicator());
    }
    return CameraPreview(widget.controller);
  }
}

A The widget crashes because CameraPreview requires a different controller type.

B The widget shows a static image from the camera roll instead of live feed.

C A loading spinner is shown until the camera is ready, then the live camera feed appears filling the widget area.

D Nothing is shown because the controller is never initialized.

💡 Hint

Think about what happens before the camera is ready and after initialization.

The widget first checks if the camera controller is initialized. If not, it shows a spinner. Once ready, it displays the live camera feed using CameraPreview.

❓ lifecycle

intermediate

What is the correct way to manage the CameraController lifecycle in Flutter?

You create a CameraController in initState. Which method should you override to properly release the camera resources?

A No need to release resources; Flutter handles it automatically.

B Override deactivate() and call controller.dispose() inside it.

C Override didChangeDependencies() and call controller.dispose() inside it.

D Override dispose() and call controller.dispose() inside it.

💡 Hint

Think about cleaning up resources when the widget is removed permanently.

dispose() is called when the widget is permanently removed. You should dispose the CameraController there to free camera resources.

📝 Syntax

advanced

What error does this Flutter camera initialization code produce?

Analyze this snippet initializing a CameraController. What error will it cause?

Flutter

late CameraController controller;

void initCamera() async {
  final cameras = await availableCameras();
  controller = CameraController(cameras.first, ResolutionPreset.high);
  await controller.initialize();
}

@override
void initState() {
  super.initState();
  initCamera();
}

A No error; the camera initializes correctly.

B Runtime error because initCamera is async but not awaited in initState.

C LateInitializationError because controller is used before initialization.

D Syntax error due to missing async keyword in initState.

💡 Hint

Consider what happens when you call an async function without awaiting it in initState.

initCamera is async but called without await in initState, so controller may be used before initialization completes, causing runtime errors.

❓ navigation

advanced

What happens if you navigate away from a screen with an active CameraController without disposing it?

If you push a new screen on top of a camera preview screen but forget to dispose the CameraController, what is the likely outcome?

A The camera continues running in background, causing battery drain and possible app crash.

B The camera automatically stops and releases resources when screen is hidden.

C The app throws a compile-time error preventing navigation.

D Nothing happens; camera resources are managed by the OS.

💡 Hint

Think about resource management and what happens if you don't clean up.

If you don't dispose the CameraController, the camera stays active, wasting battery and possibly causing conflicts or crashes.

🧠 Conceptual

expert

Which Flutter permission handling approach ensures camera access works on both Android and iOS?

You want to request camera permission before initializing the camera. Which approach is best to handle permissions cross-platform?

A Use the permission_handler package to request permission at runtime before camera initialization.

B Only declare camera permission in AndroidManifest.xml and Info.plist; no runtime request needed.

C Initialize the camera directly; the system will prompt for permission automatically.

D Use platform channels to write native code for permission requests on each platform.

💡 Hint

Think about runtime permission requests on modern mobile OSes.

Modern Android and iOS require runtime permission requests. The permission_handler package simplifies this cross-platform.