react-native-kookit 0.2.0 → 0.2.2

package/ios/ReactNativeKookitModule.swift

@@ -1,6 +1,502 @@
 import ExpoModulesCore
+import UIKit
+import MediaPlayer
+import AVFoundation
+import Foundation
+import Network
+
+// MARK: - FTP Related Types and Classes
+
+struct FtpConnectionConfig {
+    let host: String
+    let port: Int
+    let username: String
+    let password: String
+    let passive: Bool
+    let timeout: TimeInterval
+    
+    init(host: String, port: Int = 21, username: String, password: String, passive: Bool = true, timeout: TimeInterval = 30.0) {
+        self.host = host
+        self.port = port
+        self.username = username
+        self.password = password
+        self.passive = passive
+        self.timeout = timeout
+    }
+}
+
+struct FtpFileInfo {
+    let name: String
+    let isDirectory: Bool
+    let size: Int64
+    let lastModified: String
+    let permissions: String?
+}
+
+protocol FtpProgressDelegate: AnyObject {
+    func onProgress(transferred: Int64, total: Int64)
+    func onComplete()
+    func onError(error: String)
+}
+
+enum FtpError: Error, LocalizedError {
+    case notConnected
+    case connectionTimeout
+    case connectionCancelled
+    case authenticationFailed(String)
+    case commandFailed(String)
+    case fileNotFound(String)
+    case invalidResponse
+    
+    var errorDescription: String? {
+        switch self {
+        case .notConnected:
+            return "Not connected to FTP server"
+        case .connectionTimeout:
+            return "Connection timeout"
+        case .connectionCancelled:
+            return "Connection cancelled"
+        case .authenticationFailed(let message):
+            return "Authentication failed: \(message)"
+        case .commandFailed(let message):
+            return "Command failed: \(message)"
+        case .fileNotFound(let message):
+            return "File not found: \(message)"
+        case .invalidResponse:
+            return "Invalid response from server"
+        }
+    }
+}
+
+class FtpClient {
+    private var controlConnection: NWConnection?
+    private var isConnected = false
+    private var config: FtpConnectionConfig?
+    private weak var progressDelegate: FtpProgressDelegate?
+    
+    func connect(config: FtpConnectionConfig) async throws {
+        self.config = config
+        
+        let host = NWEndpoint.Host(config.host)
+        let port = NWEndpoint.Port(integerLiteral: UInt16(config.port))
+        let endpoint = NWEndpoint.hostPort(host: host, port: port)
+        
+        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
+                }
+            }
+            
+            controlConnection?.start(queue: .global())
+            
+            // Set timeout
+            DispatchQueue.global().asyncAfter(deadline: .now() + config.timeout) {
+                if !self.isConnected {
+                    self.controlConnection?.cancel()
+                    continuation.resume(throwing: FtpError.connectionTimeout)
+                }
+            }
+        }
+    }
+    
+    func disconnect() async {
+        if isConnected {
+            do {
+                _ = try await sendCommand("QUIT")
+            } catch {
+                // Ignore errors during disconnect
+            }
+        }
+        
+        controlConnection?.cancel()
+        controlConnection = nil
+        isConnected = false
+    }
+    
+    func listFiles(path: String? = nil) async throws -> [FtpFileInfo] {
+        guard isConnected else { throw FtpError.notConnected }
+        
+        let dataConnection = try await enterPassiveMode()
+        
+        let command = path != nil ? "LIST \(path!)" : "LIST"
+        let response = try await sendCommand(command)
+        
+        guard response.hasPrefix("150") || response.hasPrefix("125") else {
+            dataConnection.cancel()
+            throw FtpError.commandFailed("LIST failed: \(response)")
+        }
+        
+        let data = try await receiveData(from: dataConnection)
+        dataConnection.cancel()
+        
+        let finalResponse = try await readResponse()
+        guard finalResponse.hasPrefix("226") else {
+            throw FtpError.commandFailed("LIST completion failed: \(finalResponse)")
+        }
+        
+        return parseListingData(data)
+    }
+    
+    func downloadFile(remotePath: String, localPath: String) async throws {
+        guard isConnected else { throw FtpError.notConnected }
+        
+        let dataConnection = try await enterPassiveMode()
+        
+        let response = try await sendCommand("RETR \(remotePath)")
+        guard response.hasPrefix("150") || response.hasPrefix("125") else {
+            dataConnection.cancel()
+            throw FtpError.commandFailed("Download failed: \(response)")
+        }
+        
+        let localURL = URL(fileURLWithPath: localPath)
+        
+        // Create parent directories if needed
+        try FileManager.default.createDirectory(at: localURL.deletingLastPathComponent(),
+                                              withIntermediateDirectories: true,
+                                              attributes: nil)
+        
+        let data = try await receiveData(from: dataConnection, reportProgress: true)
+        dataConnection.cancel()
+        
+        try data.write(to: localURL)
+        
+        let finalResponse = try await readResponse()
+        guard finalResponse.hasPrefix("226") else {
+            try? FileManager.default.removeItem(at: localURL)
+            throw FtpError.commandFailed("Download completion failed: \(finalResponse)")
+        }
+        
+        progressDelegate?.onComplete()
+    }
+    
+    func uploadFile(localPath: String, remotePath: String) async throws {
+        guard isConnected else { throw FtpError.notConnected }
+        
+        let localURL = URL(fileURLWithPath: localPath)
+        guard FileManager.default.fileExists(atPath: localPath) else {
+            throw FtpError.fileNotFound("Local file not found: \(localPath)")
+        }
+        
+        let data = try Data(contentsOf: localURL)
+        let dataConnection = try await enterPassiveMode()
+        
+        let response = try await sendCommand("STOR \(remotePath)")
+        guard response.hasPrefix("150") || response.hasPrefix("125") else {
+            dataConnection.cancel()
+            throw FtpError.commandFailed("Upload failed: \(response)")
+        }
+        
+        try await sendData(data, to: dataConnection, reportProgress: true)
+        dataConnection.cancel()
+        
+        let finalResponse = try await readResponse()
+        guard finalResponse.hasPrefix("226") else {
+            throw FtpError.commandFailed("Upload completion failed: \(finalResponse)")
+        }
+        
+        progressDelegate?.onComplete()
+    }
+    
+    func deleteFile(remotePath: String, isDirectory: Bool = false) async throws {
+        guard isConnected else { throw FtpError.notConnected }
+        
+        let command = isDirectory ? "RMD \(remotePath)" : "DELE \(remotePath)"
+        let response = try await sendCommand(command)
+        
+        guard response.hasPrefix("250") else {
+            throw FtpError.commandFailed("Delete failed: \(response)")
+        }
+    }
+    
+    func createDirectory(remotePath: String) async throws {
+        guard isConnected else { throw FtpError.notConnected }
+        
+        let response = try await sendCommand("MKD \(remotePath)")
+        guard response.hasPrefix("257") else {
+            throw FtpError.commandFailed("Create directory failed: \(response)")
+        }
+    }
+    
+    func changeDirectory(remotePath: String) async throws {
+        guard isConnected else { throw FtpError.notConnected }
+        
+        let response = try await sendCommand("CWD \(remotePath)")
+        guard response.hasPrefix("250") else {
+            throw FtpError.commandFailed("Change directory failed: \(response)")
+        }
+    }
+    
+    func getCurrentDirectory() async throws -> String {
+        guard isConnected else { throw FtpError.notConnected }
+        
+        let response = try await sendCommand("PWD")
+        guard response.hasPrefix("257") else {
+            throw FtpError.commandFailed("Get current directory failed: \(response)")
+        }
+        
+        // Extract directory from response like: 257 "/home/user" is current directory
+        let pattern = #""([^"]+)""#
+        if let range = response.range(of: pattern, options: .regularExpression) {
+            let match = String(response[range])
+            return String(match.dropFirst().dropLast())
+        }
+        
+        throw FtpError.commandFailed("Failed to parse current directory response: \(response)")
+    }
+    
+    func setProgressDelegate(_ delegate: FtpProgressDelegate?) {
+        self.progressDelegate = delegate
+    }
+    
+    // MARK: - Private Methods
+    
+    private func performAuthentication() async throws {
+        // Read welcome message
+        let welcome = try await readResponse()
+        guard welcome.hasPrefix("220") else {
+            throw FtpError.authenticationFailed("Server not ready: \(welcome)")
+        }
+        
+        // Send username
+        let userResponse = try await sendCommand("USER \(config!.username)")
+        guard userResponse.hasPrefix("331") || userResponse.hasPrefix("230") else {
+            throw FtpError.authenticationFailed("Username rejected: \(userResponse)")
+        }
+        
+        // Send password if needed
+        if userResponse.hasPrefix("331") {
+            let passResponse = try await sendCommand("PASS \(config!.password)")
+            guard passResponse.hasPrefix("230") else {
+                throw FtpError.authenticationFailed("Authentication failed: \(passResponse)")
+            }
+        }
+        
+        // Set binary mode
+        let typeResponse = try await sendCommand("TYPE I")
+        guard typeResponse.hasPrefix("200") else {
+            throw FtpError.commandFailed("Failed to set binary mode: \(typeResponse)")
+        }
+    }
+    
+    private func sendCommand(_ command: String) async throws -> String {
+        guard let connection = controlConnection else {
+            throw FtpError.notConnected
+        }
+        
+        let commandData = "\(command)\r\n".data(using: .utf8)!
+        
+        return try await withCheckedThrowingContinuation { continuation in
+            connection.send(content: commandData, completion: .contentProcessed { error in
+                if let error = error {
+                    continuation.resume(throwing: error)
+                } else {
+                    Task {
+                        do {
+                            let response = try await self.readResponse()
+                            continuation.resume(returning: response)
+                        } catch {
+                            continuation.resume(throwing: error)
+                        }
+                    }
+                }
+            })
+        }
+    }
+    
+    private func readResponse() async throws -> String {
+        guard let connection = controlConnection else {
+            throw FtpError.notConnected
+        }
+        
+        return try await withCheckedThrowingContinuation { continuation in
+            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))
+                } else {
+                    continuation.resume(throwing: FtpError.invalidResponse)
+                }
+            }
+        }
+    }
+    
+    private func enterPassiveMode() async throws -> NWConnection {
+        let response = try await sendCommand("PASV")
+        guard response.hasPrefix("227") else {
+            throw FtpError.commandFailed("Failed to enter passive mode: \(response)")
+        }
+        
+        // Parse passive mode response: 227 Entering Passive Mode (h1,h2,h3,h4,p1,p2)
+        let pattern = #"\((\d+),(\d+),(\d+),(\d+),(\d+),(\d+)\)"#
+        let regex = try NSRegularExpression(pattern: pattern)
+        let nsString = response as NSString
+        
+        guard let match = regex.firstMatch(in: response, range: NSRange(location: 0, length: nsString.length)) else {
+            throw FtpError.commandFailed("Failed to parse passive mode response: \(response)")
+        }
+        
+        let h1 = Int(nsString.substring(with: match.range(at: 1)))!
+        let h2 = Int(nsString.substring(with: match.range(at: 2)))!
+        let h3 = Int(nsString.substring(with: match.range(at: 3)))!
+        let h4 = Int(nsString.substring(with: match.range(at: 4)))!
+        let p1 = Int(nsString.substring(with: match.range(at: 5)))!
+        let p2 = Int(nsString.substring(with: match.range(at: 6)))!
+        
+        let host = "\(h1).\(h2).\(h3).\(h4)"
+        let port = p1 * 256 + p2
+        
+        let dataHost = NWEndpoint.Host(host)
+        let dataPort = NWEndpoint.Port(integerLiteral: UInt16(port))
+        let dataEndpoint = NWEndpoint.hostPort(host: dataHost, port: dataPort)
+        
+        let dataConnection = NWConnection(to: dataEndpoint, using: .tcp)
+        
+        return try await withCheckedThrowingContinuation { continuation in
+            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
+                }
+            }
+            
+            dataConnection.start(queue: .global())
+        }
+    }
+    
+    private func receiveData(from connection: NWConnection, reportProgress: Bool = false) async throws -> Data {
+        var receivedData = Data()
+        
+        return try await withCheckedThrowingContinuation { continuation in
+            func receiveMore() {
+                connection.receive(minimumIncompleteLength: 1, maximumLength: 8192) { data, _, isComplete, error in
+                    if let error = error {
+                        continuation.resume(throwing: error)
+                        return
+                    }
+                    
+                    if let data = data {
+                        receivedData.append(data)
+                        if reportProgress {
+                            self.progressDelegate?.onProgress(transferred: Int64(receivedData.count), total: -1)
+                        }
+                    }
+                    
+                    if isComplete {
+                        continuation.resume(returning: receivedData)
+                    } else {
+                        receiveMore()
+                    }
+                }
+            }
+            receiveMore()
+        }
+    }
+    
+    private func sendData(_ data: Data, to connection: NWConnection, reportProgress: Bool = false) async throws {
+        let chunkSize = 8192
+        let totalSize = data.count
+        var sentBytes = 0
+        
+        for i in stride(from: 0, to: totalSize, by: chunkSize) {
+            let endIndex = min(i + chunkSize, totalSize)
+            let chunk = data.subdata(in: i..<endIndex)
+            
+            try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
+                connection.send(content: chunk, completion: .contentProcessed { error in
+                    if let error = error {
+                        continuation.resume(throwing: error)
+                    } else {
+                        sentBytes += chunk.count
+                        if reportProgress {
+                            self.progressDelegate?.onProgress(transferred: Int64(sentBytes), total: Int64(totalSize))
+                        }
+                        continuation.resume()
+                    }
+                })
+            }
+        }
+    }
+    
+    private func parseListingData(_ data: Data) -> [FtpFileInfo] {
+        guard let string = String(data: data, encoding: .utf8) else { return [] }
+        
+        let lines = string.components(separatedBy: .newlines)
+        var files: [FtpFileInfo] = []
+        
+        for line in lines {
+            if let fileInfo = parseListing(line) {
+                files.append(fileInfo)
+            }
+        }
+        
+        return files
+    }
+    
+    private func parseListing(_ line: String) -> FtpFileInfo? {
+        let trimmedLine = line.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmedLine.isEmpty else { return nil }
+        
+        // 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 }
+        
+        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(
+            name: name,
+            isDirectory: isDirectory,
+            size: size,
+            lastModified: lastModified,
+            permissions: permissions
+        )
+    }
+}
+
+// MARK: - Main Module
 
 public class ReactNativeKookitModule: Module {
+  private var volumeView: MPVolumeView?
+  private var volumeObserver: NSKeyValueObservation?
+  private var isVolumeKeyInterceptionEnabled = false
+  private var previousVolume: Float = 0.0
+  private var ftpClient: FtpClient?
+  
   // Each module class must implement the definition function. The definition consists of components
   // that describes the module's functionality and behavior.
   // See https://docs.expo.dev/modules/module-api for more details about available components.
@@ -16,7 +512,7 @@ public class ReactNativeKookitModule: Module {
     ])
 
     // Defines event names that the module can send to JavaScript.
