react-native-my-uploader-android 1.0.54 → 1.0.56

package/android/src/main/java/com/myuploaderandroid/MyUploaderModule.kt

@@ -1,4 +1,4 @@
-package com.myuploaderandroid
+package  com.myuploaderandroid
 
 import androidx.exifinterface.media.ExifInterface
 import java.io.File
@@ -44,6 +44,37 @@ class MyUploaderModule(private val reactContext: ReactApplicationContext) :
         private const val E_INVALID_OPTIONS = "E_INVALID_OPTIONS"
     }
 
+    private fun getWorkFile(rawUri: String): File {
+    val uri = Uri.parse(rawUri)
+    val scheme = uri.scheme?.lowercase() ?: ""
+    val tempFile = File.createTempFile("work_process_", ".tmp", reactContext.cacheDir)
+
+    try {
+        if (scheme == "http" || scheme == "https") {
+            // Uzak URL'den indir
+            val url = java.net.URL(rawUri)
+            val connection = url.openConnection() as java.net.HttpURLConnection
+            connection.connectTimeout = 15000
+            connection.readTimeout = 20000
+            connection.inputStream.use { input ->
+                tempFile.outputStream().use { output -> input.copyTo(output) }
+            }
+            connection.disconnect()
+        } else {
+            // Yerel URI'den (content:// veya file://) kopyala
+            reactContext.contentResolver.openInputStream(uri).use { input ->
+                if (input == null) throw Exception("Dosya açılamadı: $rawUri")
+                tempFile.outputStream().use { output -> input.copyTo(output) }
+            }
+        }
+    } catch (e: Exception) {
+        tempFile.delete()
+        throw e
+    }
+    return tempFile
+    }
+
+
     @ReactMethod
     fun openDocument(options: ReadableMap, promise: Promise) {
         if (pickerPromise != null) {
@@ -212,90 +243,51 @@ class MyUploaderModule(private val reactContext: ReactApplicationContext) :
     }
     
     @ReactMethod
-    fun RotateImageWithUri(fileUri: String, angle: Double, promise: Promise) {
-        Thread {
-            try {
-                val sourceUri = Uri.parse(fileUri)
-                val contentResolver = reactContext.contentResolver
-
-                // 1. ADIM: OOM Riskini Azaltmak için Bitmap'i verimli bir şekilde oku
-                // (Bu kısım, cropImageWithUri'deki ile aynı mantığı kullanır)
-                val boundsOptions = BitmapFactory.Options().apply { inJustDecodeBounds = true }
-                contentResolver.openInputStream(sourceUri)?.use {
-                    BitmapFactory.decodeStream(it, null, boundsOptions)
-                }
-                
-                val decodeOptions = BitmapFactory.Options()
-                var inSampleSize = 1
-                val maxDimension = 2048 // Uygulamanızın ihtiyacına göre ayarlayın
-                if (boundsOptions.outHeight > maxDimension || boundsOptions.outWidth > maxDimension) {
-                    val halfHeight = boundsOptions.outHeight / 2
-                    val halfWidth = boundsOptions.outWidth / 2
-                    while ((halfHeight / inSampleSize) >= maxDimension && (halfWidth / inSampleSize) >= maxDimension) {
-                        inSampleSize *= 2
-                    }
-                }
-                decodeOptions.inSampleSize = inSampleSize
-
-                // Resmi optimize edilmiş boyutta belleğe yükle
-                val originalBitmap = contentResolver.openInputStream(sourceUri)?.use {
-                    BitmapFactory.decodeStream(it, null, decodeOptions)
-                } ?: throw Exception("Bitmap oluşturulamadı (decodeStream).")
-
-
-                // 2. ADIM: Döndürme Matrisini Oluştur
-                // NOT: Bu fonksiyonda, JS'den gelen 'angle' değerini doğrudan kullanıyoruz.
-                // EXIF döndürmesi zaten orijinal resimde mevcuttur ve burada tekrar uygulanmamalıdır,
-                // çünkü amacımız kullanıcının isteği doğrultusunda ek bir döndürme yapmaktır.
-                val matrix = Matrix().apply {
-                    postRotate(angle.toFloat())
-                }
-
-                // Döndürme işlemini uygula
-                val rotatedBitmap = Bitmap.createBitmap(
-                    originalBitmap, 0, 0, originalBitmap.width, originalBitmap.height, matrix, true
-                )
-
-
-                // 3. ADIM: Döndürülmüş Bitmap'i geçici bir dosyaya kaydet
-                // (Bu kısım, cropImageWithUri'deki ile tamamen aynı)
-                val mimeType = contentResolver.getType(sourceUri) ?: "image/jpeg"
-                val fileExtension = when {
-                    mimeType.contains("png") -> "png"
-                    mimeType.contains("webp") -> "webp"
-                    else -> "jpg"
-                }
-                
-                val cacheDir = reactContext.cacheDir
-                val outputFile = createTempFile("rotated_", ".$fileExtension", cacheDir)
-                val fileOutputStream = outputFile.outputStream()
+fun RotateImageWithUri(fileUri: String, angle: Double, promise: Promise) {
+    Thread {
+        var workFile: File? = null
+        try {
+            // 1. Dosyayı yerel bir kopyaya al (İster URL olsun ister Local)
+            workFile = getWorkFile(fileUri)
 
-                val compressFormat = when (fileExtension) {
-                    "png" -> Bitmap.CompressFormat.PNG
-                    "webp" -> if (android.os.Build.VERSION.SDK_INT >= 30) Bitmap.CompressFormat.WEBP_LOSSLESS else Bitmap.CompressFormat.WEBP
-                    else -> Bitmap.CompressFormat.JPEG
-                }
+            // 2. Boyutları oku
+            val options = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+            workFile.inputStream().use { BitmapFactory.decodeStream(it, null, options) }
+            
+            // 3. OOM önlemi
+            val decodeOptions = BitmapFactory.Options().apply {
+                inSampleSize = calculateInSampleSize(options, 2048, 2048)
+            }
 
-                fileOutputStream.use { stream ->
-                    rotatedBitmap.compress(compressFormat, 95, stream)
-                }
+            // 4. Bitmap'i yükle
+            val originalBitmap = workFile.inputStream().use {
+                BitmapFactory.decodeStream(it, null, decodeOptions)
+            } ?: throw Exception("Bitmap decode edilemedi.")
 
+            // 5. Döndür
+            val matrix = Matrix().apply { postRotate(angle.toFloat()) }
+            val rotatedBitmap = Bitmap.createBitmap(originalBitmap, 0, 0, originalBitmap.width, originalBitmap.height, matrix, true)
 
-                // 4. ADIM: Belleği temizle
-                originalBitmap.recycle()
-                rotatedBitmap.recycle()
+            // 6. Kaydet
+            val outputFile = File.createTempFile("rotated_", ".jpg", reactContext.cacheDir)
+            outputFile.outputStream().use { 
+                rotatedBitmap.compress(Bitmap.CompressFormat.JPEG, 95, it) 
+            }
 
+            // Bellek temizliği
+            originalBitmap.recycle()
+            rotatedBitmap.recycle()
 
-                // 5. ADIM: Yeni oluşturulan dosyanın URI'sini döndür
-                promise.resolve(Uri.fromFile(outputFile).toString())
+            promise.resolve(Uri.fromFile(outputFile).toString())
 
-            } catch (e: OutOfMemoryError) {
-                promise.reject("E_OOM_ROTATE", "Resim döndürülürken hafıza yetersiz kaldı.")
-            } catch (e: Exception) {
-                promise.reject("E_ROTATE_URI", "Döndürme hatası: ${e.message}")
-            }
-        }.start()
-    }
+        } catch (e: Exception) {
+            promise.reject("E_ROTATE_URI", e.message)
+        } finally {
+            // KRİTİK: İndirilen/kopyalanan geçici dosyayı SİL
+            workFile?.delete()
+        }
+    }.start()
+}
 
 
     @ReactMethod
@@ -393,139 +385,80 @@ class MyUploaderModule(private val reactContext: ReactApplicationContext) :
     }
 
     @ReactMethod
