react-native-kookit 0.2.3 → 0.2.6

package/ios/ReactNativeKookitModule.swift

@@ -311,32 +311,53 @@ class FtpClient: @unchecked Sendable {
     func downloadFile(remotePath: String, localPath: String) async throws {
         guard isConnected else { throw FtpError.notConnected }
         
+        print("FTP DEBUG: Starting download - Remote: \(remotePath), Local: \(localPath)")
+        
         let dataConnection = try await enterPassiveMode()
+        print("FTP DEBUG: Passive mode established for download")
         
         let response = try await sendCommand("RETR \(remotePath)")
-        guard response.hasPrefix("150") || response.hasPrefix("125") else {
+        print("FTP DEBUG: RETR command response: \(response)")
+        
+        // Extract the first line for status check
+        let firstLine = response.components(separatedBy: .newlines).first ?? response
+        guard firstLine.hasPrefix("150") || firstLine.hasPrefix("125") else {
             dataConnection.cancel()
-            throw FtpError.commandFailed("Download failed: \(response)")
+            throw FtpError.commandFailed("Download failed: \(firstLine)")
         }
         
         let localURL = URL(fileURLWithPath: localPath)
         
         // Create parent directories if needed
+        print("FTP DEBUG: Creating parent directories for: \(localURL.deletingLastPathComponent().path)")
         try FileManager.default.createDirectory(at: localURL.deletingLastPathComponent(),
                                               withIntermediateDirectories: true,
                                               attributes: nil)
         
+        print("FTP DEBUG: Starting data reception...")
         let data = try await receiveData(from: dataConnection, reportProgress: true)
+        print("FTP DEBUG: Data reception completed, received \(data.count) bytes")
         dataConnection.cancel()
         
+        print("FTP DEBUG: Writing data to file...")
         try data.write(to: localURL)
+        print("FTP DEBUG: File written successfully")
         
-        let finalResponse = try await readResponse()
-        guard finalResponse.hasPrefix("226") else {
-            try? FileManager.default.removeItem(at: localURL)
-            throw FtpError.commandFailed("Download 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 RETR 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 download response: \(finalFirstLine)")
+            guard finalFirstLine.hasPrefix("226") else {
+                try? FileManager.default.removeItem(at: localURL)
+                throw FtpError.commandFailed("Download completion failed: \(finalFirstLine)")
+            }
         }
         
+        print("FTP DEBUG: Download completed successfully")
         progressDelegate?.onComplete()
     }
     
@@ -454,6 +475,7 @@ class FtpClient: @unchecked Sendable {
             throw FtpError.notConnected
         }
         
+        print("FTP DEBUG: Sending command: \(command)")
         let commandData = "\(command)\r\n".data(using: .utf8)!
         
         return try await withCheckedThrowingContinuation { continuation in
@@ -461,13 +483,24 @@ class FtpClient: @unchecked Sendable {
             
             connection.send(content: commandData, completion: .contentProcessed { error in
                 if let error = error {
+                    print("FTP DEBUG: Send command error: \(error)")
                     connectionBox.resume(throwing: error)
                 } else {
+                    print("FTP DEBUG: Command sent successfully, waiting for response...")
                     Task {
                         do {
                             let response = try await self.readResponse()
-                            connectionBox.resume(returning: response)
+                            print("FTP DEBUG: Command response received: \(response)")
+                            
+                            // Store the full response for multi-line responses
+                            if response.contains("\n") {
+                                print("FTP DEBUG: Multi-line response detected")
+                                connectionBox.resume(returning: response)
+                            } else {
+                                connectionBox.resume(returning: response)
+                            }
                         } catch {
+                            print("FTP DEBUG: Error reading response: \(error)")
                             connectionBox.resume(throwing: error)
                         }
                     }
@@ -481,35 +514,47 @@ class FtpClient: @unchecked Sendable {
             throw FtpError.notConnected
         }
         
+        print("FTP DEBUG: Reading response...")
         return try await withCheckedThrowingContinuation { continuation in
             let connectionBox = ConnectionBox<String>(continuation: continuation)
             
             connection.receive(minimumIncompleteLength: 1, maximumLength: 4096) { data, _, isComplete, error in
                 if let error = error {
+                    print("FTP DEBUG: Read response error: \(error)")
                     connectionBox.resume(throwing: error)
                 } else if let data = data {
+                    print("FTP DEBUG: Received response data: \(data.count) bytes")
                     // Try multiple encodings for FTP responses
                     var response: String?
                     
                     // Try UTF-8 first
                     if let utf8Response = String(data: data, encoding: .utf8) {
                         response = utf8Response
+                        print("FTP DEBUG: Response decoded with UTF-8")
                     }
                     // Try GBK for Chinese FTP servers
                     else if let gbkResponse = String(data: data, encoding: String.Encoding(rawValue: CFStringConvertEncodingToNSStringEncoding(CFStringEncoding(CFStringEncodings.GB_18030_2000.rawValue)))) {
                         response = gbkResponse
+                        print("FTP DEBUG: Response decoded with GBK")
                     }
                     // Try ASCII as fallback
                     else if let asciiResponse = String(data: data, encoding: .ascii) {
                         response = asciiResponse
+                        print("FTP DEBUG: Response decoded with ASCII")
                     }
                     
                     if let validResponse = response {
-                        connectionBox.resume(returning: validResponse.trimmingCharacters(in: .whitespacesAndNewlines))
+                        let trimmedResponse = validResponse.trimmingCharacters(in: .whitespacesAndNewlines)
+                        print("FTP DEBUG: Response content: '\(trimmedResponse)'")
+                        
+                        // Return the full response for multi-line processing
+                        connectionBox.resume(returning: trimmedResponse)
                     } else {
+                        print("FTP DEBUG: Failed to decode response")
                         connectionBox.resume(throwing: FtpError.invalidResponse)
                     }
                 } else {
+                    print("FTP DEBUG: No data received")
                     connectionBox.resume(throwing: FtpError.invalidResponse)
                 }
             }
@@ -517,7 +562,9 @@ class FtpClient: @unchecked Sendable {
     }
     
     private func enterPassiveMode() async throws -> NWConnection {
+        print("FTP DEBUG: Entering passive mode...")
         let response = try await sendCommand("PASV")
+        print("FTP DEBUG: PASV response: \(response)")
         guard response.hasPrefix("227") else {
             throw FtpError.commandFailed("Failed to enter passive mode: \(response)")
         }
@@ -541,6 +588,8 @@ class FtpClient: @unchecked Sendable {
         let host = "\(h1).\(h2).\(h3).\(h4)"
         let port = p1 * 256 + p2
         
+        print("FTP DEBUG: Parsed passive mode - Host: \(host), Port: \(port)")
+        
         let dataHost = NWEndpoint.Host(host)
         let dataPort = NWEndpoint.Port(integerLiteral: UInt16(port))
         let dataEndpoint = NWEndpoint.hostPort(host: dataHost, port: dataPort)
@@ -551,15 +600,18 @@ class FtpClient: @unchecked Sendable {
             let connectionBox = NWConnectionBox(connection: dataConnection, continuation: continuation)
             
             dataConnection.stateUpdateHandler = { state in
+                print("FTP DEBUG: Data connection state: \(state)")
                 connectionBox.handleStateUpdate(state)
             }
             
+            print("FTP DEBUG: Starting data connection...")
             dataConnection.start(queue: .global())
         }
     }
     
     private func receiveData(from connection: NWConnection, reportProgress: Bool = false) async throws -> Data {
         var receivedData = Data()
+        print("FTP DEBUG: Starting data reception, reportProgress: \(reportProgress)")
         
         return try await withCheckedThrowingContinuation { continuation in
             let connectionBox = ConnectionBox<Data>(continuation: continuation)
@@ -567,12 +619,14 @@ class FtpClient: @unchecked Sendable {
             func receiveMore() {
                 connection.receive(minimumIncompleteLength: 1, maximumLength: 8192) { data, _, isComplete, error in
                     if let error = error {
+                        print("FTP DEBUG: receiveData error: \(error)")
                         connectionBox.resume(throwing: error)
                         return
                     }
                     
                     if let data = data {
                         receivedData.append(data)
+                        print("FTP DEBUG: Received chunk of \(data.count) bytes, total: \(receivedData.count) bytes")
                         if reportProgress {
                             DispatchQueue.main.async {
                                 self.progressDelegate?.onProgress(transferred: Int64(receivedData.count), total: -1)
@@ -581,8 +635,10 @@ class FtpClient: @unchecked Sendable {
                     }
                     
                     if isComplete {
+                        print("FTP DEBUG: Data reception complete, total bytes: \(receivedData.count)")
                         connectionBox.resume(returning: receivedData)
                     } else {
+                        print("FTP DEBUG: Receiving more data...")
                         receiveMore()
                     }
                 }
@@ -747,7 +803,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.
@@ -790,8 +846,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(
@@ -803,30 +882,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 ftpClient.disconnect()
+        promise.resolve([
+          "clientId": clientId,
+          "disconnected": true
+        ])
+      }
+    }
+
+    // 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 self.ftpClient?.disconnect()
-        self.ftpClient = nil
-        promise.resolve()
+        await ftpClient.disconnect()
+        self.ftpClients.removeValue(forKey: clientId)
+        promise.resolve([
+          "clientId": clientId,
+          "disposed": true
+        ])
       }
     }
 
-    AsyncFunction("ftpList") { (path: String?, promise: Promise) in
+    // 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,
@@ -843,72 +952,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) {
@@ -1007,14 +1207,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
@@ -1022,10 +1225,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.3",
+  "version": "0.2.6",
   "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",