What is CameraX?

CameraX is a Jetpack library that makes camera development easier by providing:

• Simple camera preview
• Image capture (photos)
• Image analysis (frames for machine learning)
• Consistent behavior across different devices
• Fewer crashes compared to Camera API / Camera2

CameraX works perfectly with ML Kit for on-device AI tasks.

What is ML Kit?

ML Kit is Google’s on-device machine learning library. It’s fast, doesn’t require internet, and supports:

• Text Recognition (OCR)
• Face Detection
• Barcode Scanning
• Object Detection & Tracking
• Image Labeling
• Pose Detection

In this post, Text Recognition will be used as an example — but the same structure works for any ML Kit model.

Step-by-Step Project Guide

Step 1: Create a New Android Studio Project

• Open Android Studio (Giraffe / Koala+ recommended)
• Click New Project
• Choose Empty Activity (or Compose Activity if you're building with Jetpack Compose)
• Configure project settings:

• • Name: SmartCameraApp
  • Package: com.example.smartcamera
  • Minimum SDK: Android 8.0 (API 26) or higher
  • Build system: Gradle Kotlin DSL recommended

• Click Finish

The project will generate with a default MainActivity.kt.

Step 2: Add Required Dependencies

Open build.gradle (app level) and insert:

CameraX

def camerax_version = "1.3.3"

implementation "androidx.camera:camera-core:$camerax_version"
implementation "androidx.camera:camera-camera2:$camerax_version"
implementation "androidx.camera:camera-lifecycle:$camerax_version"
implementation "androidx.camera:camera-view:$camerax_version"
implementation "androidx.camera:camera-mlkit-vision:$camerax_version"

ML Kit — Text Recognition (example)

implementation("com.google.mlkit:text-recognition:16.0.1")

Step 3: Add Camera Permission

Add the permission to AndroidManifest.xml:

<uses-permission android:name="android.permission.CAMERA" />

Request it at runtime using the Activity Result API.

Step 4: Add a Camera Preview UI

Open activity_main.xml:

<androidx.camera.view.PreviewView
    android:id="@+id/previewView"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_gravity="center" />

PreviewView is the recommended CameraX preview component.

Step 5: Request Camera Permission

In MainActivity.kt:

private val requestPermissionLauncher =
 registerForActivityResult(ActivityResultContracts.RequestPermission()) { isGranted ->
        if (isGranted) startCamera()
        else Toast.makeText(this, "Camera permission required.", Toast.LENGTH_LONG).show()
}

private fun requestCameraPermission() {
    requestPermissionLauncher.launch(Manifest.permission.CAMERA)
}

Call requestCameraPermission() inside onCreate().

Step 6: Start CameraX

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

        // Preview setup
        val preview = Preview.Builder().build().apply {
            setSurfaceProvider(findViewById<PreviewView>(R.id.previewView).surfaceProvider)
        }

        // Image analysis setup
        val analysis = ImageAnalysis.Builder()
            .setTargetResolution(Size(1280, 720))
            .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
            .build()
            .apply {
                setAnalyzer(
                    Executors.newSingleThreadExecutor(),
                    MlKitAnalyzer()
                )
            }

        val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA
        cameraProvider.unbindAll()
        cameraProvider.bindToLifecycle(
            this,
            cameraSelector,
            preview,
            analysis
        )
    }, ContextCompat.getMainExecutor(this))
}

Step 7: Implement the ML Kit Analyzer

Create a new file MlKitAnalyzer.kt

class MlKitAnalyzer : ImageAnalysis.Analyzer {
    private val recognizer = TextRecognition.getClient()
    override fun analyze(imageProxy: ImageProxy) {
        val mediaImage = imageProxy.image ?: return
        val rotation = imageProxy.imageInfo.rotationDegrees
        val inputImage = InputImage.fromMediaImage(mediaImage, rotation)
        recognizer.process(inputImage)
            .addOnSuccessListener { result ->
                Log.d("MLKit", "Detected Text: ${result.text}")
            }
            .addOnFailureListener { e ->
                Log.e("MLKit", "Error: ${e.localizedMessage}")
            }
            .addOnCompleteListener {
                imageProxy.close()
            }
    }
}

Step 8: Optional Overlay Rendering

(Used for bounding boxes, detection highlights, face frames)

Overlay View (optional)

class OverlayView(context: Context, attrs: AttributeSet? = null) : View(context, attrs) {
    var boxes: List<Rect> = emptyList()
        set(value) {
            field = value
            invalidate()
        }

    private val paint = Paint().apply {
        color = Color.GREEN
        style = Paint.Style.STROKE
        strokeWidth = 4f
    }

    override fun onDraw(canvas: Canvas) {
        super.onDraw(canvas)
        boxes.forEach { canvas.drawRect(it, paint) }
    }
}

Add to layout:

<com.example.smartcamera.OverlayView
    android:id="@+id/overlayView"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

Step 9: Performance and Architecture Considerations

• Use a single analyzer thread: Using Executors.newSingleThreadExecutor() prevents backpressure.       
• Set appropriate resolution: 1280×720 provides a balance of speed and detail.
• Reuse ML Kit detector: Avoid creating new ML Kit instances per frame.
• Move ML logic into a ViewModel for large apps: Ensures clean architecture and testability.

