react-native-my-uploader-android 1.0.31 → 1.0.37

package/README.md

@@ -1,73 +1,270 @@
-# react-native-my-uploader
+# React Native My Uploader
 
-file uploader for android 
+Android için basit ve esnek bir dosya seçici. Bu paket, hem kullanıma hazır bir buton bileşeni hem de kendi arayüzünüzü oluşturmanız için bir `Promise` tabanlı fonksiyon sunar.
 
-## Installation
+## Özellikler
 
+- **Tekli ve Çoklu Dosya Seçimi:** `multipleFiles` prop'u ile kolayca geçiş yapın.
+- **Dosya Tipi Filtreleme:** Sadece belirli MIME tiplerindeki (`image/*`, `application/pdf` vb.) dosyaların seçilmesine izin verin.
+- **Limit Kontrolleri:** Seçilebilecek maksimum dosya sayısı (`maxFiles`) ve her bir dosya için maksimum boyut (`maxSize`) belirleyin.
+- **Hariç Tutma:** Daha önce seçilmiş dosyaların tekrar seçilmesini engelleyin (`excludedUris`).
+- **Base64 Çıktısı:** Seçilen dosyaların `base64` formatında verisini döndürür.
+- **İki Farklı Kullanım:** Hızlı entegrasyon için `<MyUploader />` bileşeni veya tam kontrol için `pickFile()` fonksiyonu.
+
+## Kurulum
 
 ```sh
-npm install react-native-my-uploader-android
+npm install react-native-my-uploader-android  //"version": "1.0.32"
 ```
 
-## Usage
+veya
 
+```sh
+yarn add react-native-my-uploader-android  //"version": "1.0.32"
+```
 
