ImagePickerKMP – Kotlin Multiplatform Camera & Gallery Picker

@Composable
fun MyScreen(innerPadding: PaddingValues) {

    // 1. Create the picker with a global config
    val picker = rememberImagePickerKMP(
        config = ImagePickerKMPConfig(
            enableCrop = false,
            galleryConfig = GalleryConfig(
                allowMultiple = true,
                selectionLimit = 10,
                includeExif = true,
                redactGpsData = true,
                mimeTypes = listOf(MimeType.IMAGE_JPEG)
            )
        )
    )

    // 2. Read the reactive result
    val result = picker.result

    Column(
        modifier = Modifier
            .padding(innerPadding)
            .fillMaxSize()
    ) {
        // 3. React to each picker state
        Box(
            modifier = Modifier.fillMaxWidth().weight(1f),
            contentAlignment = Alignment.Center
        ) {
            when (result) {

                is ImagePickerResult.Loading -> {
                    Column(horizontalAlignment = Alignment.CenterHorizontally) {
                        CircularProgressIndicator()
                        Text("Selecting...", color = Color.Gray)
                    }
                }

                is ImagePickerResult.Success -> {
                    val photos = result.photos
                    if (photos.size == 1) {
                        // Single photo (camera or simple gallery)
                        val painter = photos.first().loadPainter()
                        if (painter != null) {
                            Image(painter = painter, contentDescription = "Captured photo")
                        }
                    } else {
                        // Multiple gallery photos
                        LazyVerticalGrid(columns = GridCells.Fixed(2)) {
                            items(photos) { photo ->
                                val painter = photo.loadPainter()
                                if (painter != null) {
                                    Image(painter = painter, contentDescription = null)
                                }
                            }
                        }
                    }
                }

                is ImagePickerResult.Error ->
                    Text("Error: ${result.exception.message}", color = Color.Red)

                is ImagePickerResult.Dismissed,
                is ImagePickerResult.Idle ->
                    Text("No image selected", color = Color.Gray)
            }
        }

        // 4. Buttons that trigger the picker directly
        Row(modifier = Modifier.fillMaxWidth().padding(16.dp)) {
            Button(
                onClick = { picker.launchCamera() },
                modifier = Modifier.weight(1f)
            ) { Text("Camera") }

            Button(
                onClick = { picker.launchGallery() },
                modifier = Modifier.weight(1f)
            ) { Text("Gallery") }
        }
    }
}

// JPEG only, max 5 photos, with EXIF for this launch
picker.launchGallery(
    allowMultiple = true,
    selectionLimit = 5,
    mimeTypes = listOf(MimeType.IMAGE_JPEG),
    includeExif = true,
    redactGpsData = false // GPS included just for this launch
)

// Camera with HIGH compression, only for this tap
// Crop is controlled via ImagePickerKMPConfig(cropConfig = CropConfig(enabled = true))
picker.launchCamera(
    cameraCaptureConfig = CameraCaptureConfig(
        compressionLevel = CompressionLevel.HIGH,
        includeExif = true
    ),
    onDismiss = { /* specific callback on close */ },
    onError = { e -> println("Error: ${e.message}") }
)

when (val result = picker.result) {
    is ImagePickerResult.Idle ->
        Text("No image selected", color = Color.Gray)

    is ImagePickerResult.Loading ->
        CircularProgressIndicator()

    is ImagePickerResult.Success -> {
        // result.photos: List<PhotoResult>
        // result.first: PhotoResult? (first photo, useful for camera)
        result.photos.forEach { photo ->
            val painter = photo.loadPainter()    // Painter for Compose
            val bytes   = photo.loadBytes()      // ByteArray for file operations
            val bitmap  = photo.loadImageBitmap() // ImageBitmap for graphics
            val base64  = photo.loadBase64()     // Base64 for APIs
        }
    }

    is ImagePickerResult.Dismissed ->
        Text("Cancelled by user")

    is ImagePickerResult.Error ->
        Text("Error: ${result.exception.message}", color = Color.Red)
}

val picker = rememberImagePickerKMP()

