react-native-compressor 1.7.2 → 1.8.1

package/android/src/main/java/com/reactnativecompressor/Utils/MediaCache.kt

@@ -0,0 +1,61 @@
+package com.reactnativecompressor.Utils
+
+import android.util.Log
+import java.io.File
+
+object MediaCache {
+    private const val TAG = "MediaCache"
+    private val completedImagePaths: MutableList<String> = ArrayList()
+    fun addCompletedImagePath(imagePath: String?) {
+        if (imagePath != null) {
+            // Your code to add the imagePath to a list or perform other actions if needed.
+            completedImagePaths.add(imagePath)
+            Log.d(TAG, "Successfully added image path: $imagePath")
+        }
+    }
+
+    @JvmStatic
+    fun removeCompletedImagePath(imagePath: String?) {
+        var imagePath = imagePath
+        if (imagePath != null) {
+            if (completedImagePaths.contains(imagePath)) {
+                // Image path exists in the list, so remove it
+                completedImagePaths.remove(imagePath)
+                if (imagePath.startsWith("file://")) {
+                    imagePath = imagePath.substring(7) // Remove "file://"
+                }
+
+                // Remove the image file
+                val file = File(imagePath)
+                if (file.exists()) {
+                    if (file.delete()) {
+                        Log.d(TAG, "Successfully deleted image file: $imagePath")
+                    } else {
+                        Log.d(TAG, "Failed to delete image file: $imagePath")
+                    }
+                } else {
+                    Log.d(TAG, "Image file not found: $imagePath")
+                }
+            } else {
+                Log.d(TAG, "Image path not found in the completedImagePaths list: $imagePath")
+            }
+        }
+    }
+
+    fun cleanupCache() {
+        // Iterate through the list of completed image paths and delete the corresponding files
+        for (imagePath in completedImagePaths) {
+            val file = File(imagePath)
+            if (file.exists()) {
+                if (file.delete()) {
+                    Log.d(TAG, "Successfully deleted image file during cache cleanup: $imagePath")
+                } else {
+                    Log.d(TAG, "Failed to delete image file during cache cleanup: $imagePath")
+                }
+            } else {
+                Log.d(TAG, "Image file not found during cache cleanup: $imagePath")
+            }
+        }
+        completedImagePaths.clear()
+    }
+}

package/android/src/main/java/com/reactnativecompressor/Utils/RealPathUtil.kt

