Thread Syncronization for FileAccessHandler and DirectoryAccessHandler

h1v9 · h1v9 · commit f1e1e6f37340 · 2025-08-07T19:02:38.000+03:00
- Switching to ReentrantLock
- Thread locking for DirectoryAccessHandler (dependencies)

Newline @ EOF

Forgot import

Revert

Better locking

Forgot return

Restore last empty line
diff --git a/platform/android/java/lib/src/org/godotengine/godot/io/directory/DirectoryAccessHandler.kt b/platform/android/java/lib/src/org/godotengine/godot/io/directory/DirectoryAccessHandler.kt
@@ -35,6 +35,8 @@ import android.util.Log
 import org.godotengine.godot.Godot
 import org.godotengine.godot.io.StorageScope
 import org.godotengine.godot.io.directory.DirectoryAccessHandler.AccessType.ACCESS_RESOURCES
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
 
 /**
  * Handles files and directories access and manipulation for the Android platform
@@ -145,9 +147,10 @@ class DirectoryAccessHandler(context: Context) {
 
 	private val assetsDirAccess = AssetsDirectoryAccess(context)
 	private val fileSystemDirAccess = FilesystemDirectoryAccess(context, storageScopeIdentifier)
+	private val lock = ReentrantLock()
 
-	fun assetsFileExists(assetsPath: String) = assetsDirAccess.fileExists(assetsPath)
-	fun filesystemFileExists(path: String) = fileSystemDirAccess.fileExists(path)
+	fun assetsFileExists(assetsPath: String) = lock.withLock { assetsDirAccess.fileExists(assetsPath) }
+	fun filesystemFileExists(path: String) = lock.withLock { fileSystemDirAccess.fileExists(path) }
 
 	private fun hasDirId(accessType: AccessType, dirId: Int): Boolean {
 		return when (accessType) {
@@ -156,7 +159,7 @@ class DirectoryAccessHandler(context: Context) {
 		}
 	}
 
-	fun dirOpen(nativeAccessType: Int, path: String?): Int {
+	fun dirOpen(nativeAccessType: Int, path: String?): Int = lock.withLock {
 		if (path == null) {
 			return INVALID_DIR_ID
 		}
@@ -176,7 +179,7 @@ class DirectoryAccessHandler(context: Context) {
 		return dirAccessId
 	}
 
-	fun dirNext(dirAccessId: Int): String {
+	fun dirNext(dirAccessId: Int): String = lock.withLock {
 		val (accessType, dirId) = AccessType.fromDirAccessId(dirAccessId)
 		if (accessType == null || !hasDirId(accessType, dirId)) {
 			Log.w(TAG, "dirNext: Invalid dir id: $dirId")
@@ -189,7 +192,7 @@ class DirectoryAccessHandler(context: Context) {
 		}
 	}
 
-	fun dirClose(dirAccessId: Int) {
+	fun dirClose(dirAccessId: Int) = lock.withLock {
 		val (accessType, dirId) = AccessType.fromDirAccessId(dirAccessId)
 		if (accessType == null || !hasDirId(accessType, dirId)) {
 			Log.w(TAG, "dirClose: Invalid dir id: $dirId")
@@ -202,7 +205,7 @@ class DirectoryAccessHandler(context: Context) {
 		}
 	}
 
-	fun dirIsDir(dirAccessId: Int): Boolean {
+	fun dirIsDir(dirAccessId: Int): Boolean = lock.withLock {
 		val (accessType, dirId) = AccessType.fromDirAccessId(dirAccessId)
 		if (accessType == null || !hasDirId(accessType, dirId)) {
 			Log.w(TAG, "dirIsDir: Invalid dir id: $dirId")
@@ -215,7 +218,7 @@ class DirectoryAccessHandler(context: Context) {
 		}
 	}
 
-	fun isCurrentHidden(dirAccessId: Int): Boolean {
+	fun isCurrentHidden(dirAccessId: Int): Boolean = lock.withLock {
 		val (accessType, dirId) = AccessType.fromDirAccessId(dirAccessId)
 		if (accessType == null || !hasDirId(accessType, dirId)) {
 			return false
@@ -227,7 +230,7 @@ class DirectoryAccessHandler(context: Context) {
 		}
 	}
 
-	fun dirExists(nativeAccessType: Int, path: String?): Boolean {
+	fun dirExists(nativeAccessType: Int, path: String?): Boolean = lock.withLock {
 		if (path == null) {
 			return false
 		}
@@ -241,7 +244,7 @@ class DirectoryAccessHandler(context: Context) {
 		}
 	}
 
-	fun fileExists(nativeAccessType: Int, path: String?): Boolean {
+	fun fileExists(nativeAccessType: Int, path: String?): Boolean = lock.withLock {
 		if (path == null) {
 			return false
 		}
@@ -255,23 +258,23 @@ class DirectoryAccessHandler(context: Context) {
 		}
 	}
 
-	fun getDriveCount(nativeAccessType: Int): Int {
+	fun getDriveCount(nativeAccessType: Int): Int = lock.withLock {
 		val accessType = AccessType.fromNative(nativeAccessType) ?: return 0
 		return when(accessType) {
 			ACCESS_RESOURCES -> assetsDirAccess.getDriveCount()
 			else -> fileSystemDirAccess.getDriveCount()
 		}
 	}
 
-	fun getDrive(nativeAccessType: Int, drive: Int): String {
+	fun getDrive(nativeAccessType: Int, drive: Int): String = lock.withLock {
 		val accessType = AccessType.fromNative(nativeAccessType) ?: return ""
 		return when (accessType) {
 			ACCESS_RESOURCES -> assetsDirAccess.getDrive(drive)
 			else -> fileSystemDirAccess.getDrive(drive)
 		}
 	}
 
-	fun makeDir(nativeAccessType: Int, dir: String?): Boolean {
+	fun makeDir(nativeAccessType: Int, dir: String?): Boolean = lock.withLock {
 		if (dir == null) {
 			return false
 		}
@@ -285,23 +288,23 @@ class DirectoryAccessHandler(context: Context) {
 		}
 	}
 
-	fun getSpaceLeft(nativeAccessType: Int): Long {
+	fun getSpaceLeft(nativeAccessType: Int): Long = lock.withLock {
 		val accessType = AccessType.fromNative(nativeAccessType) ?: return 0L
 		return when (accessType) {
 			ACCESS_RESOURCES -> assetsDirAccess.getSpaceLeft()
 			else -> fileSystemDirAccess.getSpaceLeft()
 		}
 	}
 
-	fun rename(nativeAccessType: Int, from: String, to: String): Boolean {
+	fun rename(nativeAccessType: Int, from: String, to: String): Boolean = lock.withLock {
 		val accessType = AccessType.fromNative(nativeAccessType) ?: return false
 		return when (accessType) {
 			ACCESS_RESOURCES -> assetsDirAccess.rename(from, to)
 			else -> fileSystemDirAccess.rename(from, to)
 		}
 	}
 
-	fun remove(nativeAccessType: Int, filename: String?): Boolean {
+	fun remove(nativeAccessType: Int, filename: String?): Boolean = lock.withLock {
 		if (filename == null) {
 			return false
 		}
diff --git a/platform/android/java/lib/src/org/godotengine/godot/io/file/FileAccessHandler.kt b/platform/android/java/lib/src/org/godotengine/godot/io/file/FileAccessHandler.kt
@@ -39,6 +39,8 @@ import java.io.FileNotFoundException
 import java.io.InputStream
 import java.lang.UnsupportedOperationException
 import java.nio.ByteBuffer
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
 
 /**
  * Handles regular and media store file access and interactions.
@@ -110,8 +112,11 @@ class FileAccessHandler(val context: Context) {
 	internal val storageScopeIdentifier = StorageScope.Identifier(context)
 	private val files = SparseArray<DataAccess>()
 	private var lastFileId = STARTING_FILE_ID
+	private val lock = ReentrantLock()
 
-	private fun hasFileId(fileId: Int) = files.indexOfKey(fileId) >= 0
+	private fun hasFileId(fileId: Int): Boolean {
+		return files.indexOfKey(fileId) >= 0
+	}
 
 	fun canAccess(filePath: String?): Boolean {
 		return storageScopeIdentifier.canAccess(filePath)
@@ -121,7 +126,7 @@ class FileAccessHandler(val context: Context) {
 	 * Returns a positive (> 0) file id when the operation succeeds.
 	 * Otherwise, returns a negative value of [Error].
 	 */