Button(onClick = { picker.launchCamera() }) { Text("Camera") }

when (val result = picker.result) {
    is ImagePickerResult.Success -> { val photo = result.photos.first() }
    is ImagePickerResult.Error -> { /* handle error */ }
    is ImagePickerResult.Dismissed -> { /* cancelled */ }
    else -> {}
}

val picker = rememberImagePickerKMP(
    config = ImagePickerKMPConfig(
        cameraCaptureConfig = CameraCaptureConfig(
            compressionLevel = CompressionLevel.MEDIUM,
            includeExif = true,
            redactGpsData = false,
            cropConfig = CropConfig(
                enabled = true,
                circularCrop = true,
                squareCrop = true,
                freeformCrop = false
            )
        )
    )
)

Button(onClick = { picker.launchCamera() }) { Text("Camera") }

when (val result = picker.result) {
    is ImagePickerResult.Success -> { val photo = result.photos.first() }
    is ImagePickerResult.Error -> { /* handle error */ }
    is ImagePickerResult.Dismissed -> { /* cancelled */ }
    else -> {}
}

val picker = rememberImagePickerKMP(
    config = ImagePickerKMPConfig(
        galleryConfig = GalleryConfig(allowMultiple = false)
    )
)

Button(onClick = { picker.launchGallery() }) { Text("Gallery") }

when (val result = picker.result) {
    is ImagePickerResult.Success -> { val photo = result.photos.first() }
    is ImagePickerResult.Error -> { /* handle error */ }
    is ImagePickerResult.Dismissed -> { /* cancelled */ }
    else -> {}
}

val picker = rememberImagePickerKMP(
    config = ImagePickerKMPConfig(
        galleryConfig = GalleryConfig(
            allowMultiple = true,
            selectionLimit = 10,
            mimeTypes = listOf(
                MimeType.IMAGE_JPEG,
                MimeType.IMAGE_PNG,
                MimeType.IMAGE_WEBP
            )
        )
    )
)

Button(onClick = { picker.launchGallery() }) { Text("Gallery") }

when (val result = picker.result) {
    is ImagePickerResult.Success -> { result.photos.forEach { /* use photo */ } }
    is ImagePickerResult.Error -> { /* handle error */ }
    is ImagePickerResult.Dismissed -> { /* cancelled */ }
    else -> {}
}

val picker = rememberImagePickerKMP(
    config = ImagePickerKMPConfig(
        cropConfig = CropConfig(
            enabled = true,
            circularCrop = true,
            squareCrop = true,
            freeformCrop = true
        )
    )
)

// isCropActive = true while the crop UI is shown
if (picker.isCropActive) {
    CircularProgressIndicator()
}

Button(onClick = { picker.launchCamera() }) { Text("Camera + Crop") }
Button(onClick = { picker.launchGallery() }) { Text("Gallery + Crop") }

val picker = rememberImagePickerKMP(
    config = ImagePickerKMPConfig(
        cropConfig = CropConfig(enabled = true)
    )
)
picker.launchCamera()

// Camera with compression
val picker = rememberImagePickerKMP(
    config = ImagePickerKMPConfig(
        cameraCaptureConfig = CameraCaptureConfig(
            compressionLevel = CompressionLevel.HIGH
        )
    )
)
picker.launchCamera()

// Gallery with compression
val galleryPicker = rememberImagePickerKMP(
    config = ImagePickerKMPConfig(
        cameraCaptureConfig = CameraCaptureConfig(
            compressionLevel = CompressionLevel.MEDIUM
        )
    )
)
galleryPicker.launchGallery()

val picker = rememberImagePickerKMP(
    config = ImagePickerKMPConfig(
        cameraCaptureConfig = CameraCaptureConfig(includeExif = true)
    )
)

picker.launchCamera()

when (val result = picker.result) {
    is ImagePickerResult.Success -> {
        result.photos.first().exif?.let { exif ->
            println("GPS: ${exif.latitude}, ${exif.longitude}")
            println("Camera: ${exif.cameraModel}")
            println("Date: ${exif.dateTaken}")
            println("Flash: ${exif.flash}")
            println("ISO: ${exif.iso}")
            println("Shutter: ${exif.shutterSpeed}")
            println("Size: ${exif.imageWidth} x ${exif.imageHeight} px")
        }
    }
    else -> {}
}