-    Events("onChange")
+    Events("onChange", "onVolumeButtonPressed", "onFtpProgress", "onFtpComplete", "onFtpError")
 
     // Defines a JavaScript synchronous function that runs the native code on the JavaScript thread.
     Function("hello") {
@@ -32,8 +528,141 @@ public class ReactNativeKookitModule: Module {
       ])
     }
 
-    // Enables the module to be used as a native view. Definition components that are accepted as part of the
-    // view definition: Prop, Events.
+    // Enables volume key interception
+    Function("enableVolumeKeyInterception") {
+      self.enableVolumeKeyInterception()
+    }
+
+    // Disables volume key interception
+    Function("disableVolumeKeyInterception") {
+      self.disableVolumeKeyInterception()
+    }
+
+    // FTP Functions
+    AsyncFunction("ftpConnect") { (config: [String: Any], promise: Promise) in
+      Task {
+        do {
+          let ftpConfig = FtpConnectionConfig(
+            host: config["host"] as! String,
+            port: config["port"] as? Int ?? 21,
+            username: config["username"] as! String,
+            password: config["password"] as! String,
+            passive: config["passive"] as? Bool ?? true,
+            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()
+        } catch {
+          promise.reject("FTP_CONNECT_ERROR", error.localizedDescription)
+        }
+      }
+    }
+
+    AsyncFunction("ftpDisconnect") { (promise: Promise) in
+      Task {
+        do {
+          await self.ftpClient?.disconnect()
+          self.ftpClient = nil
+          promise.resolve()
+        } catch {
+          promise.reject("FTP_DISCONNECT_ERROR", error.localizedDescription)
+        }
+      }
+    }
+
+    AsyncFunction("ftpList") { (path: String?, promise: Promise) in
+      Task {
+        do {
+          let files = try await self.ftpClient?.listFiles(path: path) ?? []
+          let result = files.map { file in
+            [
+              "name": file.name,
+              "isDirectory": file.isDirectory,
+              "size": file.size,
+              "lastModified": file.lastModified,
+              "permissions": file.permissions as Any
+            ]
+          }
+          promise.resolve(result)
+        } catch {
+          promise.reject("FTP_LIST_ERROR", error.localizedDescription)
+        }
+      }
+    }
+
+    AsyncFunction("ftpDownload") { (remotePath: String, localPath: String, promise: Promise) in
+      Task {
+        do {
+          try await self.ftpClient?.downloadFile(remotePath: remotePath, localPath: localPath)
+          promise.resolve()
+        } catch {
+          promise.reject("FTP_DOWNLOAD_ERROR", error.localizedDescription)
+        }
+      }
+    }
+
+    AsyncFunction("ftpUpload") { (localPath: String, remotePath: String, promise: Promise) in
+      Task {
+        do {
+          try await self.ftpClient?.uploadFile(localPath: localPath, remotePath: remotePath)
+          promise.resolve()
+        } catch {
+          promise.reject("FTP_UPLOAD_ERROR", error.localizedDescription)
+        }
+      }
+    }
+
+    AsyncFunction("ftpDelete") { (remotePath: String, isDirectory: Bool?, promise: Promise) in
+      Task {
+        do {
+          try await self.ftpClient?.deleteFile(remotePath: remotePath, isDirectory: isDirectory ?? false)
+          promise.resolve()
+        } catch {
+          promise.reject("FTP_DELETE_ERROR", error.localizedDescription)
+        }
+      }
+    }
+
+    AsyncFunction("ftpCreateDirectory") { (remotePath: String, promise: Promise) in
+      Task {
+        do {
+          try await self.ftpClient?.createDirectory(remotePath: remotePath)
+          promise.resolve()
+        } catch {
+          promise.reject("FTP_CREATE_DIR_ERROR", error.localizedDescription)
+        }
+      }
+    }
+
+    AsyncFunction("ftpChangeDirectory") { (remotePath: String, promise: Promise) in
+      Task {
+        do {
+          try await self.ftpClient?.changeDirectory(remotePath: remotePath)
+          promise.resolve()
+        } catch {
+          promise.reject("FTP_CHANGE_DIR_ERROR", error.localizedDescription)
+        }
+      }
+    }
+
+    AsyncFunction("ftpGetCurrentDirectory") { (promise: Promise) in
+      Task {
+        do {
+          let currentDir = try await self.ftpClient?.getCurrentDirectory() ?? "/"
+          promise.resolve(currentDir)
+        } catch {
+          promise.reject("FTP_PWD_ERROR", error.localizedDescription)
+        }
+      }
+    }
+
+    // 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) {
       // Defines a setter for the `url` prop.
       Prop("url") { (view: ReactNativeKookitView, url: URL) in
@@ -45,4 +674,110 @@ public class ReactNativeKookitModule: Module {
       Events("onLoad")
     }
   }
+  
+  private func enableVolumeKeyInterception() {
+    guard !isVolumeKeyInterceptionEnabled else { return }
+    
+    isVolumeKeyInterceptionEnabled = true
+    
+    DispatchQueue.main.async {
+      // Store initial volume
+      let audioSession = AVAudioSession.sharedInstance()
+      self.previousVolume = audioSession.outputVolume
+      
+      // Configure audio session to allow volume button interception
+      do {
+        try AVAudioSession.sharedInstance().setCategory(.ambient, mode: .default, options: [.mixWithOthers])
+        try AVAudioSession.sharedInstance().setActive(true)
+      } catch {
+        print("Failed to configure audio session: \(error)")
+      }
+      
+      // Create a hidden volume view to prevent system volume HUD from showing
+      self.volumeView = MPVolumeView(frame: CGRect(x: -1000, y: -1000, width: 1, height: 1))
+      self.volumeView?.clipsToBounds = true
+      self.volumeView?.alpha = 0.01  // Make it nearly invisible but still functional
+      self.volumeView?.isUserInteractionEnabled = false
+      
+      // Add volume view to the key window
+      if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
+         let keyWindow = windowScene.windows.first(where: { $0.isKeyWindow }) {
+        keyWindow.addSubview(self.volumeView!)
+        keyWindow.sendSubviewToBack(self.volumeView!)
+      }
+      
+      // Set up volume observation with a small delay to ensure proper setup
+      DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
+        self.volumeObserver = audioSession.observe(\.outputVolume, options: [.new]) { [weak self] (audioSession, change) in
+          guard let self = self, self.isVolumeKeyInterceptionEnabled else { return }
+          
+          if let newVolume = change.newValue {
+            DispatchQueue.main.async {
+              // Determine if volume was increased or decreased
+              let key = newVolume > self.previousVolume ? "up" : "down"
+              
+              // Send event to JavaScript
+              self.sendEvent("onVolumeButtonPressed", [
+                "key": key
+              ])
+              
+              // Reset volume to prevent actual volume change
+              if let volumeSlider = self.volumeView?.subviews.compactMap({ $0 as? UISlider }).first {
+                volumeSlider.setValue(self.previousVolume, animated: false)
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+  private func disableVolumeKeyInterception() {
+    guard isVolumeKeyInterceptionEnabled else { return }
+    
+    isVolumeKeyInterceptionEnabled = false
+    
+    DispatchQueue.main.async {
+      // Remove volume observer
+      self.volumeObserver?.invalidate()
+      self.volumeObserver = nil
+      
+      // Remove volume view
+      self.volumeView?.removeFromSuperview()
+      self.volumeView = nil
+      
+      // Reset audio session
+      do {
+        try AVAudioSession.sharedInstance().setActive(false)
+      } catch {
+        print("Failed to deactivate audio session: \(error)")
+      }
+    }
+  }
+}
+
+// Helper class to handle FTP progress callbacks
+private class FtpProgressDelegateImpl: FtpProgressDelegate {
+  weak var module: ReactNativeKookitModule?
+  
+  init(module: ReactNativeKookitModule) {
+    self.module = module
+  }
+  
+  func onProgress(transferred: Int64, total: Int64) {
+    let percentage = total > 0 ? Int((transferred * 100) / total) : 0
+    module?.sendEvent("onFtpProgress", [
+      "transferred": transferred,
+      "total": total,
+      "percentage": percentage
+    ])
+  }
+  
+  func onComplete() {
+    module?.sendEvent("onFtpComplete")
+  }
+  
+  func onError(error: String) {
+    module?.sendEvent("onFtpError", ["error": error])
+  }
 }