-```js
-import MyUploader,{FileInfo} from 'react-native-my-uploader-android';
+## Kullanım
 
+Bu paketi kullanmanın iki ana yolu vardır:
 
- const [selectedFiles, setSelectedFiles] = useState<FileInfo[]>([]); // response= base64,fileName,fileSize,fileType,FileUri 
+### Yöntem 1: Hazır Buton `<MyUploader />` (Önerilen ve Kolay Yol)
 
-//for "react-native-my-uploader-android": "^1.0.25" version
-<MyUploader
-        multipleFiles={false}
-        // maxFiles={3}
-        maxSize={5} // 5MB
-        fileTypes={["*/*"]}
-        buttonPlaceHolder="Dosya Seç (En Fazla 3)"
-        ButtonStyle={styles.customButton}
-        ButtonTextStyle={styles.customButtonText}
-        onSelect={(files) => {
-          console.log('Dosyalar seçildi:', files);
-          // Yeni seçilenleri mevcut listeye ekle
-          setSelectedFiles(prevFiles => [...prevFiles, ...files]);
-        }}
-        onError={(error) => {
-          Alert.alert(`Bir hata oluştu: ${error.message}`);
-        }}
-      />
+Hızlıca bir "Dosya Seç" butonu eklemek için idealdir. Tüm mantık bileşenin kendi içindedir.
 
-<MyUploader
-        multipleFiles={true}
-         maxFiles={3}
-        maxSize={5} // 5MB
-        fileTypes={['application/pdf', 'image/jpeg']}
-        buttonPlaceHolder="Dosya Seç (En Fazla 3)"
+```jsx
+import React,{useState} from 'react';
+import { Text,View, Alert, StyleSheet } from 'react-native';
+import MyUploader, { FileInfo } from 'react-native-my-uploader-android';
+
+export default function App() {
+
+  const [files,setFiles]=useState<FileInfo[] |null>(null);
+
+  const handleFilesSelected = (files: FileInfo[]) => {
+    console.log('Seçilen Dosyalar:', files);
+    setFiles(prev => prev ? [...prev, ...files] : [...files]);
+  };
+
+  return (
+    <View style={styles.container}>
+      <MyUploader
+        onSelect={handleFilesSelected}
+        onError={(error)=>{ Alert.alert('Bir Hata Oluştu', error.message)}}
+        buttonPlaceHolder="En Fazla 3 Resim Seç (Max 2MB)"
         ButtonStyle={styles.customButton}
         ButtonTextStyle={styles.customButtonText}
-        onSelect={(files) => {
-          console.log('Dosyalar seçildi:', files);
-          // Yeni seçilenleri mevcut listeye ekle
-          setSelectedFiles(prevFiles => [...prevFiles, ...files]);
-        }}
-        onError={(error) => {
-          Alert.alert(`Bir hata oluştu: ${error.message}`);
-        }}
+        multipleFiles={true}
+        fileTypes={['image/*']}
+        maxSize={2}
+        maxFiles={3}
       />
 
+      {files ? (
+        <View style={styles.fileListContainer}>
+          <Text style={styles.fileListTitle}>Seçilen Dosyalar:</Text>
+
+          {files.map((file, index) => (
+            <Text key={index} style={styles.fileName}>
+              {file.fileName} ({file.fileSize} KB)
+            </Text>
+          ))}
+        </View>
+      ) : (
+        <View style={styles.fileListContainer}>
+          <Text>Dosya Bulunmamaktadır</Text>
+        </View>
+      )}
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+    padding: 20,
+  },
+  customButton: {
+    backgroundColor: '#00796B',
+    paddingVertical: 15,
+    paddingHorizontal: 30,
+    borderRadius: 30,
+  },
+  customButtonText: {
+    color: '#FFFFFF',
+    fontSize: 14,
+  },
+  fileListContainer: {
+    marginTop: 20,
+    padding: 15,
+    backgroundColor: '#f0f0f0',
+    borderRadius: 8,
+    width: '100%',
+  },
+  fileListTitle: {
+    fontSize: 16,
+    fontWeight: 'bold',
+    marginBottom: 10,
+  },
+  fileName: {
+    fontSize: 14,
+    color: '#333',
+    marginBottom: 5,
+  },
+});
+
+```
+
+### Yöntem 2: Fonksiyon `pickFile()` (Tam Kontrol İçin)
+
+Kendi özel butonunuzu veya dokunma alanınızı tasarlamak istediğinizde bu yöntemi kullanın. `async/await` ile çalışır ve size tam kontrol sağlar.
+
+```jsx
+import React,{useState} from 'react';
+import { Text,View, Alert, StyleSheet ,TouchableOpacity} from 'react-native';
+import { pickFile ,FileInfo} from 'react-native-my-uploader-android';
+
+export default function App() {
+  const [pickFiles,setPickFiles]=useState<FileInfo[] |null>(null)
+
+  const handlePress = async () => {
+    try {
+      // Dosya seçiciyi aç ve sonucu bekle
+      const files = await pickFile({
+        multipleFiles: true,
+        fileTypes: ['application/pdf', 'application/vnd.ms-excel'], // Sadece PDF ve Excel
+        maxFiles: 5,
+        maxSize: 10, // 10MB
+      });
+      setPickFiles(prev => prev ? [...prev, ...files] : [...files]);
+      console.log(files);
+
+    } catch (error: any) {
+        Alert.alert('Hata', error.message);
+    }
+  };
+
+  return (
+    <View style={styles.container}>
+      <TouchableOpacity style={styles.fancyButton} onPress={handlePress}>
+        <Text style={styles.fancyButtonText}>PDF veya Excel Yükle</Text>
+      </TouchableOpacity>
+        {pickFiles ?(
+          <View style={styles.fileListContainer}>
+            <Text style={styles.fileListTitle}>Seçilen Dosyalar:</Text>
+            {pickFiles.map((file, index) => (
+              <View key={index}>
+                <Text style={styles.fileName}>{file.fileName} ({file.fileSize} KB)</Text>
+              </View>
+            ))}
+          </View>
+        ):(
+          <View>
+            <Text>Dosya bulunmamaktadır.</Text>
+            </View>
+        )};
+    </View>
+  )
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+    padding: 20,
+  },
+  customButton: {
+    backgroundColor: '#00796B',
+    paddingVertical: 15,
+    paddingHorizontal: 30,
+    borderRadius: 30,
+  },
+  customButtonText: {
+    color: '#FFFFFF',
+    fontSize: 14,
+  },
+  fileListContainer: {
+    marginTop: 20,
+    padding: 15,
+    backgroundColor: '#f0f0f0',
+    borderRadius: 8,
+    width: '100%',
+  },
+  fileListTitle: {
+    fontSize: 16,
+    fontWeight: 'bold',
+    marginBottom: 10,
+  },
+  fileName: {
+    fontSize: 14,
+    color: '#333',
+    marginBottom: 15,
+    borderBottomWidth:1,
+    paddingBottom:10
+  },
+    fancyButton: {
+    borderWidth: 2,
+    borderColor: '#6200EE',
+    padding: 15,
+    borderRadius: 10,
+  },
+  fancyButtonText: {
+    color: '#6200EE',
+    fontWeight: 'bold',
+    fontSize: 16,
+  },
+});
+
 ```
 
+## Prop'lar
+
+### `<MyUploader />` & `pickFile()` Ortak Prop'ları (`DocumentPickerOptions`)
+
+| Prop           | Tip         | Varsayılan | Açıklama                                                                |
+|----------------|-------------|------------|-------------------------------------------------------------------------|
+| `multipleFiles`| `boolean`   | `false`    | `true` ise birden fazla dosya seçimine izin verir.                         |
+| `maxFiles`     | `number`    | `3`        | `multipleFiles` `true` iken seçilebilecek maksimum dosya sayısı. `0` ise limitsiz. |
+| `maxSize`      | `number`    | `0`        | Her bir dosya için MB cinsinden maksimum boyut. `0` ise limitsiz.      |
+| `fileTypes`    | `string[]`  | `['*/*']`  | Seçilebilecek dosya tipleri (MIME). Örn: `['image/jpeg', 'image/png']`. |
+| `excludedUris` | `string[]`  | `[]`       | Seçim sonuçlarından hariç tutulacak dosyaların `fileUri` listesi.        |
+
+
+### `<MyUploader />` Özel Prop'ları
+
+| Prop                | Tip                   | Varsayılan  | Açıklama                               |
+|---------------------|-----------------------|-------------|----------------------------------------|
+| `onSelect`          | `(files: FileInfo[]) => void` | **Zorunlu** | Dosyalar başarıyla seçildiğinde tetiklenir. |
+| `onError`           | `(error: Error) => void` | `undefined` | Bir hata oluştuğunda tetiklenir.         |
+| `buttonPlaceHolder` | `string`              | `"Dosya Seç"`| Buton üzerinde görünecek metin.          |
+| `ButtonStyle`       | `ViewStyle`           | `undefined` | Butonun `TouchableOpacity` stili.        |
+| `ButtonTextStyle`   | `TextStyle`           | `undefined` | Buton metninin `Text` stili.             |
+| `disabled`          | `boolean`             | `false`     | `true` ise buton devre dışı kalır.       |
+
+## Dönen Değer (`FileInfo` objesi)
+
+Her iki yöntem de `FileInfo` objelerinden oluşan bir dizi döndürür:
+
+```typescript
+interface FileInfo {
+  fileName: string;     // Dosyanın adı
+  fileSize: number;     // Dosyanın boyutu (byte cinsinden)
+  fileType: string;     // Dosyanın MIME tipi
+  fileUri: string;      // Dosyanın cihazdaki URI'si (Content URI)
+  base64: string | null; // Dosyanın Base64 kodlanmış verisi
+}
+```
 
-## Contributing
+## Katkıda Bulunma (Contributing)
 
-- [Development workflow](CONTRIBUTING.md#development-workflow)
-- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
-- [Code of conduct](CODE_OF_CONDUCT.md)
+Katkılarınız için her zaman açığız! Lütfen [CONTRIBUTING.md](CONTRIBUTING.md) dosyasını inceleyin.
 
-## License
+## Lisans
 
 MIT
 
 ---
 
-Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

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

@@ -1,177 +1,201 @@
 package com.myuploaderandroid
-
-import android.app.DownloadManager
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.content.IntentFilter
-import android.net.Uri
+import android.content.ContentValues
 import android.os.Build
 import android.os.Environment
-import android.util.Log
-import android.webkit.CookieManager
-import android.webkit.URLUtil
+import android.provider.MediaStore
+import android.webkit.MimeTypeMap
 import com.facebook.react.bridge.*
+import java.io.BufferedInputStream
 import java.io.File
+import java.io.FileOutputStream
+import java.io.OutputStream
 import java.net.HttpURLConnection
 import java.net.URL
-import java.util.concurrent.ConcurrentHashMap
-
-class DownloadFileModule(private val reactContext: ReactApplicationContext) :
-    ReactContextBaseJavaModule(reactContext) {
-
-    private val TAG = "DownloadFileModule"
-    private val downloadPromises = ConcurrentHashMap<Long, Promise>()
-
-    private val receiver: BroadcastReceiver = object : BroadcastReceiver() {
-        override fun onReceive(context: Context, intent: Intent) {
-            val downloadId = intent.getLongExtra(DownloadManager.EXTRA_DOWNLOAD_ID, -1)
-            if (downloadId != -1L) {
-                downloadPromises.remove(downloadId)?.let { promise ->
-                    checkDownloadStatus(downloadId, promise)
-                }
+import java.net.URLDecoder
+import java.util.Locale
+class DownloadFileModule ( reactContext: ReactApplicationContext ) : ReactContextBaseJavaModule(reactContext) {
+
+override fun getName(): String = "DownloadFileModule"
+
+@ReactMethod
+fun downloadFile(urlStr: String, options: ReadableMap, promise: Promise) {
+    Thread {
+        var connection: HttpURLConnection? = null
+        var inputStream: BufferedInputStream? = null
+        var outputStream: OutputStream? = null
+        var finished = false
+
+        fun rejectOnce(code: String, message: String) {
+            if (!finished) {
+                finished = true
+                promise.reject(code, message)
             }
         }
-    }
-
-    override fun getName(): String = "DownloadFile"
 
-    init {
-        val intentFilter = IntentFilter(DownloadManager.ACTION_DOWNLOAD_COMPLETE)
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            reactContext.registerReceiver(receiver, intentFilter, Context.RECEIVER_NOT_EXPORTED)
-        } else {
-            reactContext.registerReceiver(receiver, intentFilter)
+        fun resolveOnce(value: String) {
+            if (!finished) {
+                finished = true
+                promise.resolve(value)
+            }
         }
-    }
 
-    override fun onCatalystInstanceDestroy() {
         try {
-            reactContext.unregisterReceiver(receiver)
-        } catch (e: Exception) {
-            Log.w(TAG, "Receiver unregister warning: ${e.message}")
-        }
-        super.onCatalystInstanceDestroy()
-    }
-
-    @ReactMethod
-    fun downloadFile(fileUrl: String, options: ReadableMap, promise: Promise) {
-        val isDebug = if (options.hasKey("debug")) options.getBoolean("debug") else false
-        val maxSizeMB = if (options.hasKey("maxSize")) options.getDouble("maxSize") else 0.0
-        
-        // Allowed File Types (Mime Types)
-        val allowedTypes = if (options.hasKey("fileTypes")) {
-            options.getArray("fileTypes")?.toArrayList()?.mapNotNull { it.toString() } ?: emptyList()
-        } else emptyList()
-
-        if (isDebug) Log.d(TAG, "İndirme başlatılıyor: $fileUrl")
+            // --- OPTIONS ---
+            val maxSizeMB = if (options.hasKey("maxSize")) options.getInt("maxSize") else 0
+            val fileTypes = if (options.hasKey("fileTypes")) options.getArray("fileTypes") else null
+
+            // --- CONNECTION ---
+            val url = URL(urlStr)
+            connection = url.openConnection() as HttpURLConnection
+            connection.requestMethod = "GET"
+            connection.connect()
+
+            // --- HTTP STATUS CHECK ---
+            if (connection.responseCode !in 200..299) {
+                connection.disconnect()
+                rejectOnce(
+                    "ERR_HTTP",
+                    "Sunucu hatası: ${connection.responseCode}"
+                )
+                return@Thread
+            }
 
-        Thread {
-            var connection: HttpURLConnection? = null
-            try {
-                val url = URL(fileUrl)
-                connection = url.openConnection() as HttpURLConnection
-                val cookie = CookieManager.getInstance().getCookie(fileUrl)
-                if (cookie != null) connection.setRequestProperty("Cookie", cookie)
-                connection.requestMethod = "HEAD" // Sadece başlıkları çek
-                connection.connect()
-
-                val responseCode = connection.responseCode
-                if (responseCode !in 200..299) {
-                    promise.reject("E_HTTP_ERROR", "Sunucu hatası: $responseCode")
+            // --- SIZE CHECK ---
+            val contentLength = connection.contentLengthLong
+            if (maxSizeMB > 0 && contentLength > 0) {
+                val maxBytes = maxSizeMB * 1024 * 1024
+                if (contentLength > maxBytes) {
+                    connection.disconnect()
+                    rejectOnce(
+                        "ERR_SIZE_LIMIT",
+                        "Dosya boyutu ($maxSizeMB MB) sınırını aşıyor."
+                    )
                     return@Thread
                 }
+            }
 
-                val fileSize = connection.contentLengthLong
-                val contentType = connection.contentType
-                val cleanContentType = contentType?.split(";")?.get(0)?.trim() ?: "*/*"
-                
-                // 1. Content-Type Kontrolü
-                if (allowedTypes.isNotEmpty() && !allowedTypes.contains("*/*")) {
-                    var isAllowed = false
-                    for (type in allowedTypes) {
-                        if (type == "*/*" || cleanContentType.equals(type, ignoreCase = true) || cleanContentType.startsWith(type.replace("*", ""))) {
-                            isAllowed = true
-                            break
-                        }
+            // --- TYPE CHECK ---
+            val contentType = connection.contentType ?: ""
+
+            if (fileTypes != null && fileTypes.size() > 0) {
+                val allowedTypes = HashSet<String>()
+                for (i in 0 until fileTypes.size()) {
+                   val type = fileTypes.getString(i)
+                    if (type != null) {
+                        // 🔥 DÜZELTME BURADA: typesList -> allowedTypes yapıldı
+                        allowedTypes.add(type.lowercase(Locale.ROOT))
                     }
-                    if (!isAllowed) {
-                        promise.reject("E_INVALID_FILE_TYPE", "Dosya türü ($cleanContentType) izin verilenler listesinde yok.")
-                        return@Thread
+                }
+
+                val isAllowed = when {
+                    allowedTypes.contains("*/*") -> true
+                    contentType.isEmpty() -> false
+                    else -> allowedTypes.any {
+                        contentType.lowercase(Locale.ROOT).contains(it)
                     }
                 }
 
-                // 2. Boyut Kontrolü
-                if (maxSizeMB > 0 && fileSize > 0 && fileSize > maxSizeMB * 1024 * 1024) {
-                    promise.reject("E_FILE_TOO_LARGE", "Dosya boyutu (${(fileSize / 1024.0 / 1024.0).toInt()}MB) limitin (${maxSizeMB}MB) üzerinde.")
+                if (!isAllowed) {
+                    connection.disconnect()
+                    val displayType = if (contentType.isNotEmpty()) contentType else "Bilinmeyen"
+                    rejectOnce(
+                        "ERR_TYPE_MISMATCH",
+                        "Dosya tipi ($displayType) izin verilenler listesinde yok."
+                    )
                     return@Thread
                 }
+            }
 
-                val contentDisposition = connection.getHeaderField("Content-Disposition")
-                val fileName = URLUtil.guessFileName(fileUrl, contentDisposition, cleanContentType)
+            // --- FILE NAME ---
+            val fileName = getFileNameFromUrl(urlStr, contentType)
 
-                // Dosya Adı Çakışma Önleme
-                val downloadsDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS)
-                val baseName = fileName.substringBeforeLast(".")
-                val ext = fileName.substringAfterLast(".", "")
-                var counter = 1
-                var finalFileName = fileName
-                
-                while (File(downloadsDir, finalFileName).exists()) {
-                    finalFileName = if (ext.isNotEmpty()) "$baseName($counter).$ext" else "$baseName($counter)"
-                    counter++
+            // --- OPEN STREAM ---
+            inputStream = BufferedInputStream(connection.inputStream)
+            var finalUri = ""
+
+            // --- SAVE FILE ---
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                val resolver = reactApplicationContext.contentResolver
+                val values = ContentValues().apply {
+                    put(MediaStore.MediaColumns.DISPLAY_NAME, fileName)
+                    put(MediaStore.MediaColumns.MIME_TYPE, contentType)
+                    put(MediaStore.MediaColumns.RELATIVE_PATH, Environment.DIRECTORY_DOWNLOADS)
                 }
 
-                val request = DownloadManager.Request(Uri.parse(fileUrl))
-                    .setTitle(finalFileName)
-                    .setDescription("Dosya indiriliyor...")
-                    .setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED)
-                    .setDestinationInExternalPublicDir(Environment.DIRECTORY_DOWNLOADS, finalFileName)
-                    .setAllowedOverMetered(true)
+                val uri = resolver.insert(
+                    MediaStore.Downloads.EXTERNAL_CONTENT_URI,
+                    values
+                ) ?: throw Exception("MediaStore dosya oluşturulamadı")
 
-                if (cookie != null) request.addRequestHeader("Cookie", cookie)
-                if (cleanContentType != "*/*") request.setMimeType(cleanContentType)
+                outputStream = resolver.openOutputStream(uri)
+                finalUri = uri.toString()
+            } else {
+                @Suppress("DEPRECATION")
+                val dir = Environment.getExternalStoragePublicDirectory(
+                    Environment.DIRECTORY_DOWNLOADS
+                )
+                if (!dir.exists()) dir.mkdirs()
+
+                var file = File(dir, fileName)
+                var index = 1
+                val base = fileName.substringBeforeLast(".")
+                val ext = fileName.substringAfterLast(".", "")
 
-                val downloadManager = reactContext.getSystemService(Context.DOWNLOAD_SERVICE) as DownloadManager
-                val downloadId = downloadManager.enqueue(request)
+                while (file.exists()) {
+                    val name = if (ext.isNotEmpty()) "$base($index).$ext" else "$base($index)"
+                    file = File(dir, name)
+                    index++
+                }
 
-                downloadPromises[downloadId] = promise
+                outputStream = FileOutputStream(file)
+                finalUri = file.absolutePath
+            }
 
-            } catch (e: Exception) {
-                promise.reject("E_DOWNLOAD_SETUP_FAILED", e.message)
-            } finally {
-                connection?.disconnect()
+            // --- WRITE ---
+            val buffer = ByteArray(4096)
+            var count: Int
+            while (inputStream.read(buffer).also { count = it } != -1) {
+                outputStream?.write(buffer, 0, count)
             }
-        }.start()
-    }
 
-    private fun checkDownloadStatus(id: Long, promise: Promise?) {
-        val downloadManager = reactContext.getSystemService(Context.DOWNLOAD_SERVICE) as DownloadManager
-        val query = DownloadManager.Query().setFilterById(id)
-        val cursor = downloadManager.query(query)
+            outputStream?.flush()
+            resolveOnce(finalUri)
 
-        if (cursor == null) {
-            promise?.reject("E_DB_CURSOR_NULL", "Download cursor null")
-            return
+        } catch (e: Exception) {
+            rejectOnce(
+                "ERR_DOWNLOAD",
+                e.message ?: "İndirme sırasında hata oluştu"
+            )
+        } finally {
+            try {
+                outputStream?.close()
+                inputStream?.close()
+                connection?.disconnect()
+            } catch (_: Exception) {
+            }
         }
+    }.start()
+}
+
+private fun getFileNameFromUrl(url: String, contentType: String?): String {
+    var name = try {
+        URLDecoder.decode(
+            URL(url).path.substringAfterLast('/'),
+            "UTF-8"
+        )
+    } catch (e: Exception) {
+        "downloaded_file"
+    }
 
-        cursor.use {
-            if (it.moveToFirst()) {
-                val statusIndex = it.getColumnIndex(DownloadManager.COLUMN_STATUS)
-                val status = if (statusIndex >= 0) it.getInt(statusIndex) else DownloadManager.STATUS_FAILED
-
-                if (status == DownloadManager.STATUS_SUCCESSFUL) {
-                    val uriIndex = it.getColumnIndex(DownloadManager.COLUMN_LOCAL_URI)
-                    val localUri = if (uriIndex >= 0) it.getString(uriIndex) else null
-                    promise?.resolve(localUri)
-                } else {
-                    val reasonIndex = it.getColumnIndex(DownloadManager.COLUMN_REASON)
-                    val reason = if (reasonIndex >= 0) it.getInt(reasonIndex) else -1
-                    promise?.reject("E_DOWNLOAD_FAILED", "İndirme başarısız kod: $reason")
-                }
-            } else {
-                promise?.reject("E_DOWNLOAD_NOT_FOUND", "İndirme kaydı bulunamadı.")
-            }
+    if (name.isBlank()) name = "downloaded_file"
+
+    if (!name.contains(".") && !contentType.isNullOrEmpty()) {
+        val ext = MimeTypeMap.getSingleton()
+            .getExtensionFromMimeType(contentType)
+        if (ext != null) {
+            name += ".$ext"
         }
     }
+    return name
+}
 }