// Gallery EXIF
val galleryPicker = rememberImagePickerKMP(
    config = ImagePickerKMPConfig(
        galleryConfig = GalleryConfig(includeExif = true)
    )
)
galleryPicker.launchGallery()

val picker = rememberImagePickerKMP()

when (val result = picker.result) {
    is ImagePickerResult.Success -> {
        val photo = result.photos.first()

        // ── UI & Compose ──────────────────────────────────────────────
        val painter: Painter? = photo.loadPainter()
        val bitmap: ImageBitmap? = photo.loadImageBitmap()

        // ── Data Conversion ──────────────────────────────────────────
        val bytes: ByteArray = photo.loadBytes()
        val base64: String = photo.loadBase64()

        // ── File System & Paths ───────────────────────────────────────
        val absPath: String = photo.absolutePath       // Direct file path string
        val path: Path = photo.asPath()               // kotlinx.io.files.Path
        val fileExists: Boolean = photo.exists()       // Check if file exists on disk

        // ── kotlinx-io Streaming ──────────────────────────────────────
        val source: Source = photo.asSource()          // Buffered Source
        val rawSource: RawSource = photo.asRawSource() // Unbuffered RawSource

        // Stream directly to a RawSink (file upload / copy)
        val destinationSink = SystemFileSystem.sink(Path("destination.jpg"))
        photo.transferToSink(destinationSink)
    }
    else -> {}
}

// Convert to string list
val strings = MimeType.toMimeTypeStrings(
    MimeType.IMAGE_JPEG,
    MimeType.IMAGE_PNG
)
// → ["image/jpeg", "image/png"]

// Parse from string
val mt = MimeType.fromString("image/webp")
// → MimeType.IMAGE_WEBP

// Predefined groups
MimeType.COMMON_IMAGE_TYPES   // JPEG, PNG, GIF, WebP
MimeType.ALL_SUPPORTED_TYPES  // all enum entries

PermissionAndConfirmationConfig(
    customDeniedDialog = { onRetry, onDismiss ->
        Dialog(onDismissRequest = onDismiss) {
            Card(shape = RoundedCornerShape(16.dp)) {
                Column(modifier = Modifier.padding(24.dp), horizontalAlignment = Alignment.CenterHorizontally) {
                    Text("Camera Permission Required", fontWeight = FontWeight.Bold)
                    Spacer(Modifier.height(12.dp))
                    Text("Please grant camera access to take photos.", color = Color.Gray)
                    Spacer(Modifier.height(20.dp))
                    Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                        OutlinedButton(onClick = onDismiss, modifier = Modifier.weight(1f)) { Text("Cancel") }
                        Button(onClick = onRetry, modifier = Modifier.weight(1f)) { Text("Retry") }
                    }
                }
            }
        }
    }
)

PermissionAndConfirmationConfig(
    customSettingsDialog = { onOpenSettings, onDismiss ->
        Dialog(onDismissRequest = onDismiss) {
            Card(shape = RoundedCornerShape(16.dp)) {
                Column(modifier = Modifier.padding(24.dp), horizontalAlignment = Alignment.CenterHorizontally) {
                    Text("Permission Permanently Denied", fontWeight = FontWeight.Bold)
                    Spacer(Modifier.height(12.dp))
                    Text("Open system settings to enable camera access manually.", color = Color.Gray)
                    Spacer(Modifier.height(20.dp))
                    Button(onClick = onOpenSettings, modifier = Modifier.fillMaxWidth()) {
                        Text("Open Settings")
                    }
                }
            }
        }
    }
)

// Create localized PermissionConfig using i18nKonfig strings
val config: PermissionConfig = PermissionConfig.createLocalizedComposable()

// Custom PermissionConfig
val customConfig = PermissionConfig(
    titleDialogConfig = "Camera Permission",
    descriptionDialogConfig = "We need camera access to capture photos.",
    btnDialogConfig = "Open Settings",
    titleDialogDenied = "Permission Denied",
    descriptionDialogDenied = "Camera permission is required.",
    btnDialogDenied = "Grant Permission",
    btnCancel = "Cancel"
)

