如何在Android Studio中用Kotlin通过FTP上传文件/图片？求技术指导

Hey there! Since you're coming from Python and already know your way around FTP, let’s break down how to handle FTP uploads in Kotlin smoothly. I’ll walk you through practical steps and code examples tailored for uploading images and text files—no confusing jargon, just what you need to get your app up and running.

Kotlin plays nicely with Java libraries, and the go-to choice for FTP operations is Apache Commons Net. It’s stable, well-documented, and handles all the low-level FTP details for you.

To add it to your project (using Gradle):

dependencies {
    implementation 'commons-net:commons-net:3.9.0' // Use the latest version available
}

Let’s create a simple utility class to encapsulate connection, upload, and cleanup logic—this keeps your code clean and avoid repeating boilerplate.

import org.apache.commons.net.ftp.FTPClient
import java.io.File
import java.io.IOException

class FtpUploader(
    private val server: String,
    private val port: Int,
    private val username: String,
    private val password: String
) {
    private val ftpClient = FTPClient()

    init {
        try {
            // Connect to the FTP server
            ftpClient.connect(server, port)
            // Authenticate with your credentials
            if (!ftpClient.login(username, password)) {
                throw IOException("Failed to log in to FTP server—check your username/password.")
            }
            // Enable passive mode (critical for most servers to avoid connection timeouts)
            ftpClient.enterLocalPassiveMode()
            // Set file type to binary (works for images, text, and all other file types)
            ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE)
        } catch (e: IOException) {
            e.printStackTrace()
            disconnect() // Clean up if connection fails
        }
    }

    // Generic method to upload any file
    fun uploadFile(localPath: String, remotePath: String): Boolean {
        return try {
            val localFile = File(localPath)
            // Use Kotlin's `use` function to auto-close the input stream
            localFile.inputStream().use { inputStream ->
                ftpClient.storeFile(remotePath, inputStream)
                // Verify the upload completed successfully
                ftpClient.completePendingCommand()
            }
        } catch (e: IOException) {
            e.printStackTrace()
            false
        }
    }

    // Always disconnect when done to free resources
    fun disconnect() {
        try {
            if (ftpClient.isConnected) {
                ftpClient.logout()
                ftpClient.disconnect()
            }
        } catch (e: IOException) {
            e.printStackTrace()
        }
    }
}

Now you can easily upload both text and image files with just a few lines of code:

fun main() {
    // Initialize the uploader with your server details
    val ftpUploader = FtpUploader(
        server = "your-ftp-server.com",
        port = 21, // Default FTP port, adjust if yours is different
        username = "your-ftp-username",
        password = "your-ftp-password"
    )

    // Upload a text file
    val textUploadSuccess = ftpUploader.uploadFile(
        localPath = "/home/you/documents/note.txt",
        remotePath = "/server/files/note.txt"
    )
    println("Text file upload status: ${if (textUploadSuccess) "Success!" else "Failed"}")

    // Upload an image (works for PNG, JPG, etc.)
    val imageUploadSuccess = ftpUploader.uploadFile(
        localPath = "/home/you/photos/vacation.png",
        remotePath = "/server/images/vacation.png"
    )
    println("Image upload status: ${if (imageUploadSuccess) "Success!" else "Failed"}")

    // Don't forget to disconnect!
    ftpUploader.disconnect()
}

• Passive Mode: Always enable enterLocalPassiveMode()—many servers block active mode connections, which will cause timeouts.
• Binary File Type: Using BINARY_FILE_TYPE ensures no corruption for images and avoids encoding issues with text files (ASCII mode can mangle non-English characters).
• Error Handling: In production code, replace printStackTrace() with meaningful error handling (e.g., showing a user-friendly message, retrying failed uploads).
• Permissions: Double-check that your FTP account has write access to the remote directory you’re uploading to.
• Async Operations: If you’re building an Android or desktop app, use Kotlin coroutines to run uploads on a background thread (so you don’t block the UI):

  import kotlinx.coroutines.Dispatchers
  import kotlinx.coroutines.withContext
  
  suspend fun uploadFileAsync(localPath: String, remotePath: String): Boolean = withContext(Dispatchers.IO) {
      uploadFile(localPath, remotePath)
  }
  

内容的提问来源于stack exchange，提问作者BigZee