react-native-kookit 0.2.2 → 0.2.3

package/ios/ReactNativeKookitModule.swift

@@ -68,9 +68,152 @@ enum FtpError: Error, LocalizedError {
     }
 }
 
-class FtpClient {
+// Helper class to safely manage continuation resumption
+private class ConnectionBox<T>: @unchecked Sendable {
+    private let continuation: CheckedContinuation<T, Error>
+    private var hasResumed = false
+    private let queue = DispatchQueue(label: "ConnectionBox")
+    
+    init(continuation: CheckedContinuation<T, Error>) {
+        self.continuation = continuation
+    }
+    
+    func resume(returning value: T) {
+        queue.sync {
+            guard !hasResumed else { return }
+            hasResumed = true
+            continuation.resume(returning: value)
+        }
+    }
+    
+    func resume(throwing error: Error) {
+        queue.sync {
+            guard !hasResumed else { return }
+            hasResumed = true
+            continuation.resume(throwing: error)
+        }
+    }
+    
+    func resume() where T == Void {
+        queue.sync {
+            guard !hasResumed else { return }
+            hasResumed = true
+            continuation.resume()
+        }
+    }
+}
+
+// Helper class specifically for NWConnection state handling
+private class NWConnectionBox: @unchecked Sendable {
+    private let connection: NWConnection
+    private let continuation: CheckedContinuation<NWConnection, Error>
+    private var hasResumed = false
+    private let queue = DispatchQueue(label: "NWConnectionBox")
+    
+    init(connection: NWConnection, continuation: CheckedContinuation<NWConnection, Error>) {
+        self.connection = connection
+        self.continuation = continuation
+    }
+    
+    func handleStateUpdate(_ state: NWConnection.State) {
+        queue.sync {
+            guard !hasResumed else { return }
+            
+            switch state {
+            case .ready:
+                hasResumed = true
+                continuation.resume(returning: connection)
+            case .failed(let error):
+                hasResumed = true
+                continuation.resume(throwing: error)
+            case .cancelled:
+                hasResumed = true
+                continuation.resume(throwing: FtpError.connectionCancelled)
+            default:
+                break
+            }
+        }
+    }
+}
+
+// Helper class for FTP connection authentication
+private class FtpConnectionBox: @unchecked Sendable {
+    private let ftpClient: FtpClient
+    private let continuation: CheckedContinuation<Void, Error>
+    private var hasResumed = false
+    private let queue = DispatchQueue(label: "FtpConnectionBox")
+    private var timeoutTask: DispatchWorkItem?
+    
+    init(ftpClient: FtpClient, continuation: CheckedContinuation<Void, Error>) {
+        self.ftpClient = ftpClient
+        self.continuation = continuation
+    }
+    
+    func setTimeoutTask(_ task: DispatchWorkItem) {
+        self.timeoutTask = task
+    }
+    
+    func handleStateUpdate(_ state: NWConnection.State) {
+        queue.async {
+            guard !self.hasResumed else { return }
+            
+            switch state {
+            case .ready:
+                self.timeoutTask?.cancel()
+                Task {
+                    do {
+                        try await self.ftpClient.performAuthentication()
+                        self.ftpClient.isConnected = true
+                        self.queue.sync {
+                            if !self.hasResumed {
+                                self.hasResumed = true
+                                self.continuation.resume()
+                            }
+                        }
+                    } catch {
+                        self.queue.sync {
+                            if !self.hasResumed {
+                                self.hasResumed = true
+                                self.continuation.resume(throwing: error)
+                            }
+                        }
+                    }
+                }
+            case .failed(let error):
+                self.timeoutTask?.cancel()
+                self.queue.sync {
+                    if !self.hasResumed {
+                        self.hasResumed = true
+                        self.continuation.resume(throwing: error)
+                    }
+                }
+            case .cancelled:
+                self.timeoutTask?.cancel()
+                self.queue.sync {
+                    if !self.hasResumed {
+                        self.hasResumed = true
+                        self.continuation.resume(throwing: FtpError.connectionCancelled)
+                    }
+                }
+            default:
+                break
+            }
+        }
+    }
+    
+    func handleTimeout() {
+        queue.sync {
+            if !hasResumed {
+                hasResumed = true
+                continuation.resume(throwing: FtpError.connectionTimeout)
+            }
+        }
+    }
+}
+
+class FtpClient: @unchecked Sendable {
     private var controlConnection: NWConnection?
-    private var isConnected = false
+    var isConnected = false
     private var config: FtpConnectionConfig?
     private weak var progressDelegate: FtpProgressDelegate?
     
@@ -84,36 +227,24 @@ class FtpClient {
         controlConnection = NWConnection(to: endpoint, using: .tcp)
         
         return try await withCheckedThrowingContinuation { continuation in
-            controlConnection?.stateUpdateHandler = { state in
-                switch state {
-                case .ready:
-                    Task {
-                        do {
-                            try await self.performAuthentication()
-                            self.isConnected = true
-                            continuation.resume()
-                        } catch {
-                            continuation.resume(throwing: error)
-                        }
-                    }
-                case .failed(let error):
-                    continuation.resume(throwing: error)
-                case .cancelled:
-                    continuation.resume(throwing: FtpError.connectionCancelled)
-                default:
-                    break
+            let connectionBox = FtpConnectionBox(ftpClient: self, continuation: continuation)
+            
+            let timeoutTask = DispatchWorkItem {
+                if !self.isConnected {
+                    self.controlConnection?.cancel()
                 }
             }
             
+            connectionBox.setTimeoutTask(timeoutTask)
+            
+            controlConnection?.stateUpdateHandler = { state in
+                connectionBox.handleStateUpdate(state)
+            }
+            
             controlConnection?.start(queue: .global())
             
             // Set timeout
-            DispatchQueue.global().asyncAfter(deadline: .now() + config.timeout) {
-                if !self.isConnected {
-                    self.controlConnection?.cancel()
-                    continuation.resume(throwing: FtpError.connectionTimeout)
-                }
-            }
+            DispatchQueue.global().asyncAfter(deadline: .now() + config.timeout, execute: timeoutTask)
         }
     }
     
@@ -133,26 +264,48 @@ class FtpClient {
     
     func listFiles(path: String? = nil) async throws -> [FtpFileInfo] {
         guard isConnected else { throw FtpError.notConnected }
-        
+
+        // Set ASCII mode for directory listings
+        print("FTP DEBUG: Setting ASCII mode for directory listing")
+        let asciiResponse = try await sendCommand("TYPE A")
+        print("FTP DEBUG: ASCII mode response: \(asciiResponse)")
+        if !asciiResponse.hasPrefix("200") {
+            print("FTP DEBUG: Warning - Failed to set ASCII mode: \(asciiResponse)")
+        }
+
         let dataConnection = try await enterPassiveMode()
-        
+
         let command = path != nil ? "LIST \(path!)" : "LIST"
+        print("FTP DEBUG: Sending command: \(command)")
         let response = try await sendCommand(command)
-        
+        print("FTP DEBUG: LIST command response: \(response)")
+
         guard response.hasPrefix("150") || response.hasPrefix("125") else {
             dataConnection.cancel()
             throw FtpError.commandFailed("LIST failed: \(response)")
         }
-        
+
         let data = try await receiveData(from: dataConnection)
+        print("FTP DEBUG: Received data length: \(data.count) bytes")
+        if let dataString = String(data: data, encoding: .utf8) {
+            print("FTP DEBUG: Received data content: '\(dataString)'")
+        }
         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)")
         }
+
+        let files = parseListingData(data)
+        print("FTP DEBUG: Parsed \(files.count) files")
+        
+        // Reset to binary mode for file transfers
+        let binaryResponse = try await sendCommand("TYPE I")
+        print("FTP DEBUG: Reset to binary mode response: \(binaryResponse)")
         
-        return parseListingData(data)
+        return files
     }
     
     func downloadFile(remotePath: String, localPath: String) async throws {
@@ -268,7 +421,7 @@ class FtpClient {
     
     // MARK: - Private Methods
     
-    private func performAuthentication() async throws {
+    func performAuthentication() async throws {
         // Read welcome message
         let welcome = try await readResponse()
         guard welcome.hasPrefix("220") else {
@@ -304,16 +457,18 @@ class FtpClient {
         let commandData = "\(command)\r\n".data(using: .utf8)!
         
         return try await withCheckedThrowingContinuation { continuation in
+            let connectionBox = ConnectionBox<String>(continuation: continuation)
+            
             connection.send(content: commandData, completion: .contentProcessed { error in
                 if let error = error {
-                    continuation.resume(throwing: error)
+                    connectionBox.resume(throwing: error)
                 } else {
                     Task {
                         do {
                             let response = try await self.readResponse()
-                            continuation.resume(returning: response)
+                            connectionBox.resume(returning: response)
                         } catch {
-                            continuation.resume(throwing: error)
+                            connectionBox.resume(throwing: error)
                         }
                     }
                 }
@@ -327,13 +482,35 @@ class FtpClient {
         }
         
         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 {
-                    continuation.resume(throwing: error)
-                } else if let data = data, let response = String(data: data, encoding: .utf8) {
-                    continuation.resume(returning: response.trimmingCharacters(in: .whitespacesAndNewlines))
+                    connectionBox.resume(throwing: error)
+                } else if let data = data {
+                    // Try multiple encodings for FTP responses
+                    var response: String?
+                    
+                    // Try UTF-8 first
+                    if let utf8Response = String(data: data, encoding: .utf8) {
+                        response = utf8Response
+                    }
+                    // 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
+                    }
+                    // Try ASCII as fallback
+                    else if let asciiResponse = String(data: data, encoding: .ascii) {
+                        response = asciiResponse
+                    }
+                    
+                    if let validResponse = response {
+                        connectionBox.resume(returning: validResponse.trimmingCharacters(in: .whitespacesAndNewlines))
+                    } else {
+                        connectionBox.resume(throwing: FtpError.invalidResponse)
+                    }
                 } else {
-                    continuation.resume(throwing: FtpError.invalidResponse)
+                    connectionBox.resume(throwing: FtpError.invalidResponse)
                 }
             }
         }
@@ -371,17 +548,10 @@ class FtpClient {
         let dataConnection = NWConnection(to: dataEndpoint, using: .tcp)
         
         return try await withCheckedThrowingContinuation { continuation in
+            let connectionBox = NWConnectionBox(connection: dataConnection, continuation: continuation)
+            
             dataConnection.stateUpdateHandler = { state in
-                switch state {
-                case .ready:
-                    continuation.resume(returning: dataConnection)
-                case .failed(let error):
-                    continuation.resume(throwing: error)
-                case .cancelled:
-                    continuation.resume(throwing: FtpError.connectionCancelled)
-                default:
-                    break
-                }
+                connectionBox.handleStateUpdate(state)
             }
             
             dataConnection.start(queue: .global())
@@ -392,22 +562,26 @@ class FtpClient {
         var receivedData = Data()
         
         return try await withCheckedThrowingContinuation { continuation in
+            let connectionBox = ConnectionBox<Data>(continuation: continuation)
+            
             func receiveMore() {
                 connection.receive(minimumIncompleteLength: 1, maximumLength: 8192) { data, _, isComplete, error in
                     if let error = error {
-                        continuation.resume(throwing: error)
+                        connectionBox.resume(throwing: error)
                         return
                     }
                     
                     if let data = data {
                         receivedData.append(data)
                         if reportProgress {
-                            self.progressDelegate?.onProgress(transferred: Int64(receivedData.count), total: -1)
+                            DispatchQueue.main.async {
+                                self.progressDelegate?.onProgress(transferred: Int64(receivedData.count), total: -1)
+                            }
                         }
                     }
                     
                     if isComplete {
-                        continuation.resume(returning: receivedData)
+                        connectionBox.resume(returning: receivedData)
                     } else {
                         receiveMore()
                     }
@@ -427,15 +601,19 @@ class FtpClient {
             let chunk = data.subdata(in: i..<endIndex)
             
             try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
+                let connectionBox = ConnectionBox<Void>(continuation: continuation)
+                
                 connection.send(content: chunk, completion: .contentProcessed { error in
                     if let error = error {
-                        continuation.resume(throwing: error)
+                        connectionBox.resume(throwing: error)
                     } else {
                         sentBytes += chunk.count
                         if reportProgress {
-                            self.progressDelegate?.onProgress(transferred: Int64(sentBytes), total: Int64(totalSize))
+                            DispatchQueue.main.async {
+                                self.progressDelegate?.onProgress(transferred: Int64(sentBytes), total: Int64(totalSize))
+                            }
                         }
-                        continuation.resume()
+                        connectionBox.resume()
                     }
                 })
             }
@@ -443,48 +621,122 @@ class FtpClient {
     }
     
     private func parseListingData(_ data: Data) -> [FtpFileInfo] {
-        guard let string = String(data: data, encoding: .utf8) else { return [] }
+        print("FTP DEBUG: Raw data length: \(data.count) bytes")
+        print("FTP DEBUG: Raw data hex: \(data.map { String(format: "%02x", $0) }.joined())")
         
-        let lines = string.components(separatedBy: .newlines)
-        var files: [FtpFileInfo] = []
+        // Try different encodings, prioritizing Chinese encodings
+        var string: String?
+        var encoding: String.Encoding = .utf8
+        
+        // Try UTF-8 first
+        if let utf8String = String(data: data, encoding: .utf8) {
+            string = utf8String
+            encoding = .utf8
+            print("FTP DEBUG: Successfully decoded with UTF-8")
+        }
+        // Try GBK/GB2312 for Chinese
+        else if let gbkString = String(data: data, encoding: String.Encoding(rawValue: CFStringConvertEncodingToNSStringEncoding(CFStringEncoding(CFStringEncodings.GB_18030_2000.rawValue)))) {
+            string = gbkString
+            encoding = String.Encoding(rawValue: CFStringConvertEncodingToNSStringEncoding(CFStringEncoding(CFStringEncodings.GB_18030_2000.rawValue)))
+            print("FTP DEBUG: Successfully decoded with GBK/GB18030")
+        }
+        // Try Big5 for Traditional Chinese
+        else if let big5String = String(data: data, encoding: String.Encoding(rawValue: CFStringConvertEncodingToNSStringEncoding(CFStringEncoding(CFStringEncodings.big5.rawValue)))) {
+            string = big5String
+            encoding = String.Encoding(rawValue: CFStringConvertEncodingToNSStringEncoding(CFStringEncoding(CFStringEncodings.big5.rawValue)))
+            print("FTP DEBUG: Successfully decoded with Big5")
+        }
+        // Try ASCII
+        else if let asciiString = String(data: data, encoding: .ascii) {
+            string = asciiString
+            encoding = .ascii
+            print("FTP DEBUG: Successfully decoded with ASCII")
+        }
+        // Try Latin1 (ISO-8859-1)
+        else if let latin1String = String(data: data, encoding: .isoLatin1) {
+            string = latin1String
+            encoding = .isoLatin1
+            print("FTP DEBUG: Successfully decoded with Latin1")
+        }
+        // Try Windows-1252
+        else if let windowsString = String(data: data, encoding: .windowsCP1252) {
+            string = windowsString
+            encoding = .windowsCP1252
+            print("FTP DEBUG: Successfully decoded with Windows-1252")
+        }
+        else {
+            print("FTP DEBUG: Failed to decode data with any encoding")
+            print("FTP DEBUG: Raw bytes: \(Array(data))")
+            return []
+        }
+
+        guard let decodedString = string else {
+            print("FTP DEBUG: No valid string found")
+            return []
+        }
+
+        print("FTP DEBUG: Decoded string with \(encoding): '\(decodedString)'")
+        print("FTP DEBUG: String length: \(decodedString.count) characters")
         
-        for line in lines {
+        let lines = decodedString.components(separatedBy: .newlines)
+        print("FTP DEBUG: Found \(lines.count) lines")
+        var files: [FtpFileInfo] = []
+
+        for (index, line) in lines.enumerated() {
+            print("FTP DEBUG: Processing line \(index): '\(line)'")
             if let fileInfo = parseListing(line) {
                 files.append(fileInfo)
+                print("FTP DEBUG: Parsed file: \(fileInfo.name), isDirectory: \(fileInfo.isDirectory)")
+            } else {
+                print("FTP DEBUG: Failed to parse line \(index)")
             }
         }
-        
+
+        print("FTP DEBUG: Successfully parsed \(files.count) files")
         return files
     }
     
     private func parseListing(_ line: String) -> FtpFileInfo? {
         let trimmedLine = line.trimmingCharacters(in: .whitespacesAndNewlines)
-        guard !trimmedLine.isEmpty else { return nil }
-        
+        guard !trimmedLine.isEmpty else {
+            print("FTP DEBUG: Line is empty after trimming")
+            return nil
+        }
+
+        print("FTP DEBUG: Parsing line: '\(trimmedLine)'")
+
         // Parse Unix-style listing: drwxr-xr-x 3 user group 4096 Mar 15 10:30 dirname
         let components = trimmedLine.components(separatedBy: .whitespaces).filter { !$0.isEmpty }
-        guard components.count >= 9 else { return nil }
-        
+        print("FTP DEBUG: Components count: \(components.count), components: \(components)")
+
+        guard components.count >= 9 else {
+            print("FTP DEBUG: Not enough components (\(components.count)), expected at least 9")
+            return nil
+        }
+
         let permissions = components[0]
         let isDirectory = permissions.hasPrefix("d")
         let size = isDirectory ? 0 : Int64(components[4]) ?? 0
-        
+
         // Reconstruct filename (can contain spaces)
         let name = components[8...].joined(separator: " ")
-        
+
         // Parse date
         let month = components[5]
         let day = components[6]
         let yearOrTime = components[7]
         let lastModified = "\(month) \(day) \(yearOrTime)"
-        
-        return FtpFileInfo(
+
+        let fileInfo = FtpFileInfo(
             name: name,
             isDirectory: isDirectory,
             size: size,
             lastModified: lastModified,
             permissions: permissions
         )
+
+        print("FTP DEBUG: Successfully parsed file: \(fileInfo)")
+        return fileInfo
     }
 }
 
@@ -565,13 +817,9 @@ public class ReactNativeKookitModule: Module {
 
     AsyncFunction("ftpDisconnect") { (promise: Promise) in
       Task {
-        do {
-          await self.ftpClient?.disconnect()
-          self.ftpClient = nil
-          promise.resolve()
-        } catch {
-          promise.reject("FTP_DISCONNECT_ERROR", error.localizedDescription)
-        }
+        await self.ftpClient?.disconnect()
+        self.ftpClient = nil
+        promise.resolve()
       }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-kookit",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "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",