react-native-kookit 0.2.4 → 0.2.7

package/ios/ReactNativeKookitModule.swift

@@ -292,10 +292,17 @@ class FtpClient: @unchecked Sendable {
         }
         dataConnection.cancel()
 
-        let finalResponse = try await readResponse()
-        print("FTP DEBUG: Final response: \(finalResponse)")
-        guard finalResponse.hasPrefix("226") else {
-            throw FtpError.commandFailed("LIST completion failed: \(finalResponse)")
+        // Check if the response already contained the completion message (226)
+        if response.contains("226") {
+            print("FTP DEBUG: Transfer completion already received in LIST response - skipping final response read")
+        } else {
+            print("FTP DEBUG: Reading final response...")
+            let finalResponse = try await readResponse()
+            let finalFirstLine = finalResponse.components(separatedBy: .newlines).first ?? finalResponse
+            print("FTP DEBUG: Final response: \(finalFirstLine)")
+            guard finalFirstLine.hasPrefix("226") else {
+                throw FtpError.commandFailed("LIST completion failed: \(finalFirstLine)")
+            }
         }
 
         let files = parseListingData(data)
@@ -803,7 +810,7 @@ public class ReactNativeKookitModule: Module {
   private var volumeObserver: NSKeyValueObservation?
   private var isVolumeKeyInterceptionEnabled = false
   private var previousVolume: Float = 0.0
-  private var ftpClient: FtpClient?
+  private var ftpClients: [String: FtpClient] = [:]  // Store multiple FTP clients by ID
   
   // Each module class must implement the definition function. The definition consists of components
   // that describes the module's functionality and behavior.
@@ -846,8 +853,31 @@ public class ReactNativeKookitModule: Module {
       self.disableVolumeKeyInterception()
     }
 
-    // FTP Functions
-    AsyncFunction("ftpConnect") { (config: [String: Any], promise: Promise) in
+    // New FTP Client API - Create new FTP client instance
+    AsyncFunction("createFtpClient") { (clientId: String, promise: Promise) in
+      if self.ftpClients[clientId] != nil {
+        promise.reject("FTP_CLIENT_EXISTS", "FTP client with ID '\(clientId)' already exists")
+        return
+      }
+      
+      let ftpClient = FtpClient()
+      let progressDelegate = FtpProgressDelegateImpl(module: self, clientId: clientId)
+      ftpClient.setProgressDelegate(progressDelegate)
+      self.ftpClients[clientId] = ftpClient
+      
+      promise.resolve([
+        "clientId": clientId,
+        "created": true
+      ])
+    }
+
+    // Connect FTP client
+    AsyncFunction("ftpClientConnect") { (clientId: String, config: [String: Any], promise: Promise) in
+      guard let ftpClient = self.ftpClients[clientId] else {
+        promise.reject("FTP_CLIENT_NOT_FOUND", "FTP client with ID '\(clientId)' not found")
+        return
+      }
+      
       Task {
         do {
           let ftpConfig = FtpConnectionConfig(
@@ -859,30 +889,60 @@ public class ReactNativeKookitModule: Module {
             timeout: config["timeout"] as? TimeInterval ?? 30.0
           )
           
-          self.ftpClient = FtpClient()
-          let progressDelegate = FtpProgressDelegateImpl(module: self)
-          self.ftpClient?.setProgressDelegate(progressDelegate)
-          
-          try await self.ftpClient?.connect(config: ftpConfig)
-          promise.resolve()
+          try await ftpClient.connect(config: ftpConfig)
+          promise.resolve([
+            "clientId": clientId,
+            "connected": true
+          ])
         } catch {
           promise.reject("FTP_CONNECT_ERROR", error.localizedDescription)
         }
       }
     }
 
-    AsyncFunction("ftpDisconnect") { (promise: Promise) in
+    // Disconnect FTP client
+    AsyncFunction("ftpClientDisconnect") { (clientId: String, promise: Promise) in
+      guard let ftpClient = self.ftpClients[clientId] else {
+        promise.reject("FTP_CLIENT_NOT_FOUND", "FTP client with ID '\(clientId)' not found")
+        return
+      }
+      
       Task {
-        await self.ftpClient?.disconnect()
-        self.ftpClient = nil
-        promise.resolve()
+        await ftpClient.disconnect()
+        promise.resolve([
+          "clientId": clientId,
+          "disconnected": true
+        ])
       }
     }
 
-    AsyncFunction("ftpList") { (path: String?, promise: Promise) in
+    // Dispose FTP client
+    AsyncFunction("disposeFtpClient") { (clientId: String, promise: Promise) in
+      guard let ftpClient = self.ftpClients[clientId] else {
+        promise.reject("FTP_CLIENT_NOT_FOUND", "FTP client with ID '\(clientId)' not found")
+        return
+      }
+      
+      Task {
+        await ftpClient.disconnect()
+        self.ftpClients.removeValue(forKey: clientId)
+        promise.resolve([
+          "clientId": clientId,
+          "disposed": true
+        ])
+      }
+    }
+
+    // List files
+    AsyncFunction("ftpClientList") { (clientId: String, path: String?, promise: Promise) in
+      guard let ftpClient = self.ftpClients[clientId] else {
+        promise.reject("FTP_CLIENT_NOT_FOUND", "FTP client with ID '\(clientId)' not found")
+        return
+      }
+      
       Task {
         do {
-          let files = try await self.ftpClient?.listFiles(path: path) ?? []
+          let files = try await ftpClient.listFiles(path: path)
           let result = files.map { file in
             [
               "name": file.name,
@@ -899,72 +959,163 @@ public class ReactNativeKookitModule: Module {
       }
     }
 
-    AsyncFunction("ftpDownload") { (remotePath: String, localPath: String, promise: Promise) in
+    // Download file
+    AsyncFunction("ftpClientDownload") { (clientId: String, remotePath: String, localPath: String, promise: Promise) in
+      guard let ftpClient = self.ftpClients[clientId] else {
+        promise.reject("FTP_CLIENT_NOT_FOUND", "FTP client with ID '\(clientId)' not found")
+        return
+      }
+      
       Task {
         do {
-          try await self.ftpClient?.downloadFile(remotePath: remotePath, localPath: localPath)
-          promise.resolve()
+          try await ftpClient.downloadFile(remotePath: remotePath, localPath: localPath)
+          promise.resolve([
+            "clientId": clientId,
+            "remotePath": remotePath,
+            "localPath": localPath,
+            "downloaded": true
+          ])
         } catch {
           promise.reject("FTP_DOWNLOAD_ERROR", error.localizedDescription)
         }
       }
     }
 
-    AsyncFunction("ftpUpload") { (localPath: String, remotePath: String, promise: Promise) in
+    // Upload file
+    AsyncFunction("ftpClientUpload") { (clientId: String, localPath: String, remotePath: String, promise: Promise) in
+      guard let ftpClient = self.ftpClients[clientId] else {
+        promise.reject("FTP_CLIENT_NOT_FOUND", "FTP client with ID '\(clientId)' not found")
+        return
+      }
+      
       Task {
         do {
-          try await self.ftpClient?.uploadFile(localPath: localPath, remotePath: remotePath)
-          promise.resolve()
+          try await ftpClient.uploadFile(localPath: localPath, remotePath: remotePath)
+          promise.resolve([
+            "clientId": clientId,
+            "localPath": localPath,
+            "remotePath": remotePath,
+            "uploaded": true
+          ])
         } catch {
           promise.reject("FTP_UPLOAD_ERROR", error.localizedDescription)
         }
       }
     }
 
-    AsyncFunction("ftpDelete") { (remotePath: String, isDirectory: Bool?, promise: Promise) in
+    // Delete file
+    AsyncFunction("ftpClientDelete") { (clientId: String, remotePath: String, isDirectory: Bool?, promise: Promise) in
+      guard let ftpClient = self.ftpClients[clientId] else {
+        promise.reject("FTP_CLIENT_NOT_FOUND", "FTP client with ID '\(clientId)' not found")
+        return
+      }
+      
       Task {
         do {
-          try await self.ftpClient?.deleteFile(remotePath: remotePath, isDirectory: isDirectory ?? false)
-          promise.resolve()
+          try await ftpClient.deleteFile(remotePath: remotePath, isDirectory: isDirectory ?? false)
+          promise.resolve([
+            "clientId": clientId,
+            "remotePath": remotePath,
+            "deleted": true
+          ])
         } catch {
           promise.reject("FTP_DELETE_ERROR", error.localizedDescription)
         }
       }
     }
 
-    AsyncFunction("ftpCreateDirectory") { (remotePath: String, promise: Promise) in
+    // Create directory
+    AsyncFunction("ftpClientCreateDirectory") { (clientId: String, remotePath: String, promise: Promise) in
+      guard let ftpClient = self.ftpClients[clientId] else {
+        promise.reject("FTP_CLIENT_NOT_FOUND", "FTP client with ID '\(clientId)' not found")
+        return
+      }
+      
       Task {
         do {
-          try await self.ftpClient?.createDirectory(remotePath: remotePath)
-          promise.resolve()
+          try await ftpClient.createDirectory(remotePath: remotePath)
+          promise.resolve([
+            "clientId": clientId,
+            "remotePath": remotePath,
+            "created": true
+          ])
         } catch {
           promise.reject("FTP_CREATE_DIR_ERROR", error.localizedDescription)
         }
       }
     }
 
-    AsyncFunction("ftpChangeDirectory") { (remotePath: String, promise: Promise) in
+    // Change directory
+    AsyncFunction("ftpClientChangeDirectory") { (clientId: String, remotePath: String, promise: Promise) in
+      guard let ftpClient = self.ftpClients[clientId] else {
+        promise.reject("FTP_CLIENT_NOT_FOUND", "FTP client with ID '\(clientId)' not found")
+        return
+      }
+      
       Task {
         do {
-          try await self.ftpClient?.changeDirectory(remotePath: remotePath)
-          promise.resolve()
+          try await ftpClient.changeDirectory(remotePath: remotePath)
+          promise.resolve([
+            "clientId": clientId,
+            "currentDirectory": remotePath,
+            "changed": true
+          ])
         } catch {
           promise.reject("FTP_CHANGE_DIR_ERROR", error.localizedDescription)
         }
       }
     }
 
-    AsyncFunction("ftpGetCurrentDirectory") { (promise: Promise) in
+    // Get current directory
+    AsyncFunction("ftpClientGetCurrentDirectory") { (clientId: String, promise: Promise) in
+      guard let ftpClient = self.ftpClients[clientId] else {
+        promise.reject("FTP_CLIENT_NOT_FOUND", "FTP client with ID '\(clientId)' not found")
+        return
+      }
+      
       Task {
         do {
-          let currentDir = try await self.ftpClient?.getCurrentDirectory() ?? "/"
-          promise.resolve(currentDir)
+          let currentDir = try await ftpClient.getCurrentDirectory()
+          promise.resolve([
+            "clientId": clientId,
+            "currentDirectory": currentDir
+          ])
         } catch {
           promise.reject("FTP_PWD_ERROR", error.localizedDescription)
         }
       }
     }
 
+    // Get FTP client status
+    AsyncFunction("getFtpClientStatus") { (clientId: String, promise: Promise) in
+      guard let ftpClient = self.ftpClients[clientId] else {
+        promise.resolve([
+          "exists": false,
+          "connected": false
+        ])
+        return
+      }
+      
+      promise.resolve([
+        "exists": true,
+        "connected": ftpClient.isConnected
+      ])
+    }
+
+    // List all FTP clients
+    AsyncFunction("listFtpClients") { (promise: Promise) in
+      let clientsInfo = self.ftpClients.mapValues { client in
+        [
+          "connected": client.isConnected
+        ]
+      }
+      
+      promise.resolve([
+        "clients": clientsInfo,
+        "count": self.ftpClients.count
+      ])
+    }
+
     // Enables the module to be used as a native view. Definition components that are accepted as part of
     // the view definition: Prop, Events.
     View(ReactNativeKookitView.self) {
@@ -1063,14 +1214,17 @@ public class ReactNativeKookitModule: Module {
 // Helper class to handle FTP progress callbacks
 private class FtpProgressDelegateImpl: FtpProgressDelegate {
   weak var module: ReactNativeKookitModule?
+  let clientId: String
   
-  init(module: ReactNativeKookitModule) {
+  init(module: ReactNativeKookitModule, clientId: String) {
     self.module = module
+    self.clientId = clientId
   }
   
   func onProgress(transferred: Int64, total: Int64) {
     let percentage = total > 0 ? Int((transferred * 100) / total) : 0
     module?.sendEvent("onFtpProgress", [
+      "clientId": clientId,
       "transferred": transferred,
       "total": total,
       "percentage": percentage
@@ -1078,10 +1232,15 @@ private class FtpProgressDelegateImpl: FtpProgressDelegate {
   }
   
   func onComplete() {
-    module?.sendEvent("onFtpComplete")
+    module?.sendEvent("onFtpComplete", [
+      "clientId": clientId
+    ])
   }
   
   func onError(error: String) {
-    module?.sendEvent("onFtpError", ["error": error])
+    module?.sendEvent("onFtpError", [
+      "clientId": clientId,
+      "error": error
+    ])
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-kookit",
-  "version": "0.2.4",
+  "version": "0.2.7",
   "description": "React Native module for intercepting volume button presses on iOS and Android, with FTP client functionality",
   "main": "build/index.js",
   "types": "build/index.d.ts",