Tutorial

Bilder in JPG umwandeln unter Android: Ein umfassendes Tutorial

Melden

Hier ist ein ausführliches Tutorial, wie du in einer Android-App (mit Kotlin) Bilder in das JPG-Format umwandelst.

In der Android-Entwicklung ist es oft notwendig, Bilder in ein einheitliches Format wie JPG zu konvertieren, um Speicherplatz zu sparen oder die Kompatibilität mit Servern sicherzustellen. In diesem Tutorial lernst du, wie du ein beliebiges Bild (z. B. PNG oder WEBP) lädst und als JPG speicherst.

Voraussetzungen

  • Grundkenntnisse in Android Studio und Kotlin.
  • Ein Projekt mit dem Mindest-SDK von 21 (Android 5.0).

Schritt 1: Berechtigungen in der AndroidManifest.xml

Ab Android 10 (API 29) verwendet Android "Scoped Storage". Für das Speichern von Bildern in der Galerie benötigen wir für moderne Versionen oft keine expliziten Berechtigungen mehr, wenn wir die MediaStore-API verwenden. Dennoch ist es gut, die Basis-Berechtigungen zu kennen:

<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" android:maxSdkVersion="32" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="28" />

Schritt 2: Die Kern-Funktion zur Konvertierung

Das Herzstück der Konvertierung ist die Klasse Bitmap. Die Methode compress() erlaubt es uns, das Format zu ändern.

Hier ist eine Utility-Funktion, die ein Bitmap nimmt und in einen ByteArrayOutputStream als JPG schreibt:

import android.graphics.Bitmap
import java.io.ByteArrayOutputStream

fun convertBitmapToJpg(bitmap: Bitmap, quality: Int = 90): ByteArray {
    val outputStream = ByteArrayOutputStream()

    // Das Bild wird hier in JPEG umgewandelt
    // quality: 0 (kleinste Größe) bis 100 (beste Qualität)
    bitmap.compress(Bitmap.CompressFormat.JPEG, quality, outputStream)

    return outputStream.toByteArray()
}

Schritt 3: Ein Bild laden und konvertieren

Meistens hast du eine Uri (z. B. von einer Kamera oder aus der Galerie). So konvertierst du diese in ein Bitmap und dann in JPG:

import android.content.Context
import android.graphics.BitmapFactory
import android.net.Uri

fun processImageUri(context: Context, imageUri: Uri) {
    val contentResolver = context.contentResolver

    // 1. Bild aus URI laden
    val inputStream = contentResolver.openInputStream(imageUri)
    val originalBitmap = BitmapFactory.decodeStream(inputStream)

    // 2. Zu JPG konvertieren
    val jpgByteArray = convertBitmapToJpg(originalBitmap, 100)

    // 3. (Optional) Das Bild speichern (siehe Schritt 4)
}

Schritt 4: Das konvertierte JPG speichern (MediaStore API)

Um das Bild auf dem Gerät zu speichern, nutzen wir die moderne MediaStore-API. Dies funktioniert auch unter Android 11, 12 und 13 problemlos.

import android.content.ContentValues
import android.os.Build
import android.provider.MediaStore
import java.io.OutputStream

fun saveJpgToGallery(context: Context, jpgData: ByteArray, fileName: String) {
    val resolver = context.contentResolver
    val contentValues = ContentValues().apply {
        put(MediaStore.MediaColumns.DISPLAY_NAME, "$fileName.jpg")
        put(MediaStore.MediaColumns.MIME_TYPE, "image/jpeg")
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            put(MediaStore.MediaColumns.RELATIVE_PATH, "Pictures/MyApp")
        }
    }

    val uri = resolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, contentValues)

    uri?.let { targetUri ->
        val outputStream: OutputStream? = resolver.openOutputStream(targetUri)
        outputStream?.use {
            it.write(jpgData)
        }
    }
}

Zusammenfassung: Der komplette Workflow

Hier ist ein Beispiel, wie du alles in einer Activity oder einem Fragment aufrufst:

  1. Bild auswählen: Der Nutzer wählt ein Bild per ActivityResultLauncher.
  2. Konvertieren: Das Bild wird in ein Bitmap geladen und mit Bitmap.CompressFormat.JPEG komprimiert.
  3. Speichern: Das Ergebnis wird als neue Datei im Dateisystem abgelegt.

Wichtige Tipps:

  • Qualität: Ein Wert von 80 bis 90 bietet oft das beste Verhältnis zwischen Dateigröße und Bildqualität.
  • Memory Management: Große Bilder können viel RAM verbrauchen. Nutze bei sehr großen Bildern BitmapFactory.Options mit inSampleSize, um das Bild beim Laden zu verkleinern.
  • Hintergrund-Threads: Führe die Konvertierung niemals auf dem Main-Thread (UI-Thread) aus. Nutze CoroutineScope(Dispatchers.IO).launch { ... }.

Bonus: Mit Bibliotheken wie Glide (Einfacher Weg)

Wenn du bereits Bibliotheken wie Glide verwendest, kannst du Bitmaps sehr einfach extrahieren:

Glide.with(context)
    .asBitmap()
    .load(sourceUri)
    .into(object : CustomTarget<Bitmap>() {
        override fun onResourceReady(resource: Bitmap, transition: Transition<in Bitmap>?) {
            val jpgData = convertBitmapToJpg(resource)
            saveJpgToGallery(context, jpgData, "mein_neues_bild")
        }
        override fun onLoadCleared(placeholder: Drawable?) {}
    })

Mit diesem Tutorial hast du nun alle Werkzeuge, um Bilder effizient in deiner Android-App nach JPG zu konvertieren!

0