@react-native-documents/picker 9.3.1

package/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Vojtech Novak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Sun Jan 12 23:27:41 PST 2025
+gradle.version=8.9

package/android/build.gradle

@@ -0,0 +1,80 @@
+buildscript {
+    // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+    def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["DocumentPicker_kotlinVersion"]
+
+    repositories {
+        google()
+        mavenCentral()
+    }
+
+    dependencies {
+        // noinspection DifferentKotlinGradleVersion
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+def getExtOrIntegerDefault(name) {
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties['ReactNativeDocumentPicker_' + name]).toInteger()
+}
+
+def isNewArchitectureEnabled() {
+    // To opt-in for the New Architecture, you can either:
+    // - Set `newArchEnabled` to true inside the `gradle.properties` file
+    // - Invoke gradle with `-newArchEnabled=true`
+    // - Set an environment variable `ORG_GRADLE_PROJECT_newArchEnabled=true`
+    return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+}
+
+apply plugin: 'com.android.library'
+apply plugin: "kotlin-android"
+
+if (isNewArchitectureEnabled()) {
+    apply plugin: "com.facebook.react"
+}
+
+
+android {
+    def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
+    if (agpVersion.tokenize('.')[0].toInteger() >= 7) {
+      namespace "com.reactnativedocumentpicker"
+    }
+    compileSdkVersion getExtOrIntegerDefault('compileSdkVersion')
+
+    // Used to override the NDK path/version on internal CI or by allowing
+    // users to customize the NDK path/version from their root project (e.g. for M1 support)
+    if (rootProject.hasProperty("ndkPath")) {
+        ndkPath rootProject.ext.ndkPath
+    }
+    if (rootProject.hasProperty("ndkVersion")) {
+        ndkVersion rootProject.ext.ndkVersion
+    }
+
+    defaultConfig {
+        minSdkVersion getExtOrIntegerDefault('minSdkVersion')
+        targetSdkVersion getExtOrIntegerDefault('targetSdkVersion')
+        buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    }
+
+    sourceSets.main {
+        java {
+            if (!isNewArchitectureEnabled()) {
+                srcDirs += 'src/paper/java'
+            }
+        }
+    }
+}
+
+repositories {
+    google()
+    mavenLocal()
+    mavenCentral()
+}
+
+def kotlin_version = getExtOrIntegerDefault("kotlinVersion")
+
+dependencies {
+    //noinspection GradleDynamicVersion
+    implementation 'com.facebook.react:react-native:+' // from node_modules
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.1"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.reactnativedocumentpicker">
+</manifest>

package/android/src/main/java/com/reactnativedocumentpicker/CopyDestination.kt

@@ -0,0 +1,12 @@
+// LICENSE: see License.md in the package root
+package com.reactnativedocumentpicker
+
+enum class CopyDestination(val preset: String) {
+  CACHES_DIRECTORY("cachesDirectory"),
+  DOCUMENT_DIRECTORY("documentDirectory");
+
+  companion object {
+    // keep values() for RN 73 compatibility
+    fun fromPath(path: String): CopyDestination = values().find { it.preset == path } ?: CACHES_DIRECTORY
+  }
+}

package/android/src/main/java/com/reactnativedocumentpicker/DocumentMetadataBuilder.kt

@@ -0,0 +1,79 @@
+// LICENSE: see License.md in the package root
+package com.reactnativedocumentpicker
+
+import android.net.Uri
+import android.util.Base64
+import android.webkit.MimeTypeMap
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
+
+class DocumentMetadataBuilder(forUri: Uri) {
+  private val uri: Uri = forUri
+  private var name: String? = null
+  private var size: Long? = null
+  private var mimeType: String? = null
+  private var metadataError: String? = null
+  private var openableMimeTypes: Array<String>? = null
+  private var bookmark: String? = null
+  private var bookmarkError: String? = null
+  private var virtual: Boolean? = null
+
+  fun name(name: String?) = apply { this.name = name }
+
+  fun size(size: Long?) = apply { this.size = size }
+
+  fun mimeType(mimeType: String?) = apply { this.mimeType = mimeType }
+
+  fun metadataReadingError(error: String?) = apply { this.metadataError = error }
+
+  fun openableMimeTypes(openableMimeTypes: Array<String>?) = apply {
+    this.openableMimeTypes = openableMimeTypes
+  }
+
+  fun bookmark(bookmark: Uri) = apply { this.bookmark = bookmark.toString() }
+
+  fun bookmarkError(bookmarkError: String?) = apply { this.bookmarkError = bookmarkError }
+
+  fun virtual(virtual: Boolean) = apply { this.virtual = virtual }
+
+  fun build(): ReadableMap = createReadableMap()
+
+  fun hasMime() = mimeType != null
+
+  fun getUri() = uri
+
+  private fun createReadableMap(): ReadableMap {
+    val map = Arguments.createMap()
+    map.putString("name", name)
+    map.putString("uri", uri.toString())
+    size?.let { map.putDouble("size", it.toDouble()) } ?: map.putNull("size")
+    map.putString("type", mimeType?.lowercase())
+    map.putString("nativeType", mimeType?.lowercase())
+    openableMimeTypes?.let {
+      val arrayOfExtensionsAndMime = Arguments.createArray()
+      it.forEach { mimeType ->
+        val virtualFileDetails = Arguments.createMap()
+        val maybeExtension = MimeTypeMap.getSingleton().getExtensionFromMimeType(mimeType)
+        virtualFileDetails.putString("mimeType", mimeType)
+        virtualFileDetails.putString("extension", maybeExtension)
+        arrayOfExtensionsAndMime.pushMap(virtualFileDetails)
+      }
+      map.putArray("convertibleToMimeTypes", arrayOfExtensionsAndMime)
+    } ?: map.putNull("convertibleToMimeTypes")
+    map.putString("error", metadataError)
+    virtual?.let { map.putBoolean("isVirtual", it) } ?: map.putNull("isVirtual")
+
+    bookmark?.let {
+      // we're encoding so that we behave the same as the iOS implementation
+      val encodedBookmark = Base64.encodeToString(it.toByteArray(Charsets.UTF_8), Base64.DEFAULT)
+      map.putString("bookmarkStatus", "success")
+      map.putString("bookmark", encodedBookmark)
+    }
+        ?: bookmarkError?.let {
+          map.putString("bookmarkStatus", "error")
+          map.putString("bookmarkError", it)
+        }
+
+    return map
+  }
+}

package/android/src/main/java/com/reactnativedocumentpicker/FileOperations.kt

@@ -0,0 +1,203 @@
+package com.reactnativedocumentpicker
+
+import android.content.ContentResolver
+import android.content.Context
+import android.net.Uri
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.util.RNLog
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import java.io.File
+import java.io.FileNotFoundException
+import java.io.FileOutputStream
+import java.io.IOException
+import java.io.InputStream
+import java.nio.channels.Channels
+import java.util.UUID
+
+class FileOperations(private val uriMap: MutableMap<String, Uri>) {
+  suspend fun copyFilesToLocalStorage(
+    context: ReactContext,
+    filesToCopy: ReadableArray,
+    copyTo: CopyDestination,
+  ): ReadableArray =
+    withContext(Dispatchers.IO) {
+      /**
+       * export type LocalCopyResponse = | { status: 'success'; localUri: string; sourceUri: string } |
+       * { status: 'error'; copyError: string; sourceUri: string }
+       */
+      val destinationDir = getUniqueDir(context, copyTo)
+
+      val copyJobs = (0 until filesToCopy.size()).map { i ->
+        async {
+          val oneResult = Arguments.createMap()
+          val map = filesToCopy.getMap(i)
+
+          try {
+            val newFile = copySingleFile(map, context, destinationDir)
+            oneResult.merge(newFile)
+          } catch (e: Exception) {
+            val message: String = e.localizedMessage ?: e.message ?: "Unknown error"
+            oneResult.putString("status", "error")
+            oneResult.putString("copyError", message)
+            oneResult.putString("sourceUri", map.getString("uri"))
+          }
+          return@async oneResult
+        }
+      }
+
+      val results = Arguments.createArray()
+      copyJobs.awaitAll().forEach { result ->
+        results.pushMap(result)
+      }
+
+      return@withContext results
+    }
+
+  private fun copySingleFile(
+    map: ReadableMap,
+    context: ReactContext,
+    destinationDir: File
+  ): ReadableMap {
+    val sourceUriAsString: String = map.getString("uri") ?: throw IllegalArgumentException("URI is missing")
+    val fileName: String = map.getString("fileName") ?: throw IllegalArgumentException("fileName is missing")
+    val convertVirtualFileAsType = map.getString("convertVirtualFileToType")
+
+    val sourceUriInstance = uriMap[sourceUriAsString]
+    if (sourceUriInstance == null) {
+      RNLog.w(
+        context,
+        // https://developer.android.com/guide/components/intents-common#GetFile
+        "keepLocalCopy: You're trying to copy a file \"$fileName\" that wasn't picked with this module. " +
+          "This can lead to permission errors because the file reference is transient to your activity's current lifecycle. See https://developer.android.com/guide/components/intents-common#GetFile . " +
+          "Please use the result from the picker directly.")
+    }
+
+    val copiedFile =
+      copyFile(
+        context,
+        sourceUriInstance ?: Uri.parse(sourceUriAsString),
+        destinationDir,
+        fileName,
+        convertVirtualFileAsType)
+
+    val singleFileCopy = Arguments.createMap()
+    singleFileCopy.putString("status", "success")
+    // NOTE this url-encodes the path, consistent with the iOS implementation and with the response of not-copied files
+    singleFileCopy.putString("localUri", Uri.fromFile(copiedFile).toString())
+    singleFileCopy.putString("sourceUri", sourceUriAsString)
+    return singleFileCopy
+  }
+
+  private fun getUniqueDir(context: Context, copyTo: CopyDestination): File {
+    val baseDir =
+      if (copyTo == CopyDestination.DOCUMENT_DIRECTORY) context.filesDir else context.cacheDir
+
+    val randomDir = File(baseDir, UUID.randomUUID().toString())
+    val didCreateDir = randomDir.mkdir()
+    if (!didCreateDir) {
+      throw IOException("Failed to create directory at ${randomDir.absolutePath}")
+    }
+    return randomDir
+  }
+
+  private fun copyFile(
+    context: Context,
+    from: Uri,
+    destinationDir: File,
+    fileName: String,
+    convertVirtualFileAsType: String?
+  ): File {
+    val attemptedDestFile = File(destinationDir, fileName)
+    val destFileSafe = safeGetDestination(attemptedDestFile, destinationDir)
+
+    val copyStreamToFile: (InputStream?) -> Unit = { inputStream ->
+      if (inputStream == null) {
+        throw FileNotFoundException("No input stream was found for the source file")
+      }
+      FileOutputStream(destFileSafe).channel.use { destinationFileChannel ->
+        val inputChannel = Channels.newChannel(inputStream)
+        val size = destinationFileChannel.transferFrom(inputChannel, 0, Long.MAX_VALUE)
+        if (size == 0L) {
+          throw IOException("No data was copied to the destination file")
+        }
+      }
+    }
+
+    if (convertVirtualFileAsType == null) {
+      context.contentResolver.openInputStream(from).use(copyStreamToFile)
+    } else {
+      getInputStreamForVirtualFile(context.contentResolver, from, convertVirtualFileAsType)
+        .use(copyStreamToFile)
+    }
+
+    return destFileSafe
+  }
+
+  private fun getInputStreamForVirtualFile(
+    contentResolver: ContentResolver,
+    from: Uri,
+    convertVirtualFileAsType: String
+  ): InputStream? {
+    return contentResolver
+      .openTypedAssetFileDescriptor(from, convertVirtualFileAsType, null)
+      ?.createInputStream()
+  }
+
+  private fun safeGetDestination(destFile: File, expectedDir: File): File {
+    val canonicalPath = destFile.canonicalPath
+    if (!canonicalPath.startsWith(expectedDir.canonicalPath)) {
+      throw IllegalArgumentException(
+        "The copied file is attempting to write outside of the target directory.")
+    }
+    return destFile
+  }
+
+  fun writeDocumentImpl(sourceUri: Uri?, targetUriString: String?, context: ReactApplicationContext): DocumentMetadataBuilder {
+    if (sourceUri == null) {
+      throw IllegalArgumentException("The source URI is null. Call saveDocument() before writeDocument()")
+    }
+    val targetUri: Uri? = uriMap[targetUriString]
+
+    if (targetUri == null) {
+      RNLog.e(
+        context,
+        "writeDocument: You're trying to write from Uri \"$targetUriString\" that wasn't picked with this module. " +
+          "Please use the result from saveDocument()")
+      throw IllegalArgumentException("The provided URI is not known")
+    }
+
+    val metadataBuilder = DocumentMetadataBuilder(targetUri)
+
+    val contentResolver = context.contentResolver
+    val mimeFromUri = contentResolver.getType(targetUri)
+    metadataBuilder.mimeType(mimeFromUri)
+
+    // TODO https://gist.github.com/vonovak/73affb1a5b904ee165d9b5981d8dfe9a
+    contentResolver.openInputStream(sourceUri).use { inputStream ->
+      if (inputStream == null) {
+        metadataBuilder.metadataReadingError("No output stream found for source file")
+      } else {
+        contentResolver.openOutputStream(targetUri).use { outputStream ->
+          if (outputStream == null) {
+            metadataBuilder.metadataReadingError("No output stream found for destination file")
+          } else {
+            val bytesCopied = inputStream.copyTo(outputStream)
+            if (bytesCopied == 0L) {
+              metadataBuilder.metadataReadingError("No data was copied to the destination file")
+            }
+            outputStream.flush()
+          }
+        }
+      }
+    }
+
+    return metadataBuilder
+  }
+}

package/android/src/main/java/com/reactnativedocumentpicker/IntentFactory.kt

@@ -0,0 +1,36 @@
+package com.reactnativedocumentpicker
+
+import android.content.Intent
+import android.os.Build
+import android.provider.DocumentsContract
+
+object IntentFactory {
+  fun getPickIntent(options: PickOptions): Intent {
+    // TODO option for extra task on stack?
+    // reminder - flags are for granting rights to others
+
+    return Intent(options.action).apply {
+      val types = options.mimeTypes
+
+      type =
+        if (types.size > 1) {
+          putExtra(Intent.EXTRA_MIME_TYPES, types)
+          options.intentFilterTypes
+        } else {
+          types[0]
+        }
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O &&
+        options.initialDirectoryUrl != null
+      ) {
+        // only works for ACTION_OPEN_DOCUMENT
+        // TODO must be URI
+        putExtra(DocumentsContract.EXTRA_INITIAL_URI, options.initialDirectoryUrl)
+      }
+      if (!options.allowVirtualFiles) {
+        addCategory(Intent.CATEGORY_OPENABLE)
+      }
+      putExtra(Intent.EXTRA_LOCAL_ONLY, options.localOnly)
+      putExtra(Intent.EXTRA_ALLOW_MULTIPLE, options.multiple)
+    }
+  }
+}

package/android/src/main/java/com/reactnativedocumentpicker/IsKnownTypeImpl.kt

@@ -0,0 +1,40 @@
+package com.reactnativedocumentpicker
+
+import android.webkit.MimeTypeMap
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+
+class IsKnownTypeImpl {
+  companion object {
+    fun isKnownType(kind: String, value: String): WritableMap {
+      return when (kind) {
+        "mimeType" -> {
+          val extensionForMime = MimeTypeMap.getSingleton().getExtensionFromMimeType(value)
+          createMap(
+            isKnown = extensionForMime != null,
+            preferredFilenameExtension = extensionForMime,
+            mimeType = if (extensionForMime != null) value else null
+          )
+        }
+        "extension" -> {
+          val mimeForExtension = MimeTypeMap.getSingleton().getMimeTypeFromExtension(value)
+          createMap(
+            isKnown = mimeForExtension != null,
+            preferredFilenameExtension = if (mimeForExtension != null) value else null,
+            mimeType = mimeForExtension
+          )
+        }
+        else -> createMap(isKnown = false, preferredFilenameExtension = null, mimeType = null)
+      }
+    }
+
+    private fun createMap(isKnown: Boolean, preferredFilenameExtension: String?, mimeType: String?): WritableMap {
+      return Arguments.createMap().apply {
+        putNull("UTType")
+        putBoolean("isKnown", isKnown)
+        putString("preferredFilenameExtension", preferredFilenameExtension)
+        putString("mimeType", mimeType)
+      }
+    }
+  }
+}

package/android/src/main/java/com/reactnativedocumentpicker/MetadataGetter.kt

@@ -0,0 +1,150 @@
+// LICENSE: see License.md in the package root
+package com.reactnativedocumentpicker
+
+import android.content.ContentResolver
+import android.content.Context
+import android.content.Intent
+import android.database.Cursor
+import android.net.Uri
+import android.os.Build
+import android.provider.DocumentsContract
+import android.provider.OpenableColumns
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+class MetadataGetter(private val uriMap: MutableMap<String, Uri>) {
+
+  suspend fun processPickedFileUris(
+      context: Context,
+      uris: List<Uri>,
+      pickOptions: PickOptions
+  ): ReadableArray =
+      withContext(Dispatchers.IO) {
+        val results = Arguments.createArray()
+        for (uri in uris) {
+          val metadata = getMetadataForUri(context, uri, pickOptions)
+          uriMap[uri.toString()] = uri
+          results.pushMap(metadata.build())
+        }
+        results
+      }
+
+  private suspend fun getMetadataForUri(
+      context: Context,
+      sourceUri: Uri,
+      pickOptions: PickOptions,
+  ): DocumentMetadataBuilder =
+      withContext(Dispatchers.IO) {
+        val contentResolver = context.contentResolver
+        val metadataBuilder = DocumentMetadataBuilder(sourceUri)
+
+        val mimeFromUri = contentResolver.getType(sourceUri)
+        metadataBuilder.mimeType(mimeFromUri)
+
+        if (pickOptions.allowVirtualFiles) {
+          // https://developer.android.com/training/data-storage/shared/documents-files#open-virtual-file
+          val openableMimeTypes = contentResolver.getStreamTypes(sourceUri, "*/*")
+          metadataBuilder.openableMimeTypes(openableMimeTypes)
+        }
+
+        if (pickOptions.requestLongTermAccess) {
+          // https://developer.android.com/training/data-storage/shared/documents-files#persist-permissions
+          // checking FLAG_GRANT_PERSISTABLE_URI_PERMISSION is not mentioned in the official docs
+          val takeFlags = Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_GRANT_WRITE_URI_PERMISSION
+
+          try {
+            context.contentResolver.takePersistableUriPermission(sourceUri, takeFlags)
+            metadataBuilder.bookmark(sourceUri)
+          } catch (e: Exception) {
+            metadataBuilder.bookmarkError(
+                e.localizedMessage
+                    ?: e.message
+                    ?: "Unknown error with takePersistableUriPermission")
+          }
+        }
+
+        queryContentResolverMetadata(contentResolver, metadataBuilder, context)
+
+        metadataBuilder
+      }
+
+  fun queryContentResolverMetadata(
+      contentResolver: ContentResolver,
+      metadataBuilder: DocumentMetadataBuilder,
+      context: Context
+  ) {
+    val forUri = metadataBuilder.getUri()
+    contentResolver
+      .query(
+        forUri,
+        arrayOf(
+          DocumentsContract.Document.COLUMN_MIME_TYPE,
+          OpenableColumns.DISPLAY_NAME,
+          OpenableColumns.SIZE,
+          DocumentsContract.Document.COLUMN_FLAGS,
+        ),
+        null,
+        null,
+        null
+      )
+      .use { cursor ->
+        if (cursor != null && cursor.moveToFirst()) {
+          metadataBuilder.name(
+            getCursorValue(cursor, OpenableColumns.DISPLAY_NAME, String::class.java)
+          )
+
+          if (!metadataBuilder.hasMime()) {
+            metadataBuilder.mimeType(
+              getCursorValue(
+                cursor, DocumentsContract.Document.COLUMN_MIME_TYPE, String::class.java
+              )
+            )
+          }
+
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            // https://developer.android.com/training/data-storage/shared/documents-files#open-virtual-file
+            val isVirtual =
+              if (DocumentsContract.isDocumentUri(context, forUri)) {
+                val cursorValue: Int =
+                  getCursorValue(
+                    cursor, DocumentsContract.Document.COLUMN_FLAGS, Int::class.java
+                  )
+                    ?: 0
+                cursorValue and DocumentsContract.Document.FLAG_VIRTUAL_DOCUMENT != 0
+              } else {
+                false
+              }
+            metadataBuilder.virtual(isVirtual)
+          }
+          metadataBuilder.size(getCursorValue(cursor, OpenableColumns.SIZE, Long::class.java))
+        } else {
+          // metadataBuilder only contains the uri, type and error in this unlikely case
+          // there's nothing more we can do
+          metadataBuilder.metadataReadingError("Could not read file metadata")
+        }
+      }
+  }
+
+  @Suppress("UNCHECKED_CAST")
+  private fun <T> getCursorValue(cursor: Cursor, columnName: String, valueType: Class<T>): T? {
+    val columnIndex = cursor.getColumnIndex(columnName)
+    if (columnIndex != -1 && !cursor.isNull(columnIndex)) {
+      return try {
+        when (valueType) {
+          String::class.java -> cursor.getString(columnIndex) as T
+          Int::class.java -> cursor.getInt(columnIndex) as T
+          Long::class.java -> cursor.getLong(columnIndex) as T
+          Double::class.java -> cursor.getDouble(columnIndex) as T
+          Float::class.java -> cursor.getFloat(columnIndex) as T
+          else -> null
+        }
+      } catch (e: Exception) {
+        // this should not happen but if it does, we return null
+        null
+      }
+    }
+    return null
+  }
+}