val picker = rememberImagePickerKMP(
    config = ImagePickerKMPConfig(
        galleryConfig = GalleryConfig(
            allowMultiple = true,
            selectionLimit = 10,         // iOS only — max 10 items
            includeExif = true,
            redactGpsData = false,       // expose GPS (inform user!)
            mimeTypes = listOf(MimeType.IMAGE_JPEG, MimeType.IMAGE_PNG)
        )
    )
)

Button(onClick = { picker.launchGallery() }) { Text("Gallery") }

npm install imagepickerkmp

import { useImagePicker } from 'imagepickerkmp';

function PhotoUploader() {
  const { openCamera, openGallery, result } = useImagePicker({
    onPhotoCaptured: (photo) => {
      console.log('Photo:', photo.fileName, photo.fileSize);
    },
    onError: (err) => console.error(err)
  });

  return (
    <div>
      <button onClick={openCamera}>Open Camera</button>
      <button onClick={openGallery}>Open Gallery</button>
      {result && <img src={result.uri} alt="captured" />}
    </div>
  );
}

implementation("io.github.ismoy:imagepickerkmp-video:TBD" // coming soon — not yet published)

<key>NSCameraUsageDescription</key>
<string>Required to record video.</string>
<key>NSMicrophoneUsageDescription</key>
<string>Required to record audio in videos.</string>
<key>NSPhotoLibraryUsageDescription</key>
<string>Required to select videos from your library.</string>

val picker = rememberVideoPicker(
    config = VideoPickerConfig(
        quality          = VideoQuality.FULL_HD_1080P,
        allowedMimeTypes = listOf(VideoMimeType.MP4),
        audio            = AudioConfig.Default,
        output           = VideoOutputConfig(format = VideoOutputFormat.MP4),
        validation       = VideoValidationConfig(
            maxDuration = 60.seconds,
            maxFileSize = 100.mb
        )
    )
)

Button(onClick = { picker.launchCamera() })  { Text("Record") }
Button(onClick = { picker.launchGallery() }) { Text("Pick Video") }

when (val state = picker.result) {
    is VideoPickerState.Success  -> Text("${state.video.fileName} — ${state.video.durationMs / 1000}s")
    is VideoPickerState.Error    -> Text("Error: ${state.cause}")
    is VideoPickerState.Cancelled -> Text("Cancelled")
    else -> {}
}

implementation("io.github.ismoy:imagepickerkmp-audio:TBD" // coming soon — not yet published)

AudioRecorder(
    config   = AudioRecorderConfig(
        gesture  = RecordGesture.HoldAndSlide,
        showWaveform = true,
        showDuration = true
    ),
    onResult = { audioResult: AudioResult? ->
        if (audioResult != null) {
            println("Saved: ${audioResult.uri}, ${audioResult.durationMs}ms")
        }
    }
)

val picker = rememberAudioPicker(
    config = AudioPickerConfig(
        validation = AudioPickerValidation(
            maxFileSizeBytes = 20 * 1024 * 1024L,
            maxDurationMs    = 300_000L
        )
    ),
    recorderConfig = AudioRecorderConfig(showWaveform = true)
)

Button(onClick = { picker.launchRecorder() }) { Text("Record") }
Button(onClick = { picker.launchGallery() })  { Text("Pick File") }

when (val state = picker.result) {
    is AudioPickerState.Success -> {
        val audio = state.audio
        Text("${audio.fileName} — ${audio.durationMs / 1000}s")
        ImagePickerAudioPlayer(
            state = rememberAudioPlayerState(
                AudioSource.Local(
                    uri        = audio.uri,
                    durationMs = audio.durationMs,
                    title      = audio.fileName
                )
            ),
            layout = AudioPlayerLayout.VoiceMessage()
        )    }
    is AudioPickerState.Error    -> Text("Error: ${state.cause}")
    is AudioPickerState.Cancelled -> Text("Cancelled")
    else -> {}
}

implementation("io.github.ismoy:imagepickerkmp-scanner:TBD" // coming soon — not yet published)

val scanner = rememberScannerPicker(
    config = ScannerPickerConfig(
        camera = ScannerCameraConfig(
            behavior = ScannerBehaviorConfig(
                allowedFormats = listOf(BarcodeFormat.QR_CODE, BarcodeFormat.EAN_13),
                playSound      = true
            )
        )
    )
)

Button(onClick = { scanner.launchScanner() }) { Text("Scan") }

when (val result = scanner.result) {
    is ScannerPickerState.Success      -> Text("${result.result.code} (${result.result.format})")
    is ScannerPickerState.BatchSuccess -> result.results.forEach { Text(it.code) }
    is ScannerPickerState.Cancelled    -> Text("Cancelled")
    is ScannerPickerState.Error        -> Text("Error: ${result.error}")
    else -> {}
}

implementation("io.github.ismoy:imagepickerkmp-audio-player:TBD" // coming soon — not yet published)

@Composable
fun CustomPlayerScreen(audioUri: String, durationMs: Long) {
    val playerState = rememberAudioPlayerState(
        AudioSource.Local(
            uri       = audioUri,
            durationMs = durationMs,
            title     = "Voice Memo"
        )
    )

    val isPlaying = playerState.isPlaying
    val position  = playerState.currentPositionMs
    val duration  = playerState.durationMs
    val progress  = if (duration > 0) position.toFloat() / duration else 0f

    LinearProgressIndicator(progress = { progress }, modifier = Modifier.fillMaxWidth())

    Button(onClick = {
        if (isPlaying) playerState.pause() else playerState.play()
    }) { Text(if (isPlaying) "Pause" else "Play") }

    // Seek from a button
    TextButton(onClick = { playerState.seekTo(0) }) { Text("Restart") }
}

implementation("io.github.ismoy:imagepickerkmp-video-player:TBD" // coming soon — not yet published)

// Simple — just pass a source
ImagePickerVideoPlayer(
    source = VideoSource.Url("https://example.com/video.mp4"),
    config = VideoPlayerConfig(
        behavior = VideoBehaviorConfig(autoPlay = true, enablePinchToZoom = true)
    )
)

// With programmatic control
val player = rememberVideoPlayerState(source = VideoSource.Url(videoUrl))
ImagePickerVideoPlayer(state = player, config = VideoPlayerConfig())

Button(onClick = { player.play() })                { Text("Play") }
Button(onClick = { player.pause() })               { Text("Pause") }
Button(onClick = { player.seekTo(30_000L) })       { Text("Seek 30s") }
Button(onClick = { player.toggleFullscreen() })   { Text("Fullscreen") }
Button(onClick = { player.enterPiP() })            { Text("PiP") }

val config = VideoPlayerConfig(
    behavior = VideoBehaviorConfig(
        autoPlay          = true,
        enablePinchToZoom = true,
        repeatToggleModes = RepeatToggleModes.ONE_AND_ALL
    ),
    uiExtensions = VideoUIExtensions(
        customLayout = { uiState ->
            val isPlaying = uiState.status == VideoPlayerStatus.Playing
            Box(modifier = Modifier.fillMaxSize()) {
                // Custom play/pause button on the right edge
                Box(
                    modifier = Modifier
                        .size(56.dp)
                        .clip(CircleShape)
                        .background(Color.White.copy(alpha = 0.2f))
                        .clickable { if (isPlaying) uiState.pause() else uiState.play() }
                        .align(Alignment.CenterEnd),
                    contentAlignment = Alignment.Center
                ) {
                    Icon(
                        imageVector = if (isPlaying) Icons.Default.Pause else Icons.Default.PlayArrow,
                        tint = Color.White
                    )
                }
                // Position counter
                Text(
                    text = "${uiState.currentPosition / 1000}s",
                    color = Color.White,
                    modifier = Modifier.align(Alignment.BottomCenter)
                )
            }
        }
    )
)
ImagePickerVideoPlayer(source = VideoSource.Url("https://example.com/video.mp4"), config = config)