@@ -0,0 +1,177 @@
+package com.reactnativecompressor.Utils
+
+import android.annotation.SuppressLint
+import android.content.ContentUris
+import android.content.Context
+import android.database.Cursor
+import android.net.Uri
+import android.os.Build
+import android.os.Environment
+import android.provider.DocumentsContract
+import android.provider.MediaStore
+import androidx.loader.content.CursorLoader
+
+object RealPathUtil {
+    fun getRealPath(context: Context, fileUri: Uri): String? {
+        val realPath: String?
+        // SDK < API11
+        realPath = if (Build.VERSION.SDK_INT < 11) {
+            getRealPathFromURI_BelowAPI11(context, fileUri)
+        } else if (Build.VERSION.SDK_INT < 19) {
+            getRealPathFromURI_API11to18(context, fileUri)
+        } else {
+            getRealPathFromURI_API19(context, fileUri)
+        }
+        return realPath
+    }
+
+    @SuppressLint("NewApi")
+    fun getRealPathFromURI_API11to18(context: Context?, contentUri: Uri?): String? {
+        val proj = arrayOf(MediaStore.Images.Media.DATA)
+        var result: String? = null
+        val cursorLoader = CursorLoader(context!!, contentUri!!, proj, null, null, null)
+        val cursor = cursorLoader.loadInBackground()
+        if (cursor != null) {
+            val column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA)
+            cursor.moveToFirst()
+            result = cursor.getString(column_index)
+            cursor.close()
+        }
+        return result
+    }
+
+    fun getRealPathFromURI_BelowAPI11(context: Context, contentUri: Uri?): String {
+        val proj = arrayOf(MediaStore.Images.Media.DATA)
+        val cursor = context.contentResolver.query(contentUri!!, proj, null, null, null)
+        var column_index = 0
+        var result = ""
+        if (cursor != null) {
+            column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA)
+            cursor.moveToFirst()
+            result = cursor.getString(column_index)
+            cursor.close()
+            return result
+        }
+        return result
+    }
+
+    /**
+     * Get a file path from a Uri. This will get the the path for Storage Access
+     * Framework Documents, as well as the _data field for the MediaStore and
+     * other file-based ContentProviders.
+     *
+     * @param context The context.
+     * @param uri     The Uri to query.
+     * @author paulburke
+     */
+    @SuppressLint("NewApi")
+    fun getRealPathFromURI_API19(context: Context, uri: Uri): String? {
+        val isKitKat = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT
+
+        // DocumentProvider
+        if (isKitKat && DocumentsContract.isDocumentUri(context, uri)) {
+            // ExternalStorageProvider
+            if (isExternalStorageDocument(uri)) {
+                val docId = DocumentsContract.getDocumentId(uri)
+                val split = docId.split(":".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+                val type = split[0]
+                if ("primary".equals(type, ignoreCase = true)) {
+                    return Environment.getExternalStorageDirectory().toString() + "/" + split[1]
+                }
+
+                // TODO handle non-primary volumes
+            } else if (isDownloadsDocument(uri)) {
+                val id = DocumentsContract.getDocumentId(uri)
+                val contentUri = ContentUris.withAppendedId(
+                        Uri.parse("content://downloads/public_downloads"), java.lang.Long.valueOf(id))
+                return getDataColumn(context, contentUri, null, null)
+            } else if (isMediaDocument(uri)) {
+                val docId = DocumentsContract.getDocumentId(uri)
+                val split = docId.split(":".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+                val type = split[0]
+                var contentUri: Uri? = null
+                if ("image" == type) {
+                    contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI
+                } else if ("video" == type) {
+                    contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI
+                } else if ("audio" == type) {
+                    contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI
+                }
+                val selection = "_id=?"
+                val selectionArgs = arrayOf(
+                        split[1]
+                )
+                return getDataColumn(context, contentUri, selection, selectionArgs)
+            }
+        } else if ("content".equals(uri.scheme, ignoreCase = true)) {
+
+            // Return the remote address
+            return if (isGooglePhotosUri(uri)) uri.lastPathSegment else getDataColumn(context, uri, null, null)
+        } else if ("file".equals(uri.scheme, ignoreCase = true)) {
+            return uri.path
+        }
+        return null
+    }
+
+    /**
+     * Get the value of the data column for this Uri. This is useful for
+     * MediaStore Uris, and other file-based ContentProviders.
+     *
+     * @param context       The context.
+     * @param uri           The Uri to query.
+     * @param selection     (Optional) Filter used in the query.
+     * @param selectionArgs (Optional) Selection arguments used in the query.
+     * @return The value of the _data column, which is typically a file path.
+     */
+    fun getDataColumn(context: Context, uri: Uri?, selection: String?,
+                      selectionArgs: Array<String>?): String? {
+        var cursor: Cursor? = null
+        val column = "_data"
+        val projection = arrayOf(
+                column
+        )
+        try {
+            cursor = context.contentResolver.query(uri!!, projection, selection, selectionArgs,
+                    null)
+            if (cursor != null && cursor.moveToFirst()) {
+                val index = cursor.getColumnIndexOrThrow(column)
+                return cursor.getString(index)
+            }
+        } finally {
+            cursor?.close()
+        }
+        return null
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is ExternalStorageProvider.
+     */
+    fun isExternalStorageDocument(uri: Uri): Boolean {
+        return "com.android.externalstorage.documents" == uri.authority
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is DownloadsProvider.
+     */
+    fun isDownloadsDocument(uri: Uri): Boolean {
+        return "com.android.providers.downloads.documents" == uri.authority
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is MediaProvider.
+     */
+    fun isMediaDocument(uri: Uri): Boolean {
+        return "com.android.providers.media.documents" == uri.authority
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is Google Photos.
+     */
+    fun isGooglePhotosUri(uri: Uri): Boolean {
+        return "com.google.android.apps.photos.content" == uri.authority
+    }
+}

package/android/src/main/java/com/reactnativecompressor/Utils/Uploader.kt

@@ -0,0 +1,117 @@
+package com.reactnativecompressor.Utils
+
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import io.github.lizhangqu.coreprogress.ProgressHelper
+import io.github.lizhangqu.coreprogress.ProgressUIListener
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.MediaType
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.OkHttpClient
+import okhttp3.Request.Builder
+import okhttp3.RequestBody
+import okhttp3.Response
+import java.io.File
+import java.io.IOException
+import java.util.Locale
+
+object Uploader {
+    private const val TAG = "asyncTaskUploader"
+
+    fun upload(fileUrl: String, _options: ReadableMap?, reactContext: ReactApplicationContext, promise: Promise) {
+        val options = _options?.let { UploaderHelper.fromMap(it) }
+        val uploadableFile = File(fileUrl)
+        val url = options?.url
+        var contentType: String? = "video"
+        val okHttpClient = OkHttpClient()
+        val builder = Builder()
+      if (url != null) {
+        builder.url(url)
+      }
+        val headerIterator = options!!.headers!!.keySetIterator()
+        while (headerIterator.hasNextKey()) {
+            val key = headerIterator.nextKey()
+            val value = options.headers!!.getString(key)
+            Log.d(TAG, "$key  value: $value")
+            builder.addHeader(key, value.toString())
+            if (key.lowercase(Locale.getDefault()) === "content-type:") {
+                contentType = value
+            }
+        }
+        val mediaType: MediaType = contentType?.toMediaTypeOrNull()!!;
+        val body = RequestBody.create(mediaType, uploadableFile)
+        val requestBody = ProgressHelper.withProgress(body, object : ProgressUIListener() {
+            //if you don't need this method, don't override this methd. It isn't an abstract method, just an empty method.
+            override fun onUIProgressStart(totalBytes: Long) {
+                super.onUIProgressStart(totalBytes)
+                Log.d(TAG, "onUIProgressStart:$totalBytes")
+            }
+
+            override fun onUIProgressChanged(numBytes: Long, totalBytes: Long, percent: Float, speed: Float) {
+                EventEmitterHandler.sendUploadProgressEvent(numBytes,totalBytes,options.uuid)
+                Log.d(TAG, "=============start===============")
+                Log.d(TAG, "numBytes:$numBytes")
+                Log.d(TAG, "totalBytes:$totalBytes")
+                Log.d(TAG, "percent:$percent")
+                Log.d(TAG, "speed:$speed")
+                Log.d(TAG, "============= end ===============")
+            }
+
+            //if you don't need this method, don't override this methd. It isn't an abstract method, just an empty method.
+            override fun onUIProgressFinish() {
+                super.onUIProgressFinish()
+                Log.d(TAG, "onUIProgressFinish:")
+            }
+        })
+        builder.put(requestBody)
+        val call = okHttpClient.newCall(builder.build())
+        call.enqueue(object : Callback {
+            override fun onFailure(call: Call, e: IOException) {
+                Log.d(TAG, "=============onFailure===============")
+                promise.reject("")
+                e.printStackTrace()
+            }
+
+            @Throws(IOException::class)
+            override fun onResponse(call: Call, response: Response) {
+                Log.d(TAG, "=============onResponse===============")
+                Log.d(TAG, "request headers:" + response.request.headers)
+                Log.d(TAG, "response code:" + response.code)
+                Log.d(TAG, "response headers:" + response.headers)
+                Log.d(TAG, "response body:" + response.body!!.string())
+                val param = Arguments.createMap()
+                param.putInt("status", response.code)
+                promise.resolve(param)
+            }
+        })
+    }
+}
+
+
+class UploaderHelper {
+  var uuid: String? = null
+  var method: String? = null
+  var headers: ReadableMap? = null
+  var url: String? = null
+
+  companion object {
+    fun fromMap(map: ReadableMap): UploaderHelper {
+      val options = UploaderHelper()
+      val iterator = map.keySetIterator()
+      while (iterator.hasNextKey()) {
+        val key = iterator.nextKey()
+        when (key) {
+          "uuid" -> options.uuid = map.getString(key)
+          "method" -> options.method = map.getString(key)
+          "headers" -> options.headers = map.getMap(key)
+          "url" -> options.url = map.getString(key)
+        }
+      }
+      return options
+    }
+  }
+}

package/android/src/main/java/com/reactnativecompressor/Utils/Utils.kt

@@ -0,0 +1,162 @@
+package com.reactnativecompressor.Utils
+
+import android.content.ContentResolver
+import android.content.res.AssetFileDescriptor
+import android.net.Uri
+import android.provider.OpenableColumns
+import android.util.Log
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import numan.dev.videocompressor.VideoCompressTask
+import numan.dev.videocompressor.VideoCompressor
+import java.io.FileNotFoundException
+import java.io.IOException
+import java.net.HttpURLConnection
+import java.net.URL
+import java.util.UUID
+
+object Utils {
+    private const val TAG = "react-native-compessor"
+    var compressorExports: MutableMap<String, VideoCompressTask> = HashMap()
+    @JvmStatic
+    fun generateCacheFilePath(extension: String, reactContext: ReactApplicationContext): String {
+        val outputDir = reactContext.cacheDir
+        return String.format("%s/%s.$extension", outputDir.path, UUID.randomUUID().toString())
+    }
+
+    @JvmStatic
+    fun compressVideo(srcPath: String, destinationPath: String, resultWidth: Int, resultHeight: Int, videoBitRate: Float, uuid: String,progressDivider:Int, promise: Promise, reactContext: ReactApplicationContext) {
+        val currentVideoCompression = intArrayOf(0)
+        try {
+            val export = VideoCompressor.convertVideo(srcPath, destinationPath, resultWidth, resultHeight, videoBitRate.toInt(), object : VideoCompressor.ProgressListener {
+                override fun onStart() {
+                    //convert start
+                }
+
+                override fun onFinish(result: Boolean) {
+                    val fileUrl = "file://$destinationPath"
+                    //convert finish,result(true is success,false is fail)
+                    promise.resolve(fileUrl)
+                    MediaCache.removeCompletedImagePath(fileUrl)
+                }
+
+                override fun onError(errorMessage: String) {
+                    if (errorMessage == "class java.lang.AssertionError") {
+                        promise.resolve("file://$srcPath")
+                    } else {
+                        promise.reject("Compression has canncelled")
+                    }
+                }
+
+                override fun onProgress(percent: Float) {
+                    val roundProgress = Math.round(percent)
+                    if (progressDivider==0||(roundProgress % progressDivider == 0 && roundProgress > currentVideoCompression[0])) {
+                      EventEmitterHandler.emitVideoCompressProgress((percent / 100).toDouble(),uuid)
+                        currentVideoCompression[0] = roundProgress
+                    }
+                }
+            })
+            compressorExports[uuid] = export
+        } catch (ex: Exception) {
+            promise.reject(ex)
+        } finally {
+            currentVideoCompression[0] = 0
+        }
+    }
+
+    fun cancelCompressionHelper(uuid: String) {
+        try {
+            val export = compressorExports[uuid]
+            export!!.cancel(true)
+        } catch (ex: Exception) {
+        }
+    }
+
+    @JvmStatic
+    fun getFileSizeFromURL(urlString: String?): Int {
+        val url: URL
+        var conn: HttpURLConnection? = null
+        return try {
+            url = URL(urlString)
+            conn = url.openConnection() as HttpURLConnection
+            conn.requestMethod = "HEAD"
+            conn!!.inputStream
+            conn.contentLength
+        } catch (e: IOException) {
+            throw RuntimeException(e)
+        } finally {
+            conn?.disconnect()
+        }
+    }
+
+    @JvmStatic
+    fun getRealPath(fileUrl: String?, reactContext: ReactApplicationContext, vararg args: Any?): String? {
+        var fileUrl = fileUrl
+        if (fileUrl!!.startsWith("content://")) {
+            try {
+                val uri = Uri.parse(fileUrl)
+                fileUrl = RealPathUtil.getRealPath(reactContext, uri)
+            } catch (ex: Exception) {
+                Log.d(TAG, " Please see this issue: https://github.com/numandev1/react-native-compressor/issues/25")
+            }
+        } else if (fileUrl.startsWith("http://") || fileUrl.startsWith("https://")) {
+            val uuid: String = if (args.size > 0) args[0].toString() else ""
+            val progressDivider: Int = if (args.size > 1) args[1] as Int else 0
+            fileUrl = Downloader.downloadMediaWithProgress(fileUrl, uuid,progressDivider, reactContext)
+            Log.d(TAG, "getRealPath: $fileUrl")
+        }
+        return fileUrl
+    }
+
+
+
+  fun getFileSize(filePath: String, promise: Promise, reactContext:ReactApplicationContext) {
+    var filePath: String? = filePath
+    if (filePath!!.startsWith("http://") || filePath.startsWith("https://")) {
+      promise.resolve(getFileSizeFromURL(filePath))
+    } else {
+      filePath = getRealPath(filePath, reactContext)
+      val uri = Uri.parse(filePath)
+      val contentResolver = reactContext.contentResolver
+      val fileSize = getLength(uri, contentResolver)
+      if (fileSize >= 0) {
+        promise.resolve(fileSize.toString())
+      } else {
+        promise.resolve("")
+      }
+    }
+  }
+
+  fun getLength(uri: Uri, contentResolver: ContentResolver): Long {
+    var assetFileDescriptor: AssetFileDescriptor? = null
+    try {
+      assetFileDescriptor = contentResolver.openAssetFileDescriptor(uri, "r")
+    } catch (e: FileNotFoundException) {
+      // Do nothing
+    }
+    val length = assetFileDescriptor?.length ?: -1L
+    if (length != -1L) {
+      return length
+    }
+    return if (ContentResolver.SCHEME_CONTENT == uri.scheme) {
+      val cursor = contentResolver.query(uri, arrayOf(OpenableColumns.SIZE), null, null, null)
+      if (cursor != null) {
+        try {
+          val sizeIndex = cursor.getColumnIndex(OpenableColumns.SIZE)
+          if (sizeIndex != -1 && cursor.moveToFirst()) {
+            return try {
+              cursor.getLong(sizeIndex)
+            } catch (ignored: Throwable) {
+              -1L
+            }
+          }
+        } finally {
+          cursor.close()
+        }
+      }
+      -1L
+    } else {
+      -1L
+    }
+  }
+}

package/android/src/main/java/com/reactnativecompressor/Utils/createVideoThumbnail.kt

@@ -0,0 +1,158 @@
+package com.reactnativecompressor.Utils
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.media.MediaMetadataRetriever
+import android.net.Uri
+import android.os.Build
+import android.text.TextUtils
+import android.webkit.URLUtil
+import androidx.annotation.RequiresApi
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.GuardedResultAsyncTask
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.io.OutputStream
+import java.io.UnsupportedEncodingException
+import java.lang.ref.WeakReference
+import java.net.URLDecoder
+import java.util.UUID
+
+
+class CreateVideoThumbnail(private val reactContext: ReactApplicationContext) {
+    @ReactMethod
+    fun create(fileUrl:String,options: ReadableMap, promise: Promise) {
+        ProcessDataTask(reactContext,fileUrl, promise, options).execute()
+    }
+
+    private class ProcessDataTask(reactContext: ReactContext,private val filePath:String, private val promise: Promise, private val options: ReadableMap) : GuardedResultAsyncTask<ReadableMap?>(reactContext.exceptionHandler) {
+        private val weakContext: WeakReference<Context>
+
+        init {
+            weakContext = WeakReference(reactContext.applicationContext)
+        }
+
+        @RequiresApi(Build.VERSION_CODES.N)
+        override fun doInBackgroundGuarded(): ReadableMap? {
+            val format = "jpeg"
+            val cacheName = if (options.hasKey("cacheName")) options.getString("cacheName") else ""
+            val thumbnailDir = weakContext.get()!!.applicationContext.cacheDir.absolutePath + "/thumbnails"
+            val cacheDir = createDirIfNotExists(thumbnailDir)
+            if (!TextUtils.isEmpty(cacheName)) {
+                val file = File(thumbnailDir, "$cacheName.$format")
+                if (file.exists()) {
+                    val map = Arguments.createMap()
+                    map.putString("path", "file://" + file.absolutePath)
+                    val image = BitmapFactory.decodeFile(file.absolutePath)
+                    map.putDouble("size", image.byteCount.toDouble())
+                    map.putString("mime", "image/$format")
+                    map.putDouble("width", image.width.toDouble())
+                    map.putDouble("height", image.height.toDouble())
+                    return map
+                }
+            }
+            val headers: Map<String, String> = if (options.hasKey("headers")) options.getMap("headers")!!.toHashMap() as Map<String, String> else HashMap<String, String>()
+            val fileName = if (TextUtils.isEmpty(cacheName)) "thumb-" + UUID.randomUUID().toString() else "$cacheName.$format"
+            var fOut: OutputStream? = null
+            try {
+                val file = File(cacheDir, fileName)
+                val context = weakContext.get()
+                val image = getBitmapAtTime(context, filePath, 0, headers)
+                file.createNewFile()
+                fOut = FileOutputStream(file)
+
+                // 100 means no compression, the lower you go, the stronger the compression
+                image.compress(Bitmap.CompressFormat.JPEG, 90, fOut)
+                fOut.flush()
+                fOut.close()
+
+                val map = Arguments.createMap()
+                map.putString("path", "file://" + file.absolutePath)
+                map.putDouble("size", image.byteCount.toDouble())
+                map.putString("mime", "image/$format")
+                map.putDouble("width", image.width.toDouble())
+                map.putDouble("height", image.height.toDouble())
+                return map
+            } catch (e: Exception) {
+                promise.reject("CreateVideoThumbnail_ERROR", e)
+            }
+            return null
+        }
+
+        override fun onPostExecuteGuarded(readableArray: ReadableMap?) {
+            promise.resolve(readableArray)
+        }
+    }
+
+    companion object {
+        // delete previously added files one by one untill requred space is available
+        fun clearCache(cacheDir: String?,promise:Promise, reactContext: ReactApplicationContext) {
+          val cacheDirectory=cacheDir?.takeIf { it.isNotEmpty() } ?:"/thumbnails"
+          val thumbnailDir: String = reactContext.getApplicationContext().getCacheDir().getAbsolutePath() + cacheDirectory
+          val thumbnailDirFile = createDirIfNotExists(thumbnailDir)
+
+          if (thumbnailDirFile != null) {
+            val files = thumbnailDirFile.listFiles()
+
+            // Loop through the files and delete them
+            if (files != null) {
+              for (file in files) {
+                if (file.isFile) {
+                  file.delete()
+                }
+              }
+            }
+          }
+          promise.resolve("done")
+        }
+
+        private fun createDirIfNotExists(path: String): File {
+            val dir = File(path)
+            if (dir.exists()) {
+                return dir
+            }
+            try {
+                dir.mkdirs()
+                // Add .nomedia to hide the thumbnail directory from gallery
+                val noMedia = File(path, ".nomedia")
+                noMedia.createNewFile()
+            } catch (e: IOException) {
+                e.printStackTrace()
+            }
+            return dir
+        }
+
+        private fun getBitmapAtTime(context: Context?, filePath: String?, time: Int, headers: Map<String, String>): Bitmap {
+            val retriever = MediaMetadataRetriever()
+            if (URLUtil.isFileUrl(filePath)) {
+                val decodedPath: String?
+                decodedPath = try {
+                    URLDecoder.decode(filePath, "UTF-8")
+                } catch (e: UnsupportedEncodingException) {
+                    filePath
+                }
+                retriever.setDataSource(decodedPath!!.replace("file://", ""))
+            } else if (filePath!!.contains("content://")) {
+                retriever.setDataSource(context, Uri.parse(filePath))
+            } else {
+                check(Build.VERSION.SDK_INT >= 14) { "Remote videos aren't supported on sdk_version < 14" }
+                retriever.setDataSource(filePath, headers)
+            }
+            val image = retriever.getFrameAtTime((time * 1000).toLong(), MediaMetadataRetriever.OPTION_CLOSEST_SYNC)
+            try {
+                retriever.release()
+            } catch (e: IOException) {
+                throw RuntimeException(e)
+            }
+            checkNotNull(image) { "File doesn't exist or not supported" }
+            return image
+        }
+    }
+}