-	fun fileOpen(path: String?, modeFlags: Int): Int {
+	fun fileOpen(path: String?, modeFlags: Int): Int = lock.withLock {
 		val (fileError, fileId) = fileOpen(path, FileAccessFlags.fromNativeModeFlags(modeFlags))
 		return if (fileError == Error.OK) {
 			fileId
@@ -145,7 +150,6 @@ class FileAccessHandler(val context: Context) {
 		return try {
 			path?.let {
 				val dataAccess = DataAccess.generateDataAccess(storageScope, context, it, accessFlag) ?: return FILE_OPEN_FAILED
-
 				files.put(++lastFileId, dataAccess)
 				Pair(Error.OK, lastFileId)
 			} ?: FILE_OPEN_FAILED
@@ -159,47 +163,47 @@ class FileAccessHandler(val context: Context) {
 		}
 	}
 
-	fun fileGetSize(fileId: Int): Long {
+	fun fileGetSize(fileId: Int): Long = lock.withLock {
 		if (!hasFileId(fileId)) {
 			return 0L
 		}
 
 		return files[fileId].size()
 	}
 
-	fun fileSeek(fileId: Int, position: Long) {
+	fun fileSeek(fileId: Int, position: Long) = lock.withLock {
 		if (!hasFileId(fileId)) {
 			return
 		}
 
 		files[fileId].seek(position)
 	}
 
-	fun fileSeekFromEnd(fileId: Int, position: Long) {
+	fun fileSeekFromEnd(fileId: Int, position: Long) = lock.withLock {
 		if (!hasFileId(fileId)) {
 			return
 		}
 
 		files[fileId].seekFromEnd(position)
 	}
 
-	fun fileRead(fileId: Int, byteBuffer: ByteBuffer?): Int {
+	fun fileRead(fileId: Int, byteBuffer: ByteBuffer?): Int = lock.withLock {
 		if (!hasFileId(fileId) || byteBuffer == null) {
 			return 0
 		}
 
 		return files[fileId].read(byteBuffer)
 	}
 
-	fun fileWrite(fileId: Int, byteBuffer: ByteBuffer?): Boolean {
+	fun fileWrite(fileId: Int, byteBuffer: ByteBuffer?): Boolean = lock.withLock {
 		if (!hasFileId(fileId) || byteBuffer == null) {
 			return false
 		}
 
 		return files[fileId].write(byteBuffer)
 	}
 
-	fun fileFlush(fileId: Int) {
+	fun fileFlush(fileId: Int) = lock.withLock {
 		if (!hasFileId(fileId)) {
 			return
 		}
@@ -243,7 +247,7 @@ class FileAccessHandler(val context: Context) {
 		}
 	}
 
-	fun fileResize(fileId: Int, length: Long): Int {
+	fun fileResize(fileId: Int, length: Long): Int = lock.withLock {
 		if (!hasFileId(fileId)) {
 			return Error.FAILED.toNativeValue()
 		}
@@ -266,28 +270,28 @@ class FileAccessHandler(val context: Context) {
 		}
 	}
 
-	fun fileGetPosition(fileId: Int): Long {
+	fun fileGetPosition(fileId: Int): Long = lock.withLock {
 		if (!hasFileId(fileId)) {
 			return 0L
 		}
 
 		return files[fileId].position()
 	}
 
-	fun isFileEof(fileId: Int): Boolean {
+	fun isFileEof(fileId: Int): Boolean = lock.withLock {
 		if (!hasFileId(fileId)) {
 			return false
 		}
 
 		return files[fileId].endOfFile
 	}
 
-	fun setFileEof(fileId: Int, eof: Boolean) {
+	fun setFileEof(fileId: Int, eof: Boolean) = lock.withLock {
 		val file = files[fileId] ?: return
 		file.endOfFile = eof
 	}
 
-	fun fileClose(fileId: Int) {
+	fun fileClose(fileId: Int) = lock.withLock {
 		if (hasFileId(fileId)) {
 			files[fileId].close()
 			files.remove(fileId)

Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,8 @@ import android.util.Log`
`35`	`35`	`import org.godotengine.godot.Godot`
`36`	`36`	`import org.godotengine.godot.io.StorageScope`
`37`	`37`	`import org.godotengine.godot.io.directory.DirectoryAccessHandler.AccessType.ACCESS_RESOURCES`
	`38`	`+import java.util.concurrent.locks.ReentrantLock`
	`39`	`+import kotlin.concurrent.withLock`
`38`	`40`
`39`	`41`	`/**`
`40`	`42`	`* Handles files and directories access and manipulation for the Android platform`
`@@ -145,9 +147,10 @@ class DirectoryAccessHandler(context: Context) {`
`145`	`147`
`146`	`148`	`private val assetsDirAccess = AssetsDirectoryAccess(context)`
`147`	`149`	`private val fileSystemDirAccess = FilesystemDirectoryAccess(context, storageScopeIdentifier)`
	`150`	`+ private val lock = ReentrantLock()`
`148`	`151`
`149`		`- fun assetsFileExists(assetsPath: String) = assetsDirAccess.fileExists(assetsPath)`
`150`		`- fun filesystemFileExists(path: String) = fileSystemDirAccess.fileExists(path)`
	`152`	`+ fun assetsFileExists(assetsPath: String) = lock.withLock { assetsDirAccess.fileExists(assetsPath) }`
	`153`	`+ fun filesystemFileExists(path: String) = lock.withLock { fileSystemDirAccess.fileExists(path) }`
`151`	`154`
`152`	`155`	`private fun hasDirId(accessType: AccessType, dirId: Int): Boolean {`
`153`	`156`	`return when (accessType) {`
`@@ -156,7 +159,7 @@ class DirectoryAccessHandler(context: Context) {`
`156`	`159`	`}`
`157`	`160`	`}`
`158`	`161`
`159`		`- fun dirOpen(nativeAccessType: Int, path: String?): Int {`
	`162`	`+ fun dirOpen(nativeAccessType: Int, path: String?): Int = lock.withLock {`
`160`	`163`	`if (path == null) {`
`161`	`164`	`return INVALID_DIR_ID`
`162`	`165`	`}`
`@@ -176,7 +179,7 @@ class DirectoryAccessHandler(context: Context) {`
`176`	`179`	`return dirAccessId`
`177`	`180`	`}`
`178`	`181`
`179`		`- fun dirNext(dirAccessId: Int): String {`
	`182`	`+ fun dirNext(dirAccessId: Int): String = lock.withLock {`
`180`	`183`	`val (accessType, dirId) = AccessType.fromDirAccessId(dirAccessId)`
`181`	`184`	`if (accessType == null \|\| !hasDirId(accessType, dirId)) {`
`182`	`185`	`Log.w(TAG, "dirNext: Invalid dir id: $dirId")`
`@@ -189,7 +192,7 @@ class DirectoryAccessHandler(context: Context) {`
`189`	`192`	`}`
`190`	`193`	`}`
`191`	`194`
`192`		`- fun dirClose(dirAccessId: Int) {`
	`195`	`+ fun dirClose(dirAccessId: Int) = lock.withLock {`
`193`	`196`	`val (accessType, dirId) = AccessType.fromDirAccessId(dirAccessId)`
`194`	`197`	`if (accessType == null \|\| !hasDirId(accessType, dirId)) {`
`195`	`198`	`Log.w(TAG, "dirClose: Invalid dir id: $dirId")`
`@@ -202,7 +205,7 @@ class DirectoryAccessHandler(context: Context) {`
`202`	`205`	`}`
`203`	`206`	`}`
`204`	`207`
`205`		`- fun dirIsDir(dirAccessId: Int): Boolean {`
	`208`	`+ fun dirIsDir(dirAccessId: Int): Boolean = lock.withLock {`
`206`	`209`	`val (accessType, dirId) = AccessType.fromDirAccessId(dirAccessId)`
`207`	`210`	`if (accessType == null \|\| !hasDirId(accessType, dirId)) {`
`208`	`211`	`Log.w(TAG, "dirIsDir: Invalid dir id: $dirId")`
`@@ -215,7 +218,7 @@ class DirectoryAccessHandler(context: Context) {`
`215`	`218`	`}`
`216`	`219`	`}`
`217`	`220`
`218`		`- fun isCurrentHidden(dirAccessId: Int): Boolean {`
	`221`	`+ fun isCurrentHidden(dirAccessId: Int): Boolean = lock.withLock {`
`219`	`222`	`val (accessType, dirId) = AccessType.fromDirAccessId(dirAccessId)`
`220`	`223`	`if (accessType == null \|\| !hasDirId(accessType, dirId)) {`
`221`	`224`	`return false`
`@@ -227,7 +230,7 @@ class DirectoryAccessHandler(context: Context) {`
`227`	`230`	`}`
`228`	`231`	`}`
`229`	`232`
`230`		`- fun dirExists(nativeAccessType: Int, path: String?): Boolean {`
	`233`	`+ fun dirExists(nativeAccessType: Int, path: String?): Boolean = lock.withLock {`
`231`	`234`	`if (path == null) {`
`232`	`235`	`return false`
`233`	`236`	`}`
`@@ -241,7 +244,7 @@ class DirectoryAccessHandler(context: Context) {`
`241`	`244`	`}`
`242`	`245`	`}`
`243`	`246`
`244`		`- fun fileExists(nativeAccessType: Int, path: String?): Boolean {`
	`247`	`+ fun fileExists(nativeAccessType: Int, path: String?): Boolean = lock.withLock {`
`245`	`248`	`if (path == null) {`
`246`	`249`	`return false`
`247`	`250`	`}`
`@@ -255,23 +258,23 @@ class DirectoryAccessHandler(context: Context) {`
`255`	`258`	`}`
`256`	`259`	`}`
`257`	`260`
`258`		`- fun getDriveCount(nativeAccessType: Int): Int {`
	`261`	`+ fun getDriveCount(nativeAccessType: Int): Int = lock.withLock {`
`259`	`262`	`val accessType = AccessType.fromNative(nativeAccessType) ?: return 0`
`260`	`263`	`return when(accessType) {`
`261`	`264`	`ACCESS_RESOURCES -> assetsDirAccess.getDriveCount()`
`262`	`265`	`else -> fileSystemDirAccess.getDriveCount()`
`263`	`266`	`}`
`264`	`267`	`}`
`265`	`268`
`266`		`- fun getDrive(nativeAccessType: Int, drive: Int): String {`
	`269`	`+ fun getDrive(nativeAccessType: Int, drive: Int): String = lock.withLock {`
`267`	`270`	`val accessType = AccessType.fromNative(nativeAccessType) ?: return ""`
`268`	`271`	`return when (accessType) {`
`269`	`272`	`ACCESS_RESOURCES -> assetsDirAccess.getDrive(drive)`
`270`	`273`	`else -> fileSystemDirAccess.getDrive(drive)`
`271`	`274`	`}`
`272`	`275`	`}`
`273`	`276`
`274`		`- fun makeDir(nativeAccessType: Int, dir: String?): Boolean {`
	`277`	`+ fun makeDir(nativeAccessType: Int, dir: String?): Boolean = lock.withLock {`
`275`	`278`	`if (dir == null) {`
`276`	`279`	`return false`
`277`	`280`	`}`
`@@ -285,23 +288,23 @@ class DirectoryAccessHandler(context: Context) {`
`285`	`288`	`}`
`286`	`289`	`}`
`287`	`290`
`288`		`- fun getSpaceLeft(nativeAccessType: Int): Long {`
	`291`	`+ fun getSpaceLeft(nativeAccessType: Int): Long = lock.withLock {`
`289`	`292`	`val accessType = AccessType.fromNative(nativeAccessType) ?: return 0L`
`290`	`293`	`return when (accessType) {`
`291`	`294`	`ACCESS_RESOURCES -> assetsDirAccess.getSpaceLeft()`
`292`	`295`	`else -> fileSystemDirAccess.getSpaceLeft()`
`293`	`296`	`}`
`294`	`297`	`}`
`295`	`298`
`296`		`- fun rename(nativeAccessType: Int, from: String, to: String): Boolean {`
	`299`	`+ fun rename(nativeAccessType: Int, from: String, to: String): Boolean = lock.withLock {`
`297`	`300`	`val accessType = AccessType.fromNative(nativeAccessType) ?: return false`
`298`	`301`	`return when (accessType) {`
`299`	`302`	`ACCESS_RESOURCES -> assetsDirAccess.rename(from, to)`
`300`	`303`	`else -> fileSystemDirAccess.rename(from, to)`
`301`	`304`	`}`
`302`	`305`	`}`
`303`	`306`
`304`		`- fun remove(nativeAccessType: Int, filename: String?): Boolean {`
	`307`	`+ fun remove(nativeAccessType: Int, filename: String?): Boolean = lock.withLock {`
`305`	`308`	`if (filename == null) {`
`306`	`309`	`return false`
`307`	`310`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,6 +39,8 @@ import java.io.FileNotFoundException`
`39`	`39`	`import java.io.InputStream`
`40`	`40`	`import java.lang.UnsupportedOperationException`
`41`	`41`	`import java.nio.ByteBuffer`
	`42`	`+import java.util.concurrent.locks.ReentrantLock`
	`43`	`+import kotlin.concurrent.withLock`
`42`	`44`
`43`	`45`	`/**`
`44`	`46`	`* Handles regular and media store file access and interactions.`
`@@ -110,8 +112,11 @@ class FileAccessHandler(val context: Context) {`
`110`	`112`	`internal val storageScopeIdentifier = StorageScope.Identifier(context)`
`111`	`113`	`private val files = SparseArray<DataAccess>()`
`112`	`114`	`private var lastFileId = STARTING_FILE_ID`
	`115`	`+ private val lock = ReentrantLock()`
`113`	`116`
`114`		`- private fun hasFileId(fileId: Int) = files.indexOfKey(fileId) >= 0`
	`117`	`+ private fun hasFileId(fileId: Int): Boolean {`
	`118`	`+ return files.indexOfKey(fileId) >= 0`
	`119`	`+ }`
`115`	`120`
`116`	`121`	`fun canAccess(filePath: String?): Boolean {`
`117`	`122`	`return storageScopeIdentifier.canAccess(filePath)`
`@@ -121,7 +126,7 @@ class FileAccessHandler(val context: Context) {`
`121`	`126`	`* Returns a positive (> 0) file id when the operation succeeds.`
`122`	`127`	`* Otherwise, returns a negative value of [Error].`
`123`	`128`	`*/`
`124`		`- fun fileOpen(path: String?, modeFlags: Int): Int {`
	`129`	`+ fun fileOpen(path: String?, modeFlags: Int): Int = lock.withLock {`
`125`	`130`	`val (fileError, fileId) = fileOpen(path, FileAccessFlags.fromNativeModeFlags(modeFlags))`
`126`	`131`	`return if (fileError == Error.OK) {`
`127`	`132`	`fileId`
`@@ -145,7 +150,6 @@ class FileAccessHandler(val context: Context) {`
`145`	`150`	`return try {`
`146`	`151`	`path?.let {`
`147`	`152`	`val dataAccess = DataAccess.generateDataAccess(storageScope, context, it, accessFlag) ?: return FILE_OPEN_FAILED`
`148`		`-`
`149`	`153`	`files.put(++lastFileId, dataAccess)`
`150`	`154`	`Pair(Error.OK, lastFileId)`
`151`	`155`	`} ?: FILE_OPEN_FAILED`
`@@ -159,47 +163,47 @@ class FileAccessHandler(val context: Context) {`
`159`	`163`	`}`
`160`	`164`	`}`
`161`	`165`
`162`		`- fun fileGetSize(fileId: Int): Long {`
	`166`	`+ fun fileGetSize(fileId: Int): Long = lock.withLock {`
`163`	`167`	`if (!hasFileId(fileId)) {`
`164`	`168`	`return 0L`
`165`	`169`	`}`
`166`	`170`
`167`	`171`	`return files[fileId].size()`
`168`	`172`	`}`
`169`	`173`
`170`		`- fun fileSeek(fileId: Int, position: Long) {`
	`174`	`+ fun fileSeek(fileId: Int, position: Long) = lock.withLock {`
`171`	`175`	`if (!hasFileId(fileId)) {`
`172`	`176`	`return`
`173`	`177`	`}`
`174`	`178`
`175`	`179`	`files[fileId].seek(position)`
`176`	`180`	`}`
`177`	`181`
`178`		`- fun fileSeekFromEnd(fileId: Int, position: Long) {`
	`182`	`+ fun fileSeekFromEnd(fileId: Int, position: Long) = lock.withLock {`
`179`	`183`	`if (!hasFileId(fileId)) {`
`180`	`184`	`return`
`181`	`185`	`}`
`182`	`186`
`183`	`187`	`files[fileId].seekFromEnd(position)`
`184`	`188`	`}`
`185`	`189`
`186`		`- fun fileRead(fileId: Int, byteBuffer: ByteBuffer?): Int {`
	`190`	`+ fun fileRead(fileId: Int, byteBuffer: ByteBuffer?): Int = lock.withLock {`
`187`	`191`	`if (!hasFileId(fileId) \|\| byteBuffer == null) {`
`188`	`192`	`return 0`
`189`	`193`	`}`
`190`	`194`
`191`	`195`	`return files[fileId].read(byteBuffer)`
`192`	`196`	`}`
`193`	`197`
`194`		`- fun fileWrite(fileId: Int, byteBuffer: ByteBuffer?): Boolean {`
	`198`	`+ fun fileWrite(fileId: Int, byteBuffer: ByteBuffer?): Boolean = lock.withLock {`
`195`	`199`	`if (!hasFileId(fileId) \|\| byteBuffer == null) {`
`196`	`200`	`return false`
`197`	`201`	`}`
`198`	`202`
`199`	`203`	`return files[fileId].write(byteBuffer)`
`200`	`204`	`}`
`201`	`205`
`202`		`- fun fileFlush(fileId: Int) {`
	`206`	`+ fun fileFlush(fileId: Int) = lock.withLock {`
`203`	`207`	`if (!hasFileId(fileId)) {`
`204`	`208`	`return`
`205`	`209`	`}`
`@@ -243,7 +247,7 @@ class FileAccessHandler(val context: Context) {`
`243`	`247`	`}`
`244`	`248`	`}`
`245`	`249`
`246`		`- fun fileResize(fileId: Int, length: Long): Int {`
	`250`	`+ fun fileResize(fileId: Int, length: Long): Int = lock.withLock {`
`247`	`251`	`if (!hasFileId(fileId)) {`
`248`	`252`	`return Error.FAILED.toNativeValue()`
`249`	`253`	`}`
`@@ -266,28 +270,28 @@ class FileAccessHandler(val context: Context) {`
`266`	`270`	`}`
`267`	`271`	`}`
`268`	`272`
`269`		`- fun fileGetPosition(fileId: Int): Long {`
	`273`	`+ fun fileGetPosition(fileId: Int): Long = lock.withLock {`
`270`	`274`	`if (!hasFileId(fileId)) {`
`271`	`275`	`return 0L`
`272`	`276`	`}`
`273`	`277`
`274`	`278`	`return files[fileId].position()`
`275`	`279`	`}`
`276`	`280`
`277`		`- fun isFileEof(fileId: Int): Boolean {`
	`281`	`+ fun isFileEof(fileId: Int): Boolean = lock.withLock {`
`278`	`282`	`if (!hasFileId(fileId)) {`
`279`	`283`	`return false`
`280`	`284`	`}`
`281`	`285`
`282`	`286`	`return files[fileId].endOfFile`
`283`	`287`	`}`
`284`	`288`
`285`		`- fun setFileEof(fileId: Int, eof: Boolean) {`
	`289`	`+ fun setFileEof(fileId: Int, eof: Boolean) = lock.withLock {`
`286`	`290`	`val file = files[fileId] ?: return`
`287`	`291`	`file.endOfFile = eof`
`288`	`292`	`}`
`289`	`293`
`290`		`- fun fileClose(fileId: Int) {`
	`294`	`+ fun fileClose(fileId: Int) = lock.withLock {`
`291`	`295`	`if (hasFileId(fileId)) {`
`292`	`296`	`files[fileId].close()`
`293`	`297`	`files.remove(fileId)`