DEV Community: Nyerhovwo Adjekughene (Nero)

📸 JetImagePicker: Effortless Image Picking in Jetpack Compose (With Zero Permission Worries)

Nyerhovwo Adjekughene (Nero) — Tue, 15 Jul 2025 08:20:31 +0000

Let's face it - handling image capture and gallery selection in Android is painful. Between READ_MEDIA_IMAGES, scoped storage, runtime permissions, compression, and Compose UI updates… it's easy to mess up. That's why I built JetImagePicker - a plug-and-play image picker for Android from API 21 to 34+ that just works.

What Is JetImagePicker?
JetImagePicker is a modern Kotlin library that:

Handles camera/gallery permissions automatically
Supports multiple image selection
Handles Android 13+ scoped media permissions
Provides compression, resizing, and easy-to-use UI previews
Works with both Jetpack Compose and classic XML

Why I Built It
While working on photo uploads at Raenest, we found ourselves:

Copy-pasting permission logic into every feature
Handling edge cases manually for Android 10–14
Writing boilerplate code for image compression, state handling, and previews

I thought: There has to be a cleaner way - so I created JetImagePickerLibrary.

Full Example in Jetpack Compose

@Composable
fun ImagePickerScreen(modifier: Modifier = Modifier) {
    val context = LocalContext.current
    var message by remember { mutableStateOf<String?>(null) }
    val pickerState = rememberJetImagePickerState(
        context = context,
        config = JetImagePickerConfig(
            enableCompression = true,
            compressionQuality = 70,
            allowMultiple = false,
            targetWidth = 1024,
            targetHeight = 1024
        )
    ) { result ->
        when (result) {
            is ImagePickerResult.Success -> {
                message = null
                Log.d("ImagePicker", "Images selected: ${result.uris}")
            }
            is ImagePickerResult.PermissionDenied -> {
                message = "Permission denied: ${result.permission}"
            }
            is ImagePickerResult.PermissionPermanentlyDenied -> {
                message = "Permission permanently denied: ${result.permission}. Enable in settings."
            }
            is ImagePickerResult.ShowRationale -> {
                message = "Please grant ${result.permission} permission to continue."
            }
        }
    }
    Column(modifier = modifier.padding(16.dp)) {
        Button(
            onClick = pickerState.pickFromGallery,
            modifier = Modifier.fillMaxWidth()
        ) {
            Text("Pick from Gallery")
        }
        Spacer(modifier = Modifier.height(8.dp))
        Button(
            onClick = pickerState.captureWithCamera,
            modifier = Modifier.fillMaxWidth()
        ) {
            Text("Capture with Camera")
        }
        Spacer(modifier = Modifier.height(16.dp))
        when (pickerState.selectedImageUris.size) {
            1 -> ImagePreview(uri = pickerState.selectedImageUris.first())
            in 2..Int.MAX_VALUE -> MultiImagePreview(imageUris = pickerState.selectedImageUris)
        }
        message?.let {
            Spacer(modifier = Modifier.height(12.dp))
            Text(
                text = it,
                color = MaterialTheme.colorScheme.error,
                style = MaterialTheme.typography.bodySmall
            )
        }
    }
}

Features Recap
Feature JetImagePicker Library

📱 API Level Support 21 to 34+
🔐 Runtime Permissions - Auto-handled
🖼 Multiple Image Support - Yes
🧯 Compression & Resizing - Configurable
🧩 Jetpack Compose Ready - Native
🎯 Zero Boilerplate - Yes

⚙️ How It Works
rememberJetImagePickerState manages all state, permissions, and result callbacks
JetImagePickerConfig lets you control compression, multi-selection, and image dimensions
Preview components (ImagePreview, MultiImagePreview) are provided out of the box

🔌 Installation
// settings.gradle

dependencyResolutionManagement {
    repositories {
        maven { url 'https://jitpack.io' }
    }
}

// app/build.gradle

dependencies {
    implementation 'com.github.nerojust:JetImagePicker:v1'
}

//In android manifest

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

Check out the library on Github Here

Final Thoughts
If you're building modern Android apps with Jetpack Compose or XML, JetImagePickerLibrary will save you dozens of hours. No more worrying about runtime permissions or fragile file URI logic.
One function. All versions. All scenarios handled.

