stream-chat-expo 9.0.2-beta.2 → 9.1.0

package/android/build.gradle

@@ -29,8 +29,9 @@ if (isNewArchitectureEnabled()) {
 def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["StreamChatExpo_" + name]).toInteger()
 }
+def canonicalProjectDir = projectDir.getCanonicalFile()
 def localSharedNativeRootDir = new File(projectDir, "src/main/java/com/streamchatreactnative/shared")
-def sharedNativeRootDir = new File(projectDir, "../../shared-native/android")
+def sharedNativeRootDir = new File(canonicalProjectDir, "../../shared-native/android")
 def hasNativeSources = { File dir ->
   dir.exists() && !fileTree(dir).matching { include "**/*.kt"; include "**/*.java" }.files.isEmpty()
 }
@@ -88,10 +89,10 @@ tasks.register("syncSharedShimmerSources") {
   outputs.upToDateWhen { false }
   doLast {
     def sourceRootDir = null
-    if (hasNativeSources(localSharedNativeRootDir)) {
-      sourceRootDir = localSharedNativeRootDir
-    } else if (hasNativeSources(sharedNativeRootDir)) {
+    if (hasNativeSources(sharedNativeRootDir)) {
       sourceRootDir = sharedNativeRootDir
+    } else if (hasNativeSources(localSharedNativeRootDir)) {
+      sourceRootDir = localSharedNativeRootDir
     }
 
     if (sourceRootDir == null) {

package/android/src/main/java/com/streamchatexpo/StreamChatExpoPackage.java

@@ -14,12 +14,17 @@ import java.util.List;
 import java.util.Map;
 
 public class StreamChatExpoPackage extends TurboReactPackage {
+  private static final String STREAM_MULTIPART_UPLOADER_MODULE = "StreamMultipartUploader";
   private static final String STREAM_VIDEO_THUMBNAIL_MODULE = "StreamVideoThumbnail";
 
   @Nullable
   @Override
   public NativeModule getModule(String name, ReactApplicationContext reactContext) {
-    if (name.equals(STREAM_VIDEO_THUMBNAIL_MODULE) && BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+    if (name.equals(STREAM_MULTIPART_UPLOADER_MODULE)) {
+      return createNewArchModule("com.streamchatexpo.StreamMultipartUploaderModule", reactContext);
+    }
+
+    if (name.equals(STREAM_VIDEO_THUMBNAIL_MODULE)) {
       return createNewArchModule("com.streamchatexpo.StreamVideoThumbnailModule", reactContext);
     }
 
@@ -30,7 +35,17 @@ public class StreamChatExpoPackage extends TurboReactPackage {
   public ReactModuleInfoProvider getReactModuleInfoProvider() {
     return () -> {
       final Map<String, ReactModuleInfo> moduleInfos = new HashMap<>();
-      boolean isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED;
+      moduleInfos.put(
+              STREAM_MULTIPART_UPLOADER_MODULE,
+              new ReactModuleInfo(
+                      STREAM_MULTIPART_UPLOADER_MODULE,
+                      STREAM_MULTIPART_UPLOADER_MODULE,
+                      false, // canOverrideExistingModule
+                      false, // needsEagerInit
+                      false, // hasConstants
+                      false, // isCxxModule
+                      true // isTurboModule
+              ));
       moduleInfos.put(
               STREAM_VIDEO_THUMBNAIL_MODULE,
               new ReactModuleInfo(
@@ -40,7 +55,7 @@ public class StreamChatExpoPackage extends TurboReactPackage {
                       false, // needsEagerInit
                       false, // hasConstants
                       false, // isCxxModule
-                      isTurboModule // isTurboModule
+                      true // isTurboModule
               ));
       return moduleInfos;
     };

package/android/src/main/java/com/streamchatreactnative/shared/upload/StreamMultipartUploadFileRequestBody.kt

@@ -0,0 +1,25 @@
+package com.streamchatreactnative.shared.upload
+
+import android.content.Context
+import okhttp3.RequestBody
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okio.BufferedSink
+import okio.source
+
+class StreamMultipartUploadFileRequestBody(
+  private val context: Context,
+  private val filePart: StreamMultipartFilePart,
+) : RequestBody() {
+  private val resolvedMimeType = StreamMultipartUploadSourceResolver.mimeType(context, filePart)
+  private val resolvedContentLength = StreamMultipartUploadSourceResolver.contentLength(context, filePart.uri)
+
+  override fun contentLength(): Long = resolvedContentLength ?: -1L
+
+  override fun contentType() = resolvedMimeType.toMediaTypeOrNull()
+
+  override fun writeTo(sink: BufferedSink) {
+    StreamMultipartUploadSourceResolver.openInputStream(context, filePart.uri).use { inputStream ->
+      sink.writeAll(inputStream.source())
+    }
+  }
+}

package/android/src/main/java/com/streamchatreactnative/shared/upload/StreamMultipartUploadModels.kt

@@ -0,0 +1,39 @@
+package com.streamchatreactnative.shared.upload
+
+data class StreamMultipartUploadRequest(
+  val headers: Map<String, String>,
+  val method: String,
+  val parts: List<StreamMultipartUploadPart>,
+  val progress: StreamMultipartUploadProgressOptions?,
+  val timeoutMs: Long?,
+  val uploadId: String,
+  val url: String,
+)
+
+sealed interface StreamMultipartUploadPart {
+  val fieldName: String
+}
+
+data class StreamMultipartFilePart(
+  override val fieldName: String,
+  val fileName: String,
+  val mimeType: String?,
+  val uri: String,
+) : StreamMultipartUploadPart
+
+data class StreamMultipartTextPart(
+  override val fieldName: String,
+  val value: String,
+) : StreamMultipartUploadPart
+
+data class StreamMultipartUploadProgressOptions(
+  val count: Int?,
+  val intervalMs: Long?,
+)
+
+data class StreamMultipartUploadResponse(
+  val body: String,
+  val headers: Map<String, String>,
+  val status: Int,
+  val statusText: String?,
+)

package/android/src/main/java/com/streamchatreactnative/shared/upload/StreamMultipartUploadProgress.kt

@@ -0,0 +1,80 @@
+package com.streamchatreactnative.shared.upload
+
+import android.os.SystemClock
+import okhttp3.RequestBody
+import okio.Buffer
+import okio.BufferedSink
+import okio.ForwardingSink
+import okio.Sink
+import okio.buffer
+import kotlin.math.floor
+
+class StreamMultipartUploadProgressThrottler(
+  options: StreamMultipartUploadProgressOptions?,
+  private val onProgress: (loaded: Long, total: Long?) -> Unit,
+) {
+  private val intervalMs = (options?.intervalMs ?: 16L).coerceIn(16L, 1_000L)
+  private val count = (options?.count ?: 20).coerceIn(1, 100)
+  private var emittedBuckets = -1
+  private var lastEventAtMs = 0L
+
+  fun dispatch(loaded: Long, total: Long?) {
+    val now = SystemClock.elapsedRealtime()
+    val isTerminal = total != null && total >= 0 && loaded >= total
+
+    if (isTerminal) {
+      onProgress(loaded, total)
+      return
+    }
+
+    val passesInterval = now - lastEventAtMs >= intervalMs
+    val passesCount =
+      if (count > 0 && total != null && total > 0) {
+        val nextBucket = floor((loaded.toDouble() / total.toDouble()) * count.toDouble()).toInt()
+        if (nextBucket > emittedBuckets) {
+          emittedBuckets = nextBucket
+          true
+        } else {
+          false
+        }
+      } else {
+        true
+      }
+
+    if (!passesInterval || !passesCount) {
+      return
+    }
+
+    lastEventAtMs = now
+    onProgress(loaded, total)
+  }
+}
+
+class StreamMultipartUploadProgressRequestBody(
+  private val requestBody: RequestBody,
+  private val throttler: StreamMultipartUploadProgressThrottler,
+) : RequestBody() {
+  private val resolvedContentLength by lazy { requestBody.contentLength().takeIf { it >= 0L } }
+
+  override fun contentLength(): Long = requestBody.contentLength()
+
+  override fun contentType() = requestBody.contentType()
+
+  override fun writeTo(sink: BufferedSink) {
+    val countingSink =
+      object : ForwardingSink(sink as Sink) {
+        private var bytesWritten = 0L
+
+        override fun write(source: Buffer, byteCount: Long) {
+          super.write(source, byteCount)
+
+          bytesWritten += byteCount
+          throttler.dispatch(bytesWritten, resolvedContentLength)
+        }
+      }
+
+    val bufferedSink = countingSink.buffer()
+    requestBody.writeTo(bufferedSink)
+    bufferedSink.flush()
+  }
+}

package/android/src/main/java/com/streamchatreactnative/shared/upload/StreamMultipartUploadRequestParser.kt

@@ -0,0 +1,110 @@
+package com.streamchatreactnative.shared.upload
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+
+object StreamMultipartUploadRequestParser {
+  fun parse(
+    uploadId: String,
+    url: String,
+    method: String,
+    headers: ReadableArray,
+    parts: ReadableArray,
+    progress: ReadableMap?,
+    timeoutMs: Double?,
+  ): StreamMultipartUploadRequest {
+    return StreamMultipartUploadRequest(
+      headers = headers.toStringMap(),
+      method = method,
+      parts = parts.toUploadParts(),
+      progress = progress?.toProgressOptions(),
+      timeoutMs = timeoutMs?.toLong()?.takeIf { it > 0L },
+      uploadId = uploadId,
+      url = url,
+    )
+  }
+
+  private fun ReadableArray.toUploadParts(): List<StreamMultipartUploadPart> {
+    val parsedParts = mutableListOf<StreamMultipartUploadPart>()
+
+    for (index in 0 until size()) {
+      val part = getMap(index) ?: throw IllegalArgumentException("Missing multipart part at index $index")
+      val fieldName =
+        part.getString("fieldName") ?: throw IllegalArgumentException("Multipart part $index is missing fieldName")
+      val kind =
+        part.getString("kind") ?: throw IllegalArgumentException("Multipart part $index is missing kind")
+
+      when (kind) {
+        "file" -> {
+          val uri =
+            part.getString("uri") ?: throw IllegalArgumentException("Multipart file part $index is missing uri")
+          val fileName =
+            part.getString("fileName")
+              ?: throw IllegalArgumentException("Multipart file part $index is missing fileName")
+
+          parsedParts += StreamMultipartFilePart(
+            fieldName = fieldName,
+            fileName = fileName,
+            mimeType = part.getString("mimeType"),
+            uri = uri,
+          )
+        }
+
+        "text" -> {
+          val value =
+            part.getString("value") ?: throw IllegalArgumentException("Multipart text part $index is missing value")
+          parsedParts += StreamMultipartTextPart(fieldName = fieldName, value = value)
+        }
+
+        else -> throw IllegalArgumentException("Unsupported multipart part kind: $kind")
+      }
+    }
+
+    if (parsedParts.none { it is StreamMultipartFilePart }) {
+      throw IllegalArgumentException("Multipart upload must contain at least one file part")
+    }
+
+    return parsedParts
+  }
+
+  private fun ReadableArray.toStringMap(): Map<String, String> {
+    val parsed = mutableMapOf<String, String>()
+
+    for (index in 0 until size()) {
+      val header = getMap(index) ?: throw IllegalArgumentException("Missing multipart header at index $index")
+      val name =
+        header.getString("name") ?: throw IllegalArgumentException("Multipart header $index is missing name")
+      if (header.getType("value") == ReadableType.Null) {
+        continue
+      }
+      val value =
+        header.getString("value")
+          ?: header.getDynamic("value").asString()
+          ?: throw IllegalArgumentException("Multipart header $index is missing value")
+      parsed[name] = value
+    }
+
+    return parsed
+  }
+
+  private fun ReadableMap.toProgressOptions(): StreamMultipartUploadProgressOptions {
+    val count =
+      if (hasKey("count") && !isNull("count")) {
+        getDouble("count").toInt().coerceIn(1, 100)
+      } else {
+        null
+      }
+    val intervalMs =
+      if (hasKey("intervalMs") && !isNull("intervalMs")) {
+        getDouble("intervalMs").toLong().coerceIn(16L, 1_000L)
+      } else {
+        null
+      }
+
+    return StreamMultipartUploadProgressOptions(
+      count = count,
+      intervalMs = intervalMs,
+    )
+  }
+}

package/android/src/main/java/com/streamchatreactnative/shared/upload/StreamMultipartUploadSourceResolver.kt

@@ -0,0 +1,99 @@
+package com.streamchatreactnative.shared.upload
+
+import android.content.Context
+import android.database.Cursor
+import android.net.Uri
+import android.provider.OpenableColumns
+import java.io.File
+import java.io.FileInputStream
+import java.io.InputStream
+import java.net.URLConnection
+
+object StreamMultipartUploadSourceResolver {
+  fun contentLength(context: Context, uriString: String): Long? {
+    val uri = normalizeUri(uriString)
+
+    return when (uri.scheme?.lowercase()) {
+      null, "file" -> {
+        val file = toFile(uri, uriString)
+        if (!file.exists()) {
+          throw IllegalArgumentException("File does not exist for upload: $uriString")
+        }
+        file.length()
+      }
+
+      "content" -> {
+        context.contentResolver.openAssetFileDescriptor(uri, "r")?.use { descriptor ->
+          descriptor.length.takeIf { it >= 0L }
+        } ?: queryLongColumn(context, uri, OpenableColumns.SIZE)
+      }
+
+      else -> throw IllegalArgumentException("Unsupported upload URI scheme: ${uri.scheme}")
+    }
+  }
+
+  fun mimeType(context: Context, part: StreamMultipartFilePart): String {
+    val explicitMimeType = part.mimeType?.takeIf { it.isNotBlank() }
+    if (explicitMimeType != null) {
+      return explicitMimeType
+    }
+
+    val uri = normalizeUri(part.uri)
+    val contentResolverMime = context.contentResolver.getType(uri)
+    if (!contentResolverMime.isNullOrBlank()) {
+      return contentResolverMime
+    }
+
+    return URLConnection.guessContentTypeFromName(part.fileName) ?: "application/octet-stream"
+  }
+
+  fun openInputStream(context: Context, uriString: String): InputStream {
+    val uri = normalizeUri(uriString)
+
+    return when (uri.scheme?.lowercase()) {
+      null, "file" -> FileInputStream(toFile(uri, uriString))
+      "content" ->
+        context.contentResolver.openInputStream(uri)
+          ?: throw IllegalArgumentException("Failed to open content URI for upload: $uriString")
+      else -> throw IllegalArgumentException("Unsupported upload URI scheme: ${uri.scheme}")
+    }
+  }
+
+  private fun normalizeUri(uriString: String): Uri {
+    if (uriString.startsWith("/")) {
+      return Uri.fromFile(File(uriString))
+    }
+
+    val parsed = Uri.parse(uriString)
+
+    if (parsed.scheme.isNullOrBlank()) {
+      return Uri.fromFile(File(uriString))
+    }
+
+    return parsed
+  }
+
+  private fun queryLongColumn(context: Context, uri: Uri, columnName: String): Long? {
+    val projection = arrayOf(columnName)
+    val cursor: Cursor =
+      context.contentResolver.query(uri, projection, null, null, null) ?: return null
+
+    cursor.use {
+      if (!it.moveToFirst()) {
+        return null
+      }
+
+      val columnIndex = it.getColumnIndex(columnName)
+      if (columnIndex == -1 || it.isNull(columnIndex)) {
+        return null
+      }
+
+      return it.getLong(columnIndex)
+    }
+  }
+
+  private fun toFile(uri: Uri, original: String): File {
+    val path = uri.path ?: original
+    return File(path)
+  }
+}

package/android/src/main/java/com/streamchatreactnative/shared/upload/StreamMultipartUploader.kt

@@ -0,0 +1,138 @@
+package com.streamchatreactnative.shared.upload
+
+import android.content.Context
+import okhttp3.Call
+import okhttp3.MultipartBody
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody
+import okhttp3.ResponseBody
+import java.io.InterruptedIOException
+import java.io.IOException
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.TimeUnit
+
+object StreamMultipartUploader {
+  private val client: OkHttpClient = OkHttpClient.Builder().retryOnConnectionFailure(true).build()
+  private const val MAX_RESPONSE_BODY_BYTES = 1_048_576L
+  private val cancelledUploadIds = ConcurrentHashMap.newKeySet<String>()
+  private val inFlightCalls = ConcurrentHashMap<String, Call>()
+
+  fun cancel(uploadId: String) {
+    cancelledUploadIds.add(uploadId)
+    inFlightCalls.remove(uploadId)?.cancel()
+  }
+
+  fun upload(
+    context: Context,
+    request: StreamMultipartUploadRequest,
+    onProgress: (loaded: Long, total: Long?) -> Unit,
+  ): StreamMultipartUploadResponse {
+    if (cancelledUploadIds.contains(request.uploadId)) {
+      cancelledUploadIds.remove(request.uploadId)
+      throw InterruptedIOException("Request aborted")
+    }
+
+    val httpRequest = createRequest(context, request, onProgress)
+    val call = clientFor(request).newCall(httpRequest)
+    val existingCall = inFlightCalls.putIfAbsent(request.uploadId, call)
+    if (existingCall != null) {
+      throw IllegalStateException("Upload already in flight for id: ${request.uploadId}")
+    }
+
+    try {
+      if (cancelledUploadIds.remove(request.uploadId)) {
+        call.cancel()
+      }
+
+      call.execute().use { response ->
+        return StreamMultipartUploadResponse(
+          body = readResponseBody(response.body),
+          headers =
+            response.headers.names().associateWith { name ->
+              response.headers(name).joinToString(", ")
+            },
+          status = response.code,
+          statusText = response.message,
+        )
+      }
+    } finally {
+      inFlightCalls.remove(request.uploadId, call)
+      cancelledUploadIds.remove(request.uploadId)
+    }
+  }
+
+  private fun clientFor(request: StreamMultipartUploadRequest): OkHttpClient {
+    val timeoutMs = request.timeoutMs ?: return client
+    return client.newBuilder()
+      .callTimeout(timeoutMs, TimeUnit.MILLISECONDS)
+      .build()
+  }
+
+  private fun readResponseBody(body: ResponseBody?): String {
+    if (body == null) {
+      return ""
+    }
+
+    val source = body.source()
+    source.request(MAX_RESPONSE_BODY_BYTES + 1L)
+    val buffer = source.buffer
+
+    if (buffer.size > MAX_RESPONSE_BODY_BYTES) {
+      throw IOException("Upload response body exceeded $MAX_RESPONSE_BODY_BYTES bytes")
+    }
+
+    return buffer.clone().readString(Charsets.UTF_8)
+  }
+
+  private fun createMultipartBody(
+    context: Context,
+    request: StreamMultipartUploadRequest,
+    onProgress: (loaded: Long, total: Long?) -> Unit,
+  ): RequestBody {
+    val multipartBodyBuilder = MultipartBody.Builder().setType(MultipartBody.FORM)
+
+    request.parts.forEach { part ->
+      when (part) {
+        is StreamMultipartFilePart -> {
+          multipartBodyBuilder.addFormDataPart(
+            part.fieldName,
+            part.fileName,
+            StreamMultipartUploadFileRequestBody(context, part),
+          )
+        }
+
+        is StreamMultipartTextPart -> {
+          multipartBodyBuilder.addFormDataPart(part.fieldName, part.value)
+        }
+      }
+    }
+
+    val multipartBody = multipartBodyBuilder.build()
+    val throttler = StreamMultipartUploadProgressThrottler(request.progress, onProgress)
+
+    return StreamMultipartUploadProgressRequestBody(multipartBody, throttler)
+  }
+
+  private fun createRequest(
+    context: Context,
+    request: StreamMultipartUploadRequest,
+    onProgress: (loaded: Long, total: Long?) -> Unit,
+  ): Request {
+    val requestBuilder = Request.Builder().url(request.url)
+
+    request.headers.forEach { (key, value) ->
+      if (
+        key.equals("Content-Type", ignoreCase = true) ||
+          key.equals("Content-Length", ignoreCase = true)
+      ) {
+        return@forEach
+      }
+
+      requestBuilder.header(key, value)
+    }
+
+    val body = createMultipartBody(context, request, onProgress)
+    return requestBuilder.method(request.method, body).build()
+  }
+}

package/android/src/newarch/com/streamchatexpo/StreamMultipartUploaderModule.kt

@@ -0,0 +1,122 @@
+package com.streamchatexpo
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.streamchatreactnative.shared.upload.StreamMultipartUploadRequestParser
+import com.streamchatreactnative.shared.upload.StreamMultipartUploader
+import java.util.concurrent.LinkedBlockingQueue
+import java.util.concurrent.ThreadPoolExecutor
+import java.util.concurrent.TimeUnit
+
+class StreamMultipartUploaderModule(
+  reactContext: ReactApplicationContext,
+) : NativeStreamMultipartUploaderSpec(reactContext) {
+  override fun getName(): String = NAME
+
+  override fun addListener(eventType: String) = Unit
+
+  override fun removeListeners(count: Double) = Unit
+
+  override fun cancelUpload(uploadId: String, promise: Promise) {
+    StreamMultipartUploader.cancel(uploadId)
+    promise.resolve(null)
+  }
+
+  override fun uploadMultipart(
+    uploadId: String,
+    url: String,
+    method: String,
+    headers: ReadableArray,
+    parts: ReadableArray,
+    progress: ReadableMap?,
+    timeoutMs: Double?,
+    promise: Promise,
+  ) {
+    val request =
+      try {
+        StreamMultipartUploadRequestParser.parse(
+          uploadId = uploadId,
+          url = url,
+          method = method,
+          headers = headers,
+          parts = parts,
+          progress = progress,
+          timeoutMs = timeoutMs,
+        )
+      } catch (error: Throwable) {
+        promise.reject("stream_multipart_upload_error", error.message, error)
+        return
+      }
+
+    try {
+      executor.execute {
+        try {
+          val response =
+            StreamMultipartUploader.upload(reactApplicationContext, request) { loaded, total ->
+              emitProgress(uploadId, loaded, total)
+            }
+
+          val payload = Arguments.createMap().apply {
+            putString("body", response.body)
+            putArray("headers", Arguments.createArray().apply {
+              response.headers.forEach { (name, value) ->
+                pushMap(
+                  Arguments.createMap().apply {
+                    putString("name", name)
+                    putString("value", value)
+                  },
+                )
+              }
+            })
+            putDouble("status", response.status.toDouble())
+            putString("statusText", response.statusText)
+          }
+          promise.resolve(payload)
+        } catch (error: Throwable) {
+          promise.reject("stream_multipart_upload_error", error.message, error)
+        }
+      }
+    } catch (error: Throwable) {
+      promise.reject("stream_multipart_upload_error", error.message, error)
+    }
+  }
+
+  private fun emitProgress(uploadId: String, loaded: Long, total: Long?) {
+    UiThreadUtil.runOnUiThread {
+      val payload = Arguments.createMap().apply {
+        putDouble("loaded", loaded.toDouble())
+        if (total != null) {
+          putDouble("total", total.toDouble())
+        } else {
+          putNull("total")
+        }
+        putString("uploadId", uploadId)
+      }
+
+      reactApplicationContext
+        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+        .emit(PROGRESS_EVENT_NAME, payload)
+    }
+  }
+
+  companion object {
+    const val NAME = "StreamMultipartUploader"
+    private const val PROGRESS_EVENT_NAME = "streamMultipartUploadProgress"
+    private val maxConcurrentUploads = Runtime.getRuntime().availableProcessors().coerceIn(2, 4)
+    private val executor =
+      ThreadPoolExecutor(
+        maxConcurrentUploads,
+        maxConcurrentUploads,
+        30L,
+        TimeUnit.SECONDS,
+        LinkedBlockingQueue(64),
+      ).apply {
+        allowCoreThreadTimeOut(true)
+      }
+  }
+}