chore(release): 5.1.2 [skip ci]

## [5.1.2](https://github.com/revanced/revanced-patcher/compare/v5.1.1...v5.1.2) (2022-09-29)

### Bug Fixes

* check dependencies for resource patches ([9c07ffc](9c07ffcc7a))
* use instruction index instead of strings list index for `StringMatch` ([843e62a](843e62ad29))

CHANGELOG.md

@@ -1,3 +1,25 @@
+## [5.1.2](https://github.com/revanced/revanced-patcher/compare/v5.1.1...v5.1.2) (2022-09-29)
+
+
+### Bug Fixes
+
+* check dependencies for resource patches ([9c07ffc](https://github.com/revanced/revanced-patcher/commit/9c07ffcc7af9f088426528561f4321c5cc6b5b15))
+* use instruction index instead of strings list index for `StringMatch` ([843e62a](https://github.com/revanced/revanced-patcher/commit/843e62ad290ee0a707be9322ee943921da3ea420))
+
+## [5.1.1](https://github.com/revanced/revanced-patcher/compare/v5.1.0...v5.1.1) (2022-09-26)
+
+
+### Performance Improvements
+
+* decode resources only when necessary ([3ba4be2](https://github.com/revanced/revanced-patcher/commit/3ba4be240bf0a424e4bbfbaca9605644fda0984e))
+
+# [5.1.0](https://github.com/revanced/revanced-patcher/compare/v5.0.1...v5.1.0) (2022-09-26)
+
+
+### Features
+
+* RwLock for opening files in `DomFileEditor` ([db4348c](https://github.com/revanced/revanced-patcher/commit/db4348c4faf51bfe29678baacfbe76ba645ec0b9))
+
 ## [5.0.1](https://github.com/revanced/revanced-patcher/compare/v5.0.0...v5.0.1) (2022-09-23)
 
 

gradle.properties

@@ -1,2 +1,2 @@
 kotlin.code.style = official
-version = 5.0.1
+version = 5.1.2

src/main/kotlin/app/revanced/patcher/Patcher.kt

@@ -1,7 +1,6 @@
 package app.revanced.patcher
 
 import app.revanced.patcher.data.Data
-import app.revanced.patcher.data.PackageMetadata
 import app.revanced.patcher.data.impl.findIndexed
 import app.revanced.patcher.extensions.PatchExtensions.dependencies
 import app.revanced.patcher.extensions.PatchExtensions.deprecated
@@ -47,84 +46,30 @@ private val NAMER = BasicDexFileNamer()
 class Patcher(private val options: PatcherOptions) {
     private val logger = options.logger
     private val opcodes: Opcodes
-
+    private var resourceDecodingMode = ResourceDecodingMode.MANIFEST_ONLY
     val data: PatcherData
 
     companion object {
         @JvmStatic
         val version = VersionReader.read()
+        private fun BuildOptions.setBuildOptions(options: PatcherOptions) {
+            this.aaptPath = options.aaptPath
+            this.useAapt2 = true
+            this.frameworkFolderLocation = options.frameworkFolderLocation
+        }
     }
 
     init {
-        val extInputFile = ExtFile(options.inputFile)
-        try {
-            val outDir = File(options.resourceCacheDirectory)
-            if (outDir.exists()) {
-                logger.info("Deleting existing resource cache directory")
-                outDir.deleteRecursively()
-            }
-            outDir.mkdirs()
+        logger.info("Reading dex files")
+        // read dex files
+        val dexFile = MultiDexIO.readDexFile(true, options.inputFile, NAMER, null, null)
+        // get the opcodes
+        opcodes = dexFile.opcodes
+        // finally create patcher data
+        data = PatcherData(dexFile.classes.toMutableList(), options.resourceCacheDirectory)
 
-            val androlib = Androlib(BuildOptions().also { it.setBuildOptions(options) })
-            val resourceTable = androlib.getResTable(extInputFile, true)
-
-            val packageMetadata = PackageMetadata()
-
-            if (options.patchResources) {
-                logger.info("Decoding resources")
-
-                // decode resources to cache directory
-                androlib.decodeManifestWithResources(extInputFile, outDir, resourceTable)
-                androlib.decodeResourcesFull(extInputFile, outDir, resourceTable)
-
-                // read additional metadata from the resource table
-                packageMetadata.metaInfo.usesFramework = UsesFramework().also { framework ->
-                    framework.ids = resourceTable.listFramePackages().map { it.id }.sorted()
-                }
-
-                packageMetadata.metaInfo.doNotCompress = buildList {
-                    androlib.recordUncompressedFiles(extInputFile, this)
-                }
-
-            } else {
-                logger.info("Only decoding AndroidManifest.xml because resource patching is disabled")
-
-                // create decoder for the resource table
-                val decoder = ResAttrDecoder()
-                decoder.currentPackage = ResPackage(resourceTable, 0, null)
-
-                // create xml parser with the decoder
-                val axmlParser = AXmlResourceParser()
-                axmlParser.attrDecoder = decoder
-
-                // parse package information with the decoder and parser which will set required values in the resource table
-                // instead of decodeManifest another more low level solution can be created to make it faster/better
-                XmlPullStreamDecoder(
-                    axmlParser, AndrolibResources().resXmlSerializer
-                ).decodeManifest(
-                    extInputFile.directory.getFileInput("AndroidManifest.xml"), nullOutputStream
-                )
-            }
-
-            packageMetadata.packageName = resourceTable.currentResPackage.name
-            packageMetadata.packageVersion = resourceTable.versionInfo.versionName
-            packageMetadata.metaInfo.versionInfo = resourceTable.versionInfo
-            packageMetadata.metaInfo.sdkInfo = resourceTable.sdkInfo
-
-            logger.info("Reading dex files")
-
-            // read dex files
-            val dexFile = MultiDexIO.readDexFile(true, options.inputFile, NAMER, null, null)
-            // get the opcodes
-            opcodes = dexFile.opcodes
-
-            // finally create patcher data
-            data = PatcherData(
-                dexFile.classes.toMutableList(), options.resourceCacheDirectory, packageMetadata
-            )
-        } finally {
-            extInputFile.close()
-        }
+        // decode manifest file
+        decodeResources(ResourceDecodingMode.MANIFEST_ONLY)
     }
 
     /**
@@ -175,48 +120,51 @@ class Patcher(private val options: PatcherOptions) {
         val metaInfo = packageMetadata.metaInfo
         var resourceFile: File? = null
 
-        if (options.patchResources) {
-            val cacheDirectory = ExtFile(options.resourceCacheDirectory)
-            try {
-                val androlibResources = AndrolibResources().also { resources ->
-                    resources.buildOptions = BuildOptions().also { buildOptions ->
-                        buildOptions.setBuildOptions(options)
-                        buildOptions.isFramework = metaInfo.isFrameworkApk
-                        buildOptions.resourcesAreCompressed = metaInfo.compressionType
-                        buildOptions.doNotCompress = metaInfo.doNotCompress
+        when (resourceDecodingMode) {
+            ResourceDecodingMode.FULL -> {
+                val cacheDirectory = ExtFile(options.resourceCacheDirectory)
+                try {
+                    val androlibResources = AndrolibResources().also { resources ->
+                        resources.buildOptions = BuildOptions().also { buildOptions ->
+                            buildOptions.setBuildOptions(options)
+                            buildOptions.isFramework = metaInfo.isFrameworkApk
+                            buildOptions.resourcesAreCompressed = metaInfo.compressionType
+                            buildOptions.doNotCompress = metaInfo.doNotCompress
+                        }
+
+                        resources.setSdkInfo(metaInfo.sdkInfo)
+                        resources.setVersionInfo(metaInfo.versionInfo)
+                        resources.setSharedLibrary(metaInfo.sharedLibrary)
+                        resources.setSparseResources(metaInfo.sparseResources)
                     }
 
-                    resources.setSdkInfo(metaInfo.sdkInfo)
-                    resources.setVersionInfo(metaInfo.versionInfo)
-                    resources.setSharedLibrary(metaInfo.sharedLibrary)
-                    resources.setSparseResources(metaInfo.sparseResources)
-                }
+                    val manifestFile = cacheDirectory.resolve("AndroidManifest.xml")
 
-                val manifestFile = cacheDirectory.resolve("AndroidManifest.xml")
+                    ResXmlPatcher.fixingPublicAttrsInProviderAttributes(manifestFile)
 
-                ResXmlPatcher.fixingPublicAttrsInProviderAttributes(manifestFile)
+                    val aaptFile = cacheDirectory.resolve("aapt_temp_file")
 
-                val aaptFile = cacheDirectory.resolve("aapt_temp_file")
+                    // delete if it exists
+                    Files.deleteIfExists(aaptFile.toPath())
 
-                // delete if it exists
-                Files.deleteIfExists(aaptFile.toPath())
+                    val resDirectory = cacheDirectory.resolve("res")
+                    val includedFiles = metaInfo.usesFramework.ids.map { id ->
+                        androlibResources.getFrameworkApk(
+                            id, metaInfo.usesFramework.tag
+                        )
+                    }.toTypedArray()
 
-                val resDirectory = cacheDirectory.resolve("res")
-                val includedFiles = metaInfo.usesFramework.ids.map { id ->
-                    androlibResources.getFrameworkApk(
-                        id, metaInfo.usesFramework.tag
+                    logger.info("Compiling resources")
+                    androlibResources.aaptPackage(
+                        aaptFile, manifestFile, resDirectory, null, null, includedFiles
                     )
-                }.toTypedArray()
 
-                logger.info("Compiling resources")
-                androlibResources.aaptPackage(
-                    aaptFile, manifestFile, resDirectory, null, null, includedFiles
-                )
-
-                resourceFile = aaptFile
-            } finally {
-                cacheDirectory.close()
+                    resourceFile = aaptFile
+                } finally {
+                    cacheDirectory.close()
+                }
             }
+            else -> logger.info("Not compiling resources because resource patching is not required")
         }
 
         logger.trace("Creating new dex file")
@@ -242,7 +190,9 @@ class Patcher(private val options: PatcherOptions) {
         return PatcherResult(
             dexFiles.map {
                 app.revanced.patcher.util.dex.DexFile(it.key, it.value.readAt(0))
-            }, metaInfo.doNotCompress?.toList(), resourceFile
+            },
+            metaInfo.doNotCompress?.toList(),
+            resourceFile
         )
     }
 
@@ -251,16 +201,29 @@ class Patcher(private val options: PatcherOptions) {
      * @param patches [Patch]es The patches to add.
      */
     fun addPatches(patches: Iterable<Class<out Patch<Data>>>) {
-        for (patch in patches) {
-            val needsVersion = patch.sincePatcherVersion
-            if (needsVersion != null && needsVersion > version) {
-                logger.error("Patch '${patch.patchName}' requires Patcher version $needsVersion or higher")
-                logger.error("Current Patcher version is $version")
-                logger.warn("Skipping '${patch.patchName}'!")
-                continue // TODO: continue or halt/throw?
-            }
+        /**
+         * Fill the cache with the instances of the [Patch]es for later use.
+         * Note: Dependencies of the [Patch] will be cached as well.
+         */
+        fun Class<out Patch<Data>>.isResource() {
+            this.also {
+                if (!ResourcePatch::class.java.isAssignableFrom(it)) return@also
+                // set the mode to decode all resources before running the patches
+                resourceDecodingMode = ResourceDecodingMode.FULL
+            }.dependencies?.forEach { it.java.isResource() }
         }
-        data.patches.addAll(patches)
+
+        data.patches.addAll(
+            patches.onEach(Class<out Patch<Data>>::isResource).onEach { patch ->
+                val needsVersion = patch.sincePatcherVersion
+                if (needsVersion != null && needsVersion > version) {
+                    logger.error("Patch '${patch.patchName}' requires Patcher version $needsVersion or higher")
+                    logger.error("Current Patcher version is $version")
+                    logger.warn("Skipping '${patch.patchName}'!")
+                    return@onEach // TODO: continue or halt/throw?
+                }
+            }
+        )
     }
 
     /**
@@ -286,49 +249,120 @@ class Patcher(private val options: PatcherOptions) {
         }
 
         // recursively apply all dependency patches
-        patch.dependencies?.forEach {
-            val patchDependency = it.java
-
-            val result = applyPatch(patchDependency, appliedPatches)
+        patch.dependencies?.forEach { dependencyClass ->
+            val dependency = dependencyClass.java
 
+            val result = applyPatch(dependency, appliedPatches)
             if (result.isSuccess()) return@forEach
 
             val error = result.error()!!
             val errorMessage = error.cause ?: error.message
-            return PatchResultError("'$patchName' depends on '${patchDependency.patchName}' but the following error was raised: $errorMessage")
+            return PatchResultError("'$patchName' depends on '${dependency.patchName}' but the following error was raised: $errorMessage")
+        }
+
+        patch.deprecated?.let { (reason, replacement) ->
+            logger.warn("'$patchName' is deprecated, reason: $reason")
+            if (replacement != null) logger.warn("Use '${replacement.java.patchName}' instead")
         }
 
         val patchInstance = patch.getDeclaredConstructor().newInstance()
 
-        // if the current patch is a resource patch but resource patching is disabled, return an error
-        val isResourcePatch = patchInstance is ResourcePatch
-        if (!options.patchResources && isResourcePatch) {
-            return PatchResultError("'$patchName' is a resource patch, but resource patching is disabled")
-        }
-
-        patch.deprecated?.let { (reason, replacement) ->
-            logger.warn("'$patchName' is deprecated: $reason")
-            if (replacement != null) logger.warn("Use '${replacement.java.patchName}' instead")
-        }
-
-        // TODO: find a solution for this
+        val isResourcePatch = ResourcePatch::class.java.isAssignableFrom(patch)
+        // TODO: implement this in a more polymorphic way
         val data = if (isResourcePatch) {
             data.resourceData
         } else {
-            val bytecodeData = data.bytecodeData
-            (patchInstance as BytecodePatch).fingerprints?.resolve(bytecodeData, bytecodeData.classes.internalClasses)
-            bytecodeData
+            data.bytecodeData.also { data ->
+                (patchInstance as BytecodePatch).fingerprints?.resolve(
+                    data,
+                    data.classes.internalClasses
+                )
+            }
         }
 
         logger.trace("Executing '$patchName' of type: ${if (isResourcePatch) "resource" else "bytecode"}")
 
         return try {
-            val result = patchInstance.execute(data)
-            appliedPatches[patchName] = AppliedPatch(patchInstance, result.isSuccess())
-            result
+            patchInstance.execute(data).also {
+                appliedPatches[patchName] = AppliedPatch(patchInstance, it.isSuccess())
+            }
         } catch (e: Exception) {
-            appliedPatches[patchName] = AppliedPatch(patchInstance, false)
-            PatchResultError(e)
+            PatchResultError(e).also {
+                appliedPatches[patchName] = AppliedPatch(patchInstance, false)
+            }
+        }
+    }
+
+    /**
+     * Decode resources for the patcher.
+     *
+     * @param mode The [ResourceDecodingMode] to use when decoding.
+     */
+    private fun decodeResources(mode: ResourceDecodingMode) {
+        val extInputFile = ExtFile(options.inputFile)
+        try {
+            val androlib = Androlib(BuildOptions().also { it.setBuildOptions(options) })
+            val resourceTable = androlib.getResTable(extInputFile, true)
+            when (mode) {
+                ResourceDecodingMode.FULL -> {
+                    val outDir = File(options.resourceCacheDirectory)
+                    if (outDir.exists()) {
+                        logger.info("Deleting existing resource cache directory")
+                        if (!outDir.deleteRecursively()) {
+                            logger.error("Failed to delete existing resource cache directory")
+                        }
+                    }
+                    outDir.mkdirs()
+
+                    logger.info("Decoding resources")
+
+                    // decode resources to cache directory
+                    androlib.decodeManifestWithResources(extInputFile, outDir, resourceTable)
+                    androlib.decodeResourcesFull(extInputFile, outDir, resourceTable)
+
+                    // read additional metadata from the resource table
+                    data.packageMetadata.let { metadata ->
+                        metadata.metaInfo.usesFramework = UsesFramework().also { framework ->
+                            framework.ids = resourceTable.listFramePackages().map { it.id }.sorted()
+                        }
+
+                        // read files to not compress
+                        metadata.metaInfo.doNotCompress = buildList {
+                            androlib.recordUncompressedFiles(extInputFile, this)
+                        }
+                    }
+
+                }
+                ResourceDecodingMode.MANIFEST_ONLY -> {
+                    logger.info("Decoding AndroidManifest.xml only, because resources are not needed")
+
+                    // create decoder for the resource table
+                    val decoder = ResAttrDecoder()
+                    decoder.currentPackage = ResPackage(resourceTable, 0, null)
+
+                    // create xml parser with the decoder
+                    val axmlParser = AXmlResourceParser()
+                    axmlParser.attrDecoder = decoder
+
+                    // parse package information with the decoder and parser which will set required values in the resource table
+                    // instead of decodeManifest another more low level solution can be created to make it faster/better
+                    XmlPullStreamDecoder(
+                        axmlParser, AndrolibResources().resXmlSerializer
+                    ).decodeManifest(
+                        extInputFile.directory.getFileInput("AndroidManifest.xml"), nullOutputStream
+                    )
+                }
+            }
+
+            // read of the resourceTable which is created by reading the manifest file
+            data.packageMetadata.let { metadata ->
+                metadata.packageName = resourceTable.currentResPackage.name
+                metadata.packageVersion = resourceTable.versionInfo.versionName
+                metadata.metaInfo.versionInfo = resourceTable.versionInfo
+                metadata.metaInfo.sdkInfo = resourceTable.sdkInfo
+            }
+        } finally {
+            extInputFile.close()
         }
     }
 
@@ -338,6 +372,9 @@ class Patcher(private val options: PatcherOptions) {
      * @return A pair of the name of the [Patch] and its [PatchResult].
      */
     fun applyPatches(stopOnError: Boolean = false) = sequence {
+        // prevent from decoding the manifest twice if it is not needed
+        if (resourceDecodingMode == ResourceDecodingMode.FULL) decodeResources(ResourceDecodingMode.FULL)
+
         logger.trace("Applying all patches")
 
         val appliedPatches = LinkedHashMap<String, AppliedPatch>() // first is name
@@ -364,6 +401,21 @@ class Patcher(private val options: PatcherOptions) {
             }
         }
     }
+
+    /**
+     * The type of decoding the resources.
+     */
+    private enum class ResourceDecodingMode {
+        /**
+         * Decode all resources.
+         */
+        FULL,
+
+        /**
+         * Decode the manifest file only.
+         */
+        MANIFEST_ONLY,
+    }
 }
 
 /**
@@ -372,10 +424,4 @@ class Patcher(private val options: PatcherOptions) {
  * @param patchInstance The instance of the [Patch] that was applied.
  * @param success The result of the [Patch].
  */
-internal data class AppliedPatch(val patchInstance: Patch<Data>, val success: Boolean)
-
-private fun BuildOptions.setBuildOptions(options: PatcherOptions) {
-    this.aaptPath = options.aaptPath
-    this.useAapt2 = true
-    this.frameworkFolderLocation = options.frameworkFolderLocation
-}
+internal data class AppliedPatch(val patchInstance: Patch<Data>, val success: Boolean)

src/main/kotlin/app/revanced/patcher/PatcherData.kt

@@ -9,10 +9,10 @@ import org.jf.dexlib2.iface.ClassDef
 import java.io.File
 
 data class PatcherData(
-    internal val internalClasses: MutableList<ClassDef>,
-    internal val resourceCacheDirectory: String,
-    val packageMetadata: PackageMetadata
+    val internalClasses: MutableList<ClassDef>,
+    val resourceCacheDirectory: String,
 ) {
+    val packageMetadata = PackageMetadata()
     internal val patches = mutableListOf<Class<out Patch<Data>>>()
     internal val bytecodeData = BytecodeData(internalClasses)
     internal val resourceData = ResourceData(File(resourceCacheDirectory))

src/main/kotlin/app/revanced/patcher/PatcherOptions.kt

@@ -8,7 +8,6 @@ import java.io.File
  * Options for the [Patcher].
  * @param inputFile The input file (usually an apk file).
  * @param resourceCacheDirectory Directory to cache resources.
- * @param patchResources Weather to use the resource patcher. Resources will still need to be decoded.
  * @param aaptPath Optional path to a custom aapt binary.
  * @param frameworkFolderLocation Optional path to a custom framework folder.
  * @param logger Custom logger implementation for the [Patcher].
@@ -16,7 +15,6 @@ import java.io.File
 data class PatcherOptions(
     internal val inputFile: File,
     internal val resourceCacheDirectory: String,
-    internal val patchResources: Boolean = false,
     internal val aaptPath: String = "",
     internal val frameworkFolderLocation: String? = null,
     internal val logger: Logger = NopLogger

src/main/kotlin/app/revanced/patcher/data/impl/ResourceData.kt

@@ -30,10 +30,12 @@ class ResourceData(private val resourceCacheDirectory: File) : Data, Iterable<Fi
 }
 
 /**
- * DomFileEditor is a wrapper for a file that can be edited as a dom document.
+ * Wrapper for a file that can be edited as a dom document.
+ * Note: This constructor does not check for locks to the file when writing. Use the secondary constructor.
  *
  * @param inputStream the input stream to read the xml file from.
- * @param outputStream the output stream to write the xml file to. If null, the file will not be written.
+ * @param outputStream the output stream to write the xml file to. If null, the file will be read only.
+ *
  */
 class DomFileEditor internal constructor(
     private val inputStream: InputStream,
@@ -41,6 +43,7 @@ class DomFileEditor internal constructor(
 ) : Closeable {
     // path to the xml file to unlock the resource when closing the editor
     private var filePath: String? = null
+    private var closed: Boolean = false
 
     /**
      * The document of the xml file
@@ -48,37 +51,53 @@ class DomFileEditor internal constructor(
     val file: Document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(inputStream)
         .also(Document::normalize)
 
+
     // lazily open an output stream
     // this is required because when constructing a DomFileEditor the output stream is created along with the input stream, which is not allowed
     // the workaround is to lazily create the output stream. This way it would be used after the input stream is closed, which happens in the constructor
     constructor(file: File) : this(file.inputStream(), lazy { file.outputStream() }) {
+        // increase the lock
+        locks.merge(file.path, 1, Integer::sum)
         filePath = file.path
-
-        // prevent sharing mutability of the same file between multiple instances of DomFileEditor
-        if (locks.contains(filePath))
-            throw IllegalStateException("Can not create a DomFileEditor for that file because it is already locked by another instance of DomFileEditor.")
-        locks.add(filePath!!)
     }
 
+    /**
+     * Closes the editor. Write backs and decreases the lock count.
+     * Note: Will not write back to the file if the file is still locked.
+     */
     override fun close() {
+        if (closed) return
+
         inputStream.close()
 
         // if the output stream is not null, do not close it
         outputStream?.let {
-            val result = StreamResult(it.value)
-            TransformerFactory.newInstance().newTransformer().transform(DOMSource(file), result)
+            // prevent writing to same file, if it is being locked
+            // isLocked will be false if the editor was created through a stream
+            val isLocked = filePath?.let { path ->
+                val isLocked = locks[path]!! > 1
+                // decrease the lock count if the editor was opened for a file
+                locks.merge(path, -1, Integer::sum)
+                isLocked
+            } ?: false
 
-            it.value.close()
+            // if unlocked, write back to the file
+            if (!isLocked) {
+                it.value.use { stream ->
+                    val result = StreamResult(stream)
+                    TransformerFactory.newInstance().newTransformer().transform(DOMSource(file), result)
+                }
+
+                it.value.close()
+                return
+            }
         }
 
-        // remove the lock, if it exists
-        filePath?.let {
-            locks.remove(it)
-        }
+        closed = true
     }
 
     private companion object {
-        // list of locked file paths
-        val locks = mutableListOf<String>()
+        // map of concurrent open files
+        val locks = mutableMapOf<String, Int>()
     }
 }

src/main/kotlin/app/revanced/patcher/fingerprint/method/impl/MethodFingerprint.kt

@@ -102,17 +102,17 @@ abstract class MethodFingerprint(
 
                             val stringsList = methodFingerprint.strings.toMutableList()
 
-                            implementation.instructions.forEach { instruction ->
-                                if (instruction.opcode.ordinal != Opcode.CONST_STRING.ordinal) return@forEach
+                            implementation.instructions.forEachIndexed { instructionIndex, instruction ->
+                                if (instruction.opcode.ordinal != Opcode.CONST_STRING.ordinal) return@forEachIndexed
 
                                 val string = ((instruction as ReferenceInstruction).reference as StringReference).string
                                 val index = stringsList.indexOfFirst { it == string }
-                                if (index == -1) return@forEach
+                                if (index == -1) return@forEachIndexed
 
                                 add(
                                     StringMatch(
                                         string,
-                                        index
+                                        instructionIndex
                                     )
                                 )
                                 stringsList.removeAt(index)