Conclusion

By combining CameraX with ML Kit, Android developers can build intelligent, production-ready camera applications with minimal complexity. The stack provides:

• A modern, reliable camera pipeline.
• High-performance on-device ML processing.
• Clean integration with Jetpack architecture components.
• Flexibility for a range of detection and recognition tasks.

This approach is ideal for apps involving OCR, barcode scanning, identity verification, inventory automation, smart forms, and more.

Reference:

https://developer.android.com/media/camera/camerax

https://developers.google.com/ml-kit/guides

Organize Your Project for Scalability

A messy folder structure leads to messy code. Clean code begins with a clean project layout.

Recommended folder structure:

src/
      assets/
      components/
      composables/
      constants/
      services/
      stores/
      utils/
      views/
      router/
      App.vue
      main.js

This separation prevents bloated components and encourages reuse.

Use Consistent Naming Conventions

Naming is one of the most important aspects of clean code. So, we need to follow the naming rules:

Component naming: should use PascalCase

Example: UserProfileCard.vue, LoginForm.vue, SidebarMenu.vue

File naming for composables: should use camelCase

Example: useUser.js, useAuth.js, usePagination.js

Method naming: should describe intention:

Example:
❌ Not good
doPrice()
check()
getData()

✅️ Good
calculateTotalPrice()
validateForm()
fetchUserProfile()

Avoid abbreviations

Example:
❌ Not good
cfg, usr, prd

✅️ Good
config, user, product

Keep Components Small and Focused (Single Responsibility Principle)

A clean Vue component should contain:

✅️ The template
✅️ Local UI logic
✅️ Minor state transitions

It should not contain:
❌ Data fetching logic
❌ Business rules
❌ Repetitive utilities
❌ Large computed logic
❌ Large watchers

When a component grows >300 lines, we should refactor it.

Use Composables to Extract Reusable Logic

Example: Before (bloated component)
<script setup>
import { ref, onMounted } from 'vue'

const users = ref([])
const loading = ref(false)

async function loadUsers() {
loading.value = true
const res = await fetch('/api/users')
users.value = await res.json()
loading.value = false
}

onMounted(() => loadUsers())
</script>

Problems:
❌ Hard to reuse
❌ Hard to test
❌ Component becomes large

After:  using composable to clean code
useUsers.js
import { ref, onMounted } from 'vue'

export function useUsers() {
const users = ref([])
const loading = ref(false)

async function loadUsers() {
loading.value = true
const response = await fetch('/api/users')
users.value = await response.json()
loading.value = false
}

onMounted(loadUsers)

return { users, loading, loadUsers }
}

UserList.vue
<script setup>
import { useUsers } from '@/composables/useUsers'
const { users, loading } = useUsers()
</script>

Benefits:
✅️ Reusable in multiple components
✅️ Testable
✅️ Cleaner component

Keep Templates Clean and Expressive

Templates should read almost like HTML.

❌ Bad Template
<p>{{ price - discount > 0 ? price - discount : 0 }}</p>

✅️ Clean Template (Move logic to computed)
const finalPrice = computed(() => Math.max(price.value - discount.value, 0))

<p>{{ finalPrice }}</p>

Diagram: Template Logic Separation
Template → simple expressions
Script → complex logic
Composable → business logic

Use Centralized State Management Wisely (Pinia Recommended)

State should not float around components in unpredictable ways.
Pinia is the recommended state solution.

✅️ Example Pinia Store
import { defineStore } from 'pinia'

export const useCartStore = defineStore('cart', {
   state: () => ({
   items: []
   }),
   actions: {
   addItem(item) {
   this.items.push(item)
   },
   removeItem(id) {
   this.items = this.items.filter(i => i.id !== id)
   }
 }
})

This keeps components lightweight.

Avoid Magic Strings and Use Constants

Magic strings make code fragile.

❌ Bad
if (status === "SUCCESS_001") {
...
}

✅️ Good
status.js
export const STATUS = {
SUCCESS: 'SUCCESS_001',
FAILED: 'FAILED_999'
}

Usage:
if (status === STATUS.SUCCESS) {...}

Add Proper Documentation and Comments (When Needed)

Do not write comments that explain the obvious.
Document intention, not implementation.

✅️ Good JSDoc:

/**
* Formats an ISO date into DD/MM/YYYY format.
*/
function formatDate(dateStr) { ... }

Add Unit Tests to Reinforce Clean Architecture

Testing ensures your clean code stays clean as the project evolves.
Recommended tools:
Vitest
Vue Test Utils

Conclusion

Clean code in Vue.js is not about perfection—it’s about clarity, intention, and long-term maintainability.
By applying the principles covered in this guide:
- Organizing your project
- Naming consistently
- Keeping components small
- Using composables
- Keeping templates clean
- Centralizing shared state
- Using testing tools
Your Vue.js applications will become more maintainable, scalable, and enjoyable for everyone on the team.

[References]

https://javascript.plainenglish.io/7-vue-js-tricks-that-will-instantly-clean-up-your-code-7400cfa2e961

Image source: https://www.freepik.com/free-photo/turned-gray-laptop-computer_12661377.htm