[WIP][Android] Avoid using ArralyList for fields creation

platform/jvm/capture/src/main/kotlin/io/bitdrift/capture/LoggerImpl.kt

@@ -569,27 +569,36 @@ internal class LoggerImpl(
         val throwableFieldCount = if (hasThrowable) 2 else 0
         val totalSize = fieldsSize + throwableFieldCount
 
-        val keys = ArrayList<String>(totalSize)
-        val values = ArrayList<String>(totalSize)
+        val keys = arrayOfNulls<String>(totalSize)
+        val values = arrayOfNulls<String>(totalSize)
+        var index = 0
 
         fields?.forEach { (key, value) ->
             @Suppress("SENSELESS_COMPARISON")
             if (key != null && value != null) {
-                keys.add(key)
-                values.add(value)
+                keys[index] = key
+                values[index] = value
+                index++
             }
         }
 
-        throwable?.let {
-            keys.add("_error")
-            values.add(it.javaClass.name.orEmpty())
-            keys.add("_error_details")
-            values.add(it.message.orEmpty())
+        if (hasThrowable) {
+            val error = throwable
+            keys[index] = "_error"
+            values[index] = error?.javaClass?.name.orEmpty()
+            index++
+            keys[index] = "_error_details"
+            values[index] = error?.message.orEmpty()
+            index++
+        }
+
+        if (index == totalSize) {
+            return ArrayFields(keys.requireNoNulls(), values.requireNoNulls())
         }
 
         return ArrayFields(
-            keys.toTypedArray(),
-            values.toTypedArray(),
+            keys.copyOf(index).requireNoNulls(),
+            values.copyOf(index).requireNoNulls(),
         )
     }
 

platform/jvm/capture/src/main/kotlin/io/bitdrift/capture/network/HTTPHeaders.kt

@@ -15,15 +15,26 @@ private val DISALLOWED_HEADER_KEYS = setOf<String>("authorization", "proxy-autho
 internal object HTTPHeaders {
     fun normalizeHeaders(headers: Map<String, String>): ArrayFields {
         if (headers.isEmpty()) return ArrayFields.EMPTY
-        val keys = mutableListOf<String>()
-        val values = mutableListOf<String>()
+
+        val keys = arrayOfNulls<String>(headers.size)
+        val values = arrayOfNulls<String>(headers.size)
+        var index = 0
+
         headers.forEach { (key, value) ->
             if (!DISALLOWED_HEADER_KEYS.contains(key.lowercase())) {
-                keys.add("$HEADERS_FIELD_KEY_PREFIX.$key")
-                values.add(value)
+                keys[index] = "$HEADERS_FIELD_KEY_PREFIX.$key"
+                values[index] = value
+                index++
             }
         }
-        if (keys.isEmpty()) return ArrayFields.EMPTY
-        return ArrayFields(keys.toTypedArray(), values.toTypedArray())
+
+        if (index == 0) return ArrayFields.EMPTY
+        if (index == headers.size) {
+            return ArrayFields(keys.requireNoNulls(), values.requireNoNulls())
+        }
+        return ArrayFields(
+            keys.copyOf(index).requireNoNulls(),
+            values.copyOf(index).requireNoNulls(),
+        )
     }
 }

platform/jvm/capture/src/main/kotlin/io/bitdrift/capture/providers/FieldProvider.kt

@@ -177,12 +177,14 @@ internal fun combineJniFields(
     val totalSize = stringArrayFields.size + binaryFields.size
     if (totalSize == 0) return emptyArray()
 
-    val result = ArrayList<Field>(totalSize)
+    val result = arrayOfNulls<Field>(totalSize)
     for (i in 0 until stringArrayFields.size) {
-        result.add(Field(stringArrayFields.keys[i], FieldValue.StringField(stringArrayFields.values[i])))
+        result[i] = Field(stringArrayFields.keys[i], FieldValue.StringField(stringArrayFields.values[i]))
     }
-    result.addAll(binaryFields)
-    return result.toTypedArray()
+    for (i in binaryFields.indices) {
+        result[stringArrayFields.size + i] = binaryFields[i]
+    }
+    return result.requireNoNulls()
 }
 
 /**

platform/jvm/capture/src/main/kotlin/io/bitdrift/capture/providers/MetadataProvider.kt

@@ -27,23 +27,32 @@ internal class MetadataProvider(
     private fun fields(fieldProviders: List<FieldProvider>): Array<Field> {
         if (fieldProviders.isEmpty()) return emptyArray()
 
-        val result = mutableListOf<Field>()
-        for (fieldProvider in fieldProviders) {
+        val collectedMaps = arrayOfNulls<Map<String, String>>(fieldProviders.size)
+        var totalSize = 0
+
+        for (i in fieldProviders.indices) {
             try {
-                val providedFields = fieldProvider()
-                for ((key, value) in providedFields) {
-                    result.add(Field(key, FieldValue.StringField(value)))
-                }
+                val providedFields = fieldProviders[i]()
+                collectedMaps[i] = providedFields
+                totalSize += providedFields.size
             } catch (e: Throwable) {
-                // We cannot log to our logger as we are in the middle of processing
-                // a log and want to avoid an infinite cycle of logs.
-                // The issue is not with our code but customer's provider.
-                val message = "Field Provider \"${fieldProvider.javaClass.name}\" threw an exception"
+                val message = "Field Provider \"${fieldProviders[i].javaClass.name}\" threw an exception"
                 errorLog(message, e)
                 errorHandler.handleError(message, e)
             }
         }
-        if (result.isEmpty()) return emptyArray()
-        return result.toTypedArray()
+
+        if (totalSize == 0) return emptyArray()
+
+        val result = arrayOfNulls<Field>(totalSize)
+        var index = 0
+        for (map in collectedMaps) {
+            if (map != null) {
+                for ((key, value) in map) {
+                    result[index++] = Field(key, FieldValue.StringField(value))
+                }
+            }
+        }
+        return result.requireNoNulls()
     }
 }