react-native-compressor 1.8.0 → 1.8.2

package/README.md

@@ -68,6 +68,7 @@ We should use **react-native-compressor** instead of **FFmpeg** because **react-
   - [Audio](#audio)
   - [Background Upload](#background-upload)
   - [Download File](#download)
+  - [Create Video Thumbnail and Clear Cache](#create-video-thumbnail-and-clear-cache)
 
 * [Other Utilities](#api)
   - [Background Upload](#background-upload-1)
@@ -84,7 +85,7 @@ yarn add react-native-compressor
 
 ### [New Architecture (Turbo Module)](https://reactnative.dev/docs/new-architecture-intro) Supported
 
-you can give feedback on [Discord channel](https://discord.gg/dtYzk8sp)
+you can give feedback on [Discord channel](https://discord.gg/6Wx8Em8KAN)
 
 ### Managed Expo
 
@@ -299,6 +300,16 @@ const downloadFileUrl = await download(url, (progress) => {
 });
 ```
 
+### Video Thumbnail
+
+```js
+import { createVideoThumbnail, clearCache } from 'react-native-compressor';
+
+const thumbnail = await createVideoThumbnail(videoUri);
+
+await clearCache(); // this will clear cache of thumbnails cache directory
+```
+
 # API
 
 ## Image
@@ -421,6 +432,16 @@ type FileSystemUploadOptions = (
 
 - ##### download: ( fileUrl: string, downloadProgress?: (progress: number) => void, progressDivider?: number ) => Promise< string >
 
+### Create Video Thumbnail and Clear Cache
+
+- #### createVideoThumbnail( fileUrl: string, options: {header:Object} ): Promise<{ path: string;size: number; mime: string; width: number; height: number; }>
+
+  it will save the thumbnail of the video into the cache directory and return the thumbnail URI which you can display
+
+- #### clearCache(cacheDir?: string): Promise< string >
+
+  it will clear the cache that was created from createVideoThumbnail, in future this clear cache will be totally customized
+
 ### Get Metadata Of Video
 
 if you want to get metadata of video than you can use this function

package/android/build.gradle

@@ -1,7 +1,7 @@
 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["Compressor_kotlinVersion"]
-  
+
   repositories {
     google()
     mavenCentral()
@@ -110,8 +110,12 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4"
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4"
+  implementation "com.googlecode.mp4parser:isoparser:1.0.6"
+
   implementation 'io.github.lizhangqu:coreprogress:1.0.2'
-  implementation 'com.github.numandev1:VideoCompressor:1a262bba37'
 }
 
 if (isNewArchitectureEnabled()) {

package/android/src/main/java/com/reactnativecompressor/Audio/AudioCompressor.kt

@@ -11,7 +11,7 @@ import android.media.MediaMuxer
 import android.os.Build
 import android.util.Log
 import androidx.annotation.RequiresApi
-import numan.dev.videocompressor.codecinputsurface.CodecInputSurface
+import com.reactnativecompressor.Video.VideoCompressor.video.OutputSurface
 import java.io.File
 import java.io.IOException
 import java.nio.ByteBuffer
@@ -24,7 +24,7 @@ class AudioCompressor {
     private var mEncoder: MediaCodec? = null
     private var mDecoder: MediaCodec? = null
     private var mTrackIndex = 0
-    private var mInputSurface: CodecInputSurface? = null
+    private var mInputSurface: OutputSurface? = null
 
     // bit rate, in bits per second
     private var mBitRate = -1

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

@@ -8,6 +8,7 @@ import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableMap
 import com.reactnativecompressor.Audio.AudioMain
 import com.reactnativecompressor.Image.ImageMain
+import com.reactnativecompressor.Utils.CreateVideoThumbnailClass
 import com.reactnativecompressor.Utils.Downloader
 import com.reactnativecompressor.Utils.EventEmitterHandler
 import com.reactnativecompressor.Utils.Uploader
@@ -20,6 +21,7 @@ class CompressorModule(private val reactContext: ReactApplicationContext) : Comp
   private val imageMain: ImageMain = ImageMain(reactContext)
   private val videoMain: VideoMain = VideoMain(reactContext)
   private val audioMain: AudioMain = AudioMain(reactContext)
+  private val videoThumbnail: CreateVideoThumbnailClass = CreateVideoThumbnailClass(reactContext)
 
   override fun initialize() {
     super.initialize()
@@ -147,6 +149,16 @@ class CompressorModule(private val reactContext: ReactApplicationContext) : Comp
     }
   }
 
+  @ReactMethod
+  override fun createVideoThumbnail(fileUrl:String, options:ReadableMap, promise:Promise) {
+    videoThumbnail.create(fileUrl,options,promise)
+  }
+
+  @ReactMethod
+  override fun clearCache(cacheDir:String?, promise:Promise) {
+    CreateVideoThumbnailClass.clearCache(cacheDir, promise, reactContext)
+  }
+
     @ReactMethod
     override fun addListener(eventName: String) {
     }

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

@@ -32,17 +32,17 @@ object Uploader {
       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 headerIterator = options?.headers?.keySetIterator()
+        while (headerIterator?.hasNextKey() == true) {
+          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 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.
@@ -52,7 +52,7 @@ object Uploader {
             }
 
             override fun onUIProgressChanged(numBytes: Long, totalBytes: Long, percent: Float, speed: Float) {
-                EventEmitterHandler.sendUploadProgressEvent(numBytes,totalBytes,options.uuid)
+                EventEmitterHandler.sendUploadProgressEvent(numBytes,totalBytes,options?.uuid)
                 Log.d(TAG, "=============start===============")
                 Log.d(TAG, "numBytes:$numBytes")
                 Log.d(TAG, "totalBytes:$totalBytes")

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

@@ -7,8 +7,8 @@ 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 com.reactnativecompressor.Video.VideoCompressor.CompressionListener
+import com.reactnativecompressor.Video.VideoCompressor.VideoCompressorClass
 import java.io.FileNotFoundException
 import java.io.IOException
 import java.net.HttpURLConnection
@@ -17,7 +17,7 @@ import java.util.UUID
 
 object Utils {
     private const val TAG = "react-native-compessor"
-    var compressorExports: MutableMap<String, VideoCompressTask> = HashMap()
+    var compressorExports: MutableMap<String, VideoCompressorClass?> = HashMap()
     @JvmStatic
     fun generateCacheFilePath(extension: String, reactContext: ReactApplicationContext): String {
         val outputDir = reactContext.cacheDir
@@ -26,48 +26,54 @@ object Utils {
 
     @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
+      val currentVideoCompression = intArrayOf(0)
+      val videoCompressorClass: VideoCompressorClass? = VideoCompressorClass(reactContext);
+      compressorExports[uuid] = videoCompressorClass
+      videoCompressorClass?.start(srcPath, destinationPath, resultWidth, resultHeight, videoBitRate.toInt(),
+          listener = object : CompressionListener {
+            override fun onProgress(index: Int, percent: Float) {
+              if (percent <= 100)
+              {
+                val roundProgress = Math.round(percent)
+                if (progressDivider==0||(roundProgress % progressDivider == 0 && roundProgress > currentVideoCompression[0])) {
+                  EventEmitterHandler.emitVideoCompressProgress((percent / 100).toDouble(),uuid)
+                  currentVideoCompression[0] = roundProgress
                 }
+              }
+            }
 
-                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 onStart(index: Int) {
 
-                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
-        }
+            override fun onSuccess(index: Int, size: Long, path: String?) {
+              val fileUrl = "file://$destinationPath"
+              //convert finish,result(true is success,false is fail)
+              promise.resolve(fileUrl)
+              MediaCache.removeCompletedImagePath(fileUrl)
+              currentVideoCompression[0] = 0
+              compressorExports[uuid]=null
+            }
+
+            override fun onFailure(index: Int, failureMessage: String) {
+              Log.wtf("failureMessage", failureMessage)
+              currentVideoCompression[0] = 0
+            }
+
+            override fun onCancelled(index: Int) {
+              Log.wtf("TAG", "compression has been cancelled")
+              // make UI changes, cleanup, etc
+              currentVideoCompression[0] = 0
+            }
+          },
+        )
     }
 
     fun cancelCompressionHelper(uuid: String) {
         try {
             val export = compressorExports[uuid]
-            export!!.cancel(true)
+            export?.cancel()
+          compressorExports[uuid]=null
         } catch (ex: Exception) {
         }
     }

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 CreateVideoThumbnailClass(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
+        }
+    }
+}

package/android/src/main/java/com/reactnativecompressor/Video/VideoCompressor/CompressionInterface.kt

@@ -0,0 +1,73 @@
+package com.reactnativecompressor.Video.VideoCompressor
+
+import androidx.annotation.MainThread
+import androidx.annotation.WorkerThread
+
+/**
+ * Interface for listening to video compression events.
+ */
+interface CompressionListener {
+  /**
+   * Called when video compression starts.
+   *
+   * @param index The index of the video being compressed.
+   */
+  @MainThread
+  fun onStart(index: Int)
+
+  /**
+   * Called when video compression succeeds.
+   *
+   * @param index The index of the video that was compressed.
+   * @param size The size of the compressed video.
+   * @param path The path to the compressed video file (nullable).
+   */
+  @MainThread
+  fun onSuccess(index: Int, size: Long, path: String?)
+
+  /**
+   * Called when video compression fails.
+   *
+   * @param index The index of the video that failed to compress.
+   * @param failureMessage A message describing the reason for the failure.
+   */
+  @MainThread
+  fun onFailure(index: Int, failureMessage: String)
+
+  /**
+   * Called to report the progress of video compression.
+   *
+   * @param index The index of the video being compressed.
+   * @param percent The progress percentage (0.0 to 100.0).
+   */
+  @WorkerThread
+  fun onProgress(index: Int, percent: Float)
+
+  /**
+   * Called when video compression is canceled.
+   *
+   * @param index The index of the video that was canceled.
+   */
+  @WorkerThread
+  fun onCancelled(index: Int)
+}
+
+/**
+ * Interface for tracking the progress of video compression.
+ */
+interface CompressionProgressListener {
+  /**
+   * Called when the progress of video compression changes.
+   *
+   * @param index The index of the video being compressed.
+   * @param percent The current progress percentage (0.0 to 100.0).
+   */
+  fun onProgressChanged(index: Int, percent: Float)
+
+  /**
+   * Called when the compression progress is canceled.
+   *
+   * @param index The index of the video compression that was canceled.
+   */
+  fun onProgressCancelled(index: Int)
+}

package/android/src/main/java/com/reactnativecompressor/Video/VideoCompressor/VideoCompressorClass.kt

@@ -0,0 +1,148 @@
+package com.reactnativecompressor.Video.VideoCompressor
+
+import android.database.Cursor
+import android.net.Uri
+import android.provider.MediaStore
+import com.facebook.react.bridge.ReactApplicationContext
+import com.reactnativecompressor.Video.VideoCompressor.compressor.Compressor.compressVideo
+import com.reactnativecompressor.Video.VideoCompressor.compressor.Compressor.isRunning
+import com.reactnativecompressor.Video.VideoCompressor.video.Result
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.io.File
+
+class VideoCompressorClass(private val context: ReactApplicationContext) {
+  private var job: Job? = null
+
+  @JvmOverloads
+  fun start(
+    srcPath: String,
+    destPath: String,
+    outputWidth: Int,
+    outputHeight: Int,
+    bitrate: Int,
+    listener: CompressionListener,
+  ) {
+    val uris = mutableListOf<Uri>()
+    val uri = Uri.parse(srcPath)
+    uris.add(uri)
+    val isStreamable: Boolean = false
+    doVideoCompression(
+      uris,
+      isStreamable,
+      outputWidth,
+      outputHeight,
+      bitrate,
+      listener,
+      destPath
+    )
+  }
+
+  fun cancel() {
+    job?.cancel()
+    isRunning = false
+  }
+
+  private fun doVideoCompression(
+    uris: List<Uri>,
+    isStreamable: Boolean,
+    outputWidth: Int,
+    outputHeight: Int,
+    bitrate: Int,
+    listener: CompressionListener,
+    destPath: String
+  ) {
+    var streamableFile: File? = null
+    for (i in uris.indices) {
+      job = CoroutineScope(Dispatchers.Main).launch {
+        val desFile = File(destPath)
+
+        if (isStreamable)
+          streamableFile = File(destPath)
+
+        desFile?.let {
+          isRunning = true
+          listener.onStart(i)
+          val result = startCompression(
+            i,
+            uris[i],
+            desFile.path,
+            streamableFile?.path,
+            outputWidth,
+            outputHeight,
+            bitrate,
+            listener,
+          )
+
+          // Runs in Main(UI) Thread
+          if (result.success) {
+            listener.onSuccess(i, result.size, result.path)
+          } else {
+            listener.onFailure(i, result.failureMessage ?: "An error has occurred!")
+          }
+        }
+      }
+    }
+  }
+
+  private suspend fun startCompression(
+    index: Int,
+    srcUri: Uri,
+    destPath: String,
+    streamableFile: String? = null,
+    outputWidth: Int,
+    outputHeight: Int,
+    bitrate: Int,
+    listener: CompressionListener,
+  ): Result = withContext(Dispatchers.Default) {
+    return@withContext compressVideo(
+      index,
+      context,
+      srcUri,
+      destPath,
+      streamableFile,
+      outputWidth,
+      outputHeight,
+      bitrate,
+      object : CompressionProgressListener {
+        override fun onProgressChanged(index: Int, percent: Float) {
+          listener.onProgress(index, percent)
+        }
+
+        override fun onProgressCancelled(index: Int) {
+          listener.onCancelled(index)
+        }
+      },
+    )
+  }
+
+  private fun getMediaPath(uri: Uri): String {
+    val scheme = uri.scheme
+    if (scheme == null || scheme == "file") {
+      // The URI is a file URI, so use the path directly.
+      return uri.path ?: ""
+    } else {
+      // The URI is not a file URI, so try to copy the content to a file.
+      val resolver = context.contentResolver
+      val projection = arrayOf(MediaStore.Video.Media.DATA)
+      var cursor: Cursor? = null
+      try {
+        cursor = resolver.query(uri, projection, null, null, null)
+        if (cursor != null && cursor.moveToFirst()) {
+          val columnIndex = cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DATA)
+          return cursor.getString(columnIndex)
+        }
+      } catch (e: Exception) {
+        // Handle the exception as needed.
+      } finally {
+        cursor?.close()
+      }
+    }
+
+    // If all else fails, return an empty string or handle the error accordingly.
+    return ""
+  }
+}