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

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
@@ -635,85 +635,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.55",
   "description": "file uploader for android",
   "main": "./lib/module/index.js",
   "types": "./src/index.d.ts",