Trabajando con protocolo FTP en Android. Ejemplo

¡Hola a todos! Este será un artículo muy pequeño. Nuestra tarea aquí es conectarnos a un servidor FTP local (elegí FileZilla) y enviar algo allí usando el (obviamente) protocolo FTP.

Entonces, una gota de teoría

FTP (Protocolo de transferencia de archivos) es un protocolo de transferencia de archivos en red.

FTP requiere dos: un servidor FTP y un cliente FTP.



El servidor proporciona acceso mediante nombre de usuario y contraseña a los archivos necesarios y, en consecuencia, muestra al usuario solo aquellos archivos y carpetas a los que tiene acceso.

Client es un programa para conexión FTP. La idea principal es que el usuario puede operar con los datos del archivo en el lado del servidor: ver, editar, copiar, descargar y eliminar.



Todo es lógico.



A diferencia de, digamos, el mismo HTTP, FTP utiliza una conexión doble como modelo de conexión. En este caso, un canal es el de control, a través del cual se reciben comandos al servidor y se devuelven sus respuestas (generalmente a través del puerto TCP 21), y por el resto se realiza la transferencia de datos propiamente dicha, un canal para cada transferencia. Por lo tanto, en el marco de una sesión a través del protocolo FTP, se pueden transferir varios archivos simultáneamente y en ambas direcciones.



Si describe el proceso de establecer una conexión y seguir transfiriendo datos punto por punto, obtiene algo como lo siguiente:

1. El usuario activa la aplicación cliente y se conecta al servidor ingresando un nombre de usuario y contraseña.
2. — .
3. , FTP- ( , FTP — , , ), , (, , , ..).
4. ( , ), , FPT — , .
   
   .
5. Una vez completada la transferencia, esta conexión se cierra, pero el canal de control entre los intérpretes permanece abierto, como resultado de lo cual el usuario puede reabrir la transferencia de datos dentro de la misma sesión.

FTP: la conexión predeterminada es el puerto 21, a menos que se configure otro puerto.

Implementación

En este caso, usaremos la clase FTPClient de la biblioteca Apache (org.apache.commons.net.ftp.FTPClient). Creamos un objeto de la clase, establecemos un tiempo de espera. Luego, primero debemos conectarnos al servidor usando Connect antes de hacer cualquier cosa (y recuerde desconectarnos cuando hayamos terminado). En connect, como primer parámetro, escribimos la dirección local del host, el segundo argumento es el puerto de conexión. También debe verificar el código de respuesta FTP (demasiado obvio, pero aún así) para asegurarse de que la conexión fue exitosa.

import org.apache.commons.net.ftp.FTP
import org.apache.commons.net.ftp.FTPClient
import org.apache.commons.net.ftp.FTPReply

...

val con = FTPClient()
        con.connectTimeout = 
        con.connect("192.168.0.105", 21)
        if (FTPReply.isPositiveCompletion(con.replyCode)) {
                // 
        }

      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Ok, estamos conectados al servidor. ¿Que sigue? Ahora debe pasar por la autorización con el nombre de usuario, que, de hecho, creamos para esto. Pero antes de eso, debe establecer el modo de conexión de datos actual en PASSIVE_LOCAL_DATA_CONNECTION_MODE usando el comando enterLocalPassiveMode (). Esto significa que todas las transferencias ocurrirán entre el cliente y el servidor, y que el servidor está en modo pasivo, esperando que el cliente se conecte para iniciar la transferencia. (por ejemplo, ACTIVE_LOCAL_DATA_CONNECTION_MODE implica que el servidor iniciará la conexión).



Después de eso, al iniciar sesión, escriba el nombre de usuario y la contraseña. storeFile () almacena el archivo en el servidor usando el nombre dado y aceptando la entrada del InputStream dado. Tenía la tarea de escribir periódicamente en un archivo específico en el servidor, por lo que se ve así:

con.enterLocalPassiveMode()
                if (con.login("nad", "nad")) { //    (,     )
                    con.setFileType(FTP.BINARY_FILE_TYPE)
                    val msg = "your_msg"
                    val msg_bytes: InputStream = ByteArrayInputStream(msg.toByteArray())
                    val result: Boolean = con.storeFile("/sms.txt", msg_bytes)
                    msg_bytes.close()
                    if (result) Log.v("upload result", "succeeded")
                    con.logout()
                    con.disconnect()
                }
            }
             catch (ex: IOException) {
                ex.printStackTrace()
                return Result.failure()
            }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Si desea copiar su archivo al servidor en su totalidad, puede hacer esto (la esencia no cambia mucho, pero de repente alguien lo necesita):

val file = File("  ")
val msg_bytes = FileInputStream(file)

      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Con todo, esto es todo lo que puede necesitar. Y, por supuesto, un poco sobre la configuración de un servidor FTP local. Tengo esto, como escribí anteriormente, FileZilla. Dejamos todo por defecto. Cree un usuario y asígnele una carpeta en el host, desde la que pueda leer / escribir / eliminar, etc.







Eso es todo. Inicie y vea los registros en el servidor. Y esto es lo que debería obtener: ¡







Buena suerte!