-    fun CropImageWithUri(fileUri: String, crop: ReadableMap, promise: Promise) {
-        Thread {
-            var originalBitmap: Bitmap? = null
-            var rotatedBitmap: Bitmap? = null
-            var croppedBitmap: Bitmap? = null
-
-            try {
-                val sourceUri = Uri.parse(fileUri)
-                val contentResolver = reactContext.contentResolver
-
-                // --- 1. İYİLEŞTİRME: EXIF Döndürme Bilgisini Oku ---
-                var orientation = 0
-                try {
-                    // InputStream'i EXIF okumak için bir kere açıyoruz
-                    contentResolver.openInputStream(sourceUri)?.use { inputStream ->
-                        val exif = ExifInterface(inputStream)
-                        orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL)
-                    }
-                } catch (e: Exception) {
-                    // EXIF okunamıyorsa (örn: PNG), görmezden gel.
-                    println("EXIF bilgisi okunamadı: ${e.message}")
-                }
-                
-                // --- 2. İYİLEŞTİRME: OOM Riskini Azaltmak için BitmapFactory.Options ---
-                // Önce, sadece resmin boyutlarını almak için `inJustDecodeBounds` kullanıyoruz.
-                // Bu, resmi belleğe yüklemeden boyutlarını okumamızı sağlar.
-                val boundsOptions = BitmapFactory.Options()
-                boundsOptions.inJustDecodeBounds = true
-                contentResolver.openInputStream(sourceUri)?.use { inputStream ->
-                    BitmapFactory.decodeStream(inputStream, null, boundsOptions)
-                }
+fun CropImageWithUri(fileUri: String, crop: ReadableMap, promise: Promise) {
+    Thread {
+        var workFile: File? = null
+        try {
+            // 1. Dosyayı yerele al
+            workFile = getWorkFile(fileUri)
 
-                val originalWidth = boundsOptions.outWidth
-                val originalHeight = boundsOptions.outHeight
-                
-                // Bellek optimizasyonu için bir `inSampleSize` hesaplayalım.
-                // Örneğin, resim 2048 pikselden büyükse, onu küçülterek oku.
-                val decodeOptions = BitmapFactory.Options()
-                var inSampleSize = 1
-                val maxDimension = 2048 // Uygulamanızın ihtiyacına göre bu değeri ayarlayın
-                if (originalHeight > maxDimension || originalWidth > maxDimension) {
-                    val halfHeight: Int = originalHeight / 2
-                    val halfWidth: Int = originalWidth / 2
-                    while (halfHeight / inSampleSize >= maxDimension && halfWidth / inSampleSize >= maxDimension) {
-                        inSampleSize *= 2
-                    }
-                }
-                decodeOptions.inSampleSize = inSampleSize
-
-                // Şimdi resmi, hesaplanan `inSampleSize` ile belleğe yüklüyoruz.
-                val originalBitmap = contentResolver.openInputStream(sourceUri)?.use { inputStream ->
-                    BitmapFactory.decodeStream(inputStream, null, decodeOptions)
-                } ?: throw Exception("Bitmap oluşturulamadı (decodeStream).")
-
-
-                // --- 3. İYİLEŞTİRME: Döndürme Matrisini Oluştur ---
-                val matrix = Matrix()
-                // EXIF bilgisine göre döndürme matrisini ayarla
-                when (orientation) {
-                    ExifInterface.ORIENTATION_ROTATE_90 -> matrix.postRotate(90f)
-                    ExifInterface.ORIENTATION_ROTATE_180 -> matrix.postRotate(180f)
-                    ExifInterface.ORIENTATION_ROTATE_270 -> matrix.postRotate(270f)
-                    ExifInterface.ORIENTATION_FLIP_HORIZONTAL -> matrix.preScale(-1.0f, 1.0f)
-                    ExifInterface.ORIENTATION_FLIP_VERTICAL -> matrix.preScale(1.0f, -1.0f)
-                    // Diğer karmaşık oryantasyonlar da eklenebilir...
-                }
-                
-                // Döndürme işlemini uygula
-                val rotatedBitmap = 
-                if (!matrix.isIdentity) {
-                    Bitmap.createBitmap(
-                        originalBitmap,0, 0, originalBitmap.width, originalBitmap.height, matrix, true
-                    ).also {
-                        originalBitmap.recycle()
-                    }
-                } else {
-                originalBitmap
-                }
+            // 2. EXIF bilgisini yerel dosyadan oku (URL'de bu çalışmazdı, şimdi çalışır)
+            val orientation = try {
+                ExifInterface(workFile.absolutePath).getAttributeInt(
+                    ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL
+                )
+            } catch (_: Exception) { ExifInterface.ORIENTATION_NORMAL }
 
+            // 3. Boyut ölçümü
+            val boundsOptions = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+            workFile.inputStream().use { BitmapFactory.decodeStream(it, null, boundsOptions) }
 
-                // 4. ADIM: Kırpma koordinatlarını hesapla (Artık DÖNDÜRÜLMÜŞ bitmap üzerinden)
-                val rx = crop.getDouble("x")
-                val ry = crop.getDouble("y")
-                val rw = crop.getDouble("width")
-                val rh = crop.getDouble("height")
-                
-                // NOT: Artık rotatedBitmap'in boyutlarını kullanıyoruz!
-                val px = (rx * rotatedBitmap.width).toInt().coerceIn(0, rotatedBitmap.width - 1)
-                val py = (ry * rotatedBitmap.height).toInt().coerceIn(0, rotatedBitmap.height - 1)
-                val pw = (rw * rotatedBitmap.width).toInt().coerceAtMost(rotatedBitmap.width - px).coerceAtLeast(1)
-                val ph = (rh * rotatedBitmap.height).toInt().coerceAtMost(rotatedBitmap.height - py).coerceAtLeast(1)
+            val decodeOptions = BitmapFactory.Options().apply {
+                inSampleSize = calculateInSampleSize(boundsOptions, 2048, 2048)
+            }
 
+            // 4. Bitmap yükle
+            val originalBitmap = workFile.inputStream().use {
+                BitmapFactory.decodeStream(it, null, decodeOptions)
+            } ?: throw Exception("Bitmap yüklenemedi.")
+
+            // 5. EXIF Rotasyonu uygula
+            val matrix = Matrix()
+            when (orientation) {
+                ExifInterface.ORIENTATION_ROTATE_90 -> matrix.postRotate(90f)
+                ExifInterface.ORIENTATION_ROTATE_180 -> matrix.postRotate(180f)
+                ExifInterface.ORIENTATION_ROTATE_270 -> matrix.postRotate(270f)
+            }
 
-                // 5. ADIM: Bitmap'i kırp
-                val croppedBitmap = Bitmap.createBitmap(rotatedBitmap, px, py, pw, ph)
+            val rotatedBitmap = if (!matrix.isIdentity) {
+                Bitmap.createBitmap(originalBitmap, 0, 0, originalBitmap.width, originalBitmap.height, matrix, true)
+                    .also { originalBitmap.recycle() }
+            } else originalBitmap
 
+            // 6. Kırpma koordinatları
+            val rx = crop.getDouble("x")
+            val ry = crop.getDouble("y")
+            val rw = crop.getDouble("width")
+            val rh = crop.getDouble("height")
 
-                // 6. ADIM: Kırpılmış Bitmap'i geçici bir dosyaya kaydet
-                // ... (Bu kısım önceki kodla aynı, değişmedi) ...
-                val mimeType = contentResolver.getType(sourceUri) ?: "image/jpeg"
-                val fileExtension = when {
-                    mimeType.contains("png") -> "png"
-                    mimeType.contains("webp") -> "webp"
-                    else -> "jpg"
-                }
-                val cacheDir = reactContext.cacheDir
-                val outputFile = createTempFile("cropped_", ".$fileExtension", cacheDir)
-                val fileOutputStream = outputFile.outputStream()
-                val compressFormat = when (fileExtension) {
-                    "png" -> Bitmap.CompressFormat.PNG
-                    "webp" -> if (android.os.Build.VERSION.SDK_INT >= 30) Bitmap.CompressFormat.WEBP_LOSSLESS else Bitmap.CompressFormat.WEBP
-                    else -> Bitmap.CompressFormat.JPEG
-                }
-                fileOutputStream.use { stream ->
-                    croppedBitmap.compress(compressFormat, 95, stream)
-                }
+            val px = (rx * rotatedBitmap.width).toInt().coerceIn(0, rotatedBitmap.width - 1)
+            val py = (ry * rotatedBitmap.height).toInt().coerceIn(0, rotatedBitmap.height - 1)
+            val pw = (rw * rotatedBitmap.width).toInt().coerceAtMost(rotatedBitmap.width - px).coerceAtLeast(1)
+            val ph = (rh * rotatedBitmap.height).toInt().coerceAtMost(rotatedBitmap.height - py).coerceAtLeast(1)
 
+            val croppedBitmap = Bitmap.createBitmap(rotatedBitmap, px, py, pw, ph)
 
-               if (originalBitmap != rotatedBitmap) originalBitmap?.recycle()
-                rotatedBitmap?.recycle()
-                croppedBitmap?.recycle()
+            // 7. Çıktıyı kaydet
+            val outputFile = File.createTempFile("cropped_", ".jpg", reactContext.cacheDir)
+            outputFile.outputStream().use { 
+                croppedBitmap.compress(Bitmap.CompressFormat.JPEG, 95, it) 
+            }
 
+            // Temizlik
+            if (originalBitmap != rotatedBitmap) originalBitmap.recycle()
+            rotatedBitmap.recycle()
+            croppedBitmap.recycle()
 
-                // 8. ADIM: Yeni oluşturulan dosyanın URI'sini döndür
-                promise.resolve(Uri.fromFile(outputFile).toString())
+            promise.resolve(Uri.fromFile(outputFile).toString())
 
-            } catch (e: OutOfMemoryError) {
-                promise.reject("E_OOM_CROP", "Resim işlenirken hafıza yetersiz kaldı.")
-            } catch (e: Exception) {
-                promise.reject("E_CROP_URI", "Kırpma hatası: ${e.message}")
-            }
-        }.start()
-    }
+        } catch (e: Exception) {
+            promise.reject("E_CROP_URI", e.message)
+        } finally {
+            // KRİTİK: Geçici dosyayı SİL
+            workFile?.delete()
+        }
+    }.start()
+}
 
     @ReactMethod
     fun DeleteTempFiles(fileUris: ReadableArray, promise: Promise) {
@@ -635,85 +568,182 @@ class MyUploaderModule(private val reactContext: ReactApplicationContext) :
 
     override fun onNewIntent(intent: Intent) {}
 
-    private fun copyFileToInternalStorage(uri: Uri, originalFileName: String): String? {
-        return try {
-            val inputStream = reactContext.contentResolver.openInputStream(uri) ?: return null
-            
-            // Dosya isminin çakışmaması için timestamp ekliyoruz
-            val uniqueFileName = "picked_${System.currentTimeMillis()}_$originalFileName"
-            val tempFile = File(reactContext.cacheDir, uniqueFileName)
-            
-            val outputStream = FileOutputStream(tempFile)
-            
-            // Stream kopyalama işlemi (Hafıza dostu)
-            inputStream.use { input ->
-                outputStream.use { output ->
-                    input.copyTo(output)
-                }
-            }
-            
-            // file:///... formatında URI döndürür
-            Uri.fromFile(tempFile).toString()
+
+    private fun calculateInSampleSize(options: BitmapFactory.Options, reqWidth: Int, reqHeight: Int): Int {
+    val (height: Int, width: Int) = options.outHeight to options.outWidth
+    var inSampleSize = 1
+    if (height > reqHeight || width > reqWidth) {
+        val halfHeight = height / 2
+        val halfWidth = width / 2
+        while (halfHeight / inSampleSize >= reqHeight && halfWidth / inSampleSize >= reqWidth) {
+            inSampleSize *= 2
+        }
+    }
+    return inSampleSize
+}
+private fun rotateBitmapIfRequired(uri: Uri, bitmap: Bitmap): Bitmap {
+    val inputStream = reactContext.contentResolver.openInputStream(uri)
+    
+    // 🟢 ExifInterface kullanımı (AndroidX sürümü ile)
+    val exif = inputStream?.use { input ->
+        try {
+            ExifInterface(input)
         } catch (e: Exception) {
-            Log.e("MyUploader", "Kalıcı kopyalama hatası: ${e.message}")
             null
         }
+    } ?: return bitmap
+
+    val orientation = exif.getAttributeInt(
+        ExifInterface.TAG_ORIENTATION,
+        ExifInterface.ORIENTATION_NORMAL
+    )
+
+    val matrix = Matrix()
+    when (orientation) {
+        ExifInterface.ORIENTATION_ROTATE_90 -> matrix.postRotate(90f)
+        ExifInterface.ORIENTATION_ROTATE_180 -> matrix.postRotate(180f)
+        ExifInterface.ORIENTATION_ROTATE_270 -> matrix.postRotate(270f)
+        else -> return bitmap
     }
 
+    return try {
+        val rotated = Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, matrix, true)
+        if (rotated != bitmap) {
+            bitmap.recycle() // Eski bitmap'i bellekten boşalt
+        }
+        rotated
+    } catch (e: Exception) {
+        bitmap
+    }
+}
 
-    private fun processSelectedFiles(uris: List<Uri>): WritableArray {
-        val fileObjects = WritableNativeArray()
-        val maxSizeBytes = (maxSize * 1024 * 1024).toLong()
+// // SENIOR_UPDATE: PNG transparan alanları beyaz yapma (Siyah arka planı önler)
+private fun fillWhiteBackground(bitmap: Bitmap): Bitmap {
+    val newBitmap = Bitmap.createBitmap(bitmap.width, bitmap.height, Bitmap.Config.RGB_565)
+    val canvas = android.graphics.Canvas(newBitmap)
+    canvas.drawColor(android.graphics.Color.WHITE)
+    canvas.drawBitmap(bitmap, 0f, 0f, null)
+    bitmap.recycle()
+    return newBitmap
+}
 
-        for (uri in uris) {
-            reactContext.contentResolver.query(uri, null, null, null, null)?.use { cursor ->
-                if (cursor.moveToFirst()) {
-                    val nameIndex = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME)
-                    val sizeIndex = cursor.getColumnIndex(OpenableColumns.SIZE)
 
-                    val fileName = if (nameIndex != -1) cursor.getString(nameIndex) else guessFileNameFromUri(uri)
-                    val fileSize = if (sizeIndex != -1) cursor.getLong(sizeIndex) else -1L
 
-                   var trueSize = -1L
-                    try {
-                        reactContext.contentResolver.openAssetFileDescriptor(uri, "r")?.use { afd ->
-                            trueSize = afd.length
-                        }
-                    } catch (e: FileNotFoundException) {
-                        // Bazı durumlarda bu metod hata verebilir, görmezden gel ve devam et
-                    }
-                   
-                    if (trueSize <= 0) trueSize = fileSize
+private fun convertToJpgAndSaveInternal(uri: Uri, originalFileName: String): String? {
+    return try {
+        val contentResolver = reactContext.contentResolver
 
-                    if (maxSizeBytes > 0 && trueSize > 0 && trueSize > maxSizeBytes) {
-                        throw FileTooLargeException("Seçilen dosya ($fileName) belirtilen ${maxSize}MB boyutundan büyük.")
-                    }
+        // 1. ADIM: Sadece boyutları oku (Memory harcamaz)
+        val options = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+        contentResolver.openInputStream(uri)?.use { BitmapFactory.decodeStream(it, null, options) }
 
-                    val mimeType = reactContext.contentResolver.getType(uri) ?: URLConnection.guessContentTypeFromName(fileName) ?: "application/octet-stream"
-                    val base64 = if (this.withBase64) {
-                        encodeFileToBase64(uri)
-                    } else {
-                        null
+        // 2. ADIM: Örnekleme miktarını hesapla (Max 2048px genişlik/yükseklik standardı)
+        options.inSampleSize = calculateInSampleSize(options, 2048, 2048)
+        options.inJustDecodeBounds = false
+        // Bellek tasarrufu için 16-bit kullan (Senior Tip)
+        options.inPreferredConfig = Bitmap.Config.RGB_565 
+
+        // 3. ADIM: Bitmap'i güvenli boyutta oluştur
+        var bitmap = contentResolver.openInputStream(uri)?.use { 
+            BitmapFactory.decodeStream(it, null, options) 
+        } ?: return null
+
+        // 4. ADIM: Rotasyon düzeltme
+        bitmap = rotateBitmapIfRequired(uri, bitmap)
+
+        // 5. ADIM: Saydamlık (Alpha) temizleme
+        bitmap = fillWhiteBackground(bitmap)
+
+        // 6. ADIM: JPEG olarak kaydet
+        val nameWithoutExt = originalFileName.substringBeforeLast(".")
+        val tempFile = File(reactContext.cacheDir, "picked_${System.currentTimeMillis()}_$nameWithoutExt.jpg")
+        
+        FileOutputStream(tempFile).use { stream ->
+            bitmap.compress(Bitmap.CompressFormat.JPEG, 85, stream) // %85 kalite/boyut dengesi
+        }
+
+        bitmap.recycle()
+        Uri.fromFile(tempFile).toString()
+    } catch (e: Exception) {
+        Log.e("MyUploader", "Pipeline Error: ${e.message}")
+        null
+    }
+}
+
+
+
+
+
+   private fun processSelectedFiles(uris: List<Uri>): WritableArray {
+    val fileObjects = WritableNativeArray()
+    val maxSizeBytes = (maxSize * 1024 * 1024).toLong()
+
+    for (uri in uris) {
+        reactContext.contentResolver.query(uri, null, null, null, null)?.use { cursor ->
+            if (cursor.moveToFirst()) {
+                // 1. Orijinal dosya bilgilerini al (Sadece limit kontrolü için)
+                val nameIndex = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME)
+                val sizeIndex = cursor.getColumnIndex(OpenableColumns.SIZE)
+
+                val originalFileName = if (nameIndex != -1) cursor.getString(nameIndex) else guessFileNameFromUri(uri)
+                val originalFileSize = if (sizeIndex != -1) cursor.getLong(sizeIndex) else -1L
+
+                var trueSize = -1L
+                try {
+                    reactContext.contentResolver.openAssetFileDescriptor(uri, "r")?.use { afd ->
+                        trueSize = afd.length
                     }
+                } catch (e: FileNotFoundException) { }
+                
+                if (trueSize <= 0) trueSize = originalFileSize
 
-                    val internalFileUri = copyFileToInternalStorage(uri, fileName) ?: uri.toString()
+                // 2. Orijinal dosya boyutu kontrolü
+                if (maxSizeBytes > 0 && trueSize > 0 && trueSize > maxSizeBytes) {
+                    throw FileTooLargeException("Seçilen dosya ($originalFileName) belirtilen ${maxSize}MB boyutundan büyük.")
+                }
 
+                // 3. KRİTİK DÜZELTME: Önce JPEG'e dönüştür (Pipeline çalışsın)
+                // Bu fonksiyon artık Rotate ve Arka Plan fix işlemlerini de içeriyor
+                val internalFileUri = convertToJpgAndSaveInternal(uri, originalFileName) ?: uri.toString()
+                val finalUri = Uri.parse(internalFileUri)
 
-                    val fileMap = WritableNativeMap().apply {
-                        putString("fileName", fileName)
-                        putDouble("fileSize", if (trueSize > 0) trueSize.toDouble() else fileSize.toDouble())
-                        putString("fileType", mimeType)
-                        putString("fileUri", internalFileUri)
-                        if (withBase64 && base64 != null) {
-                            putString("base64", base64)
-                        }
+                // 4. Yeni dosyanın gerçek bilgilerini al
+                val finalFile = File(finalUri.path ?: "")
+                val finalSize = finalFile.length()
+                val finalFileName = if (originalFileName.lowercase().endsWith(".jpg") || originalFileName.lowercase().endsWith(".jpeg")) {
+                    originalFileName
+                } else {
+                    "${originalFileName.substringBeforeLast(".")}.jpg"
+                }
+
+                // 5. KRİTİK DÜZELTME: Base64'ü YENİ oluşturulan JPEG üzerinden al
+                // Böylece sunucuya giden base64 ile fileType (image/jpeg) tam eşleşir.
+                val base64 = if (this.withBase64) {
+                    // Sadece 5MB altındaki dosyaların base64'ünü çıkar (JS performansı için)
+                    if (finalSize < 5 * 1024 * 1024) {
+                        encodeFileToBase64(finalUri)
+                    } else {
+                        null // Çok büyükse null bırak, JS çökmesin
                     }
-                    fileObjects.pushMap(fileMap)
+                } else {
+                    null
                 }
-            } ?:throw FileNotFoundException("Content ile dosya bilgisi alınamadı:$uri")
-        }
-        return fileObjects
+
+                val fileMap = WritableNativeMap().apply {
+                    putString("fileName", finalFileName)
+                    putDouble("fileSize", finalSize.toDouble()) // Orijinal değil, yeni boyut
+                    putString("fileType", "image/jpeg")         // Sabit JPEG
+                    putString("fileUri", internalFileUri)
+                    if (withBase64 && base64 != null) {
+                        putString("base64", base64)
+                    }
+                }
+                fileObjects.pushMap(fileMap)
+            }
+        } ?: throw FileNotFoundException("Content ile dosya bilgisi alınamadı: $uri")
     }
+    return fileObjects
+}
 
     private fun guessFileNameFromUri (uri:Uri):String{
         return uri.lastPathSegment?.substringBefore("?") ?: "unknown_file"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-my-uploader-android",
-  "version": "1.0.54",
+  "version": "1.0.56",
   "description": "file uploader for android",
   "main": "./lib/module/index.js",
   "types": "./src/index.d.ts",