Want to Contribute?
Got improvements, Compose UI integrations, or better compression ideas?

📦 Fork it on GitHub: here

🤝 Let's Connect
💼 LinkedIn
🐙 GitHub

I share posts weekly on:
📱 Android Dev • 🧠 Clean Architecture • ⚙️ Jetpack • 🔐 Security • 🌍 Fintech Engineering

🏷 Tags

AndroidDev #Kotlin #JetpackCompose #Permissions #MobileDevelopment #CleanArchitecture #OpenSource #DevTools

Kotlin lazy vs lateinit: When and Why You Should Use Them

Nyerhovwo Adjekughene (Nero) — Mon, 14 Jul 2025 11:37:58 +0000

Knowing when to use lazy or lateinit is one of those "aha" moments that separates clean, reliable Kotlin code from spaghetti code - especially in Android development. In this post, I'll break down these powerful property delegates, share my Android use cases, and help you decide which one is right - and when.

🧐 So, what are they?
Both lazy and lateinit are tools that allow delayed initialization of properties - but they solve different problems.
Think of it like this:
🛋️ lazy is like setting up a beanbag you'll only sit on when you feel like it
🔧 lateinit is like screwing on a table leg after you've assembled the frame

Kotlin lazy – For Read-Only, One-Time Initialization
lazy lets you define a read-only property (val) whose value is computed only once - the first time it's accessed.

Real Example: Lazy-loading a Retrofit service

val apiService by lazy {
    Retrofit.Builder()
        .baseUrl(BASE_URL)
        .build()
        .create(ApiService::class.java)
}

Why this works great:
We only initialize the Retrofit service when needed
Saves memory during early startup
Keeps it thread-safe by default (SYNCHRONIZED mode)

🧪 Another Example: Config loading

val config by lazy(LazyThreadSafetyMode.NONE) {
    loadRemoteConfig()
}

This disables synchronization for better performance if you guarantee no race conditions (like using it in onCreate() only).

Kotlin lateinit – For Mutable Properties Set Later
lateinit is your tool when you want to declare a non-null var that will be initialized after the object is constructed.

✅ Common in Android:

private lateinit var binding: ActivityMainBinding
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    binding = ActivityMainBinding.inflate(layoutInflater)
    setContentView(binding.root)
}

Here, you can't initialize binding at the point of declaration, because layoutInflater isn't ready yet.

⚔️ *lazy vs lateinit *– When to Use Each
Ask Yourself Use Is it a val, and only needs 1 init? lazy Is it a var, assigned after init? lateinit Is it null-safe and side-effect-free? lazy Do you need dependency injection later? lateinit

🧨 Common Mistakes to Avoid
❌ Accessing lateinit before it's initialized

if (::someVar.isInitialized) {
    println(someVar)
}

Always check with ::yourVar.isInitialized to avoid UninitializedPropertyAccessException.

Real-world Android Dev Examples
💡 Lazy ViewModel Factory

val viewModelFactory by lazy {
    MyCustomViewModelFactory(requireContext())
}

Useful when building custom ViewModels in Fragments or Composables.

lateinit + Dependency Injection (e.g. Dagger/Hilt)

@Inject
lateinit var userRepo: UserRepository

You can't use constructor injection in some Android components (like Fragments), so lateinit is perfect here.

Why This Matters in Real Apps
In one of my projects, using lazy helped me avoid triggering an expensive image loading setup until the user actually opened the gallery screen - reducing cold startup time.
In another case, lateinit saved me from null checks all over a test suite where I needed to inject mocked APIs.
The more your Android app grows, the more these tools help keep code clean, readable, and maintainable.

🧑‍🏫 Final Advice
🧘 Use lazy when you're dealing with one-time expensive operations
🔧 Use lateinit when you can't initialize immediately but want to avoid nullable types
🤝 Document or comment fields clearly - they might crash if accessed too early!

🤝** Let's Connect**
If you found this article useful or want to ask me about anything from Kotlin to Clean Architecture:

LinkedIn: Here
GitHub: Here (www.github.com/nerojust)

AndroidDev #Kotlin #Coroutines #MobileDevelopment #ModernAndroid #DevJourney #CleanArchitecture #MVVM