Trabalhando com protocolo FTP no Android. Exemplo

Olá pessoal! Este será um artigo muito pequeno. Nossa tarefa aqui é conectar a um servidor FTP local (eu escolhi FileZilla) e enviar algo usando o protocolo FTP (obviamente).

Então, uma gota de teoria

FTP (File Transfer Protocol) é um protocolo de transferência de arquivos de rede.

O FTP requer dois: um servidor FTP e um cliente FTP.



O servidor fornece acesso por login e senha aos arquivos necessários e, dessa forma, mostra ao usuário apenas os arquivos e pastas aos quais ele tem acesso.

Client é um programa para conexão FTP. A ideia principal é que o usuário possa operar os dados do arquivo no lado do servidor: visualizar, editar, copiar, baixar e excluir.



Tudo é lógico.



Ao contrário, digamos, do mesmo HTTP, o FTP usa uma conexão dupla como modelo de conexão. Nesse caso, um canal é o de controle, por meio do qual os comandos são recebidos no servidor e suas respostas são retornadas (geralmente pela porta 21 TCP), e por meio do restante ocorre a transferência real de dados, um canal para cada transferência. Portanto, no âmbito de uma sessão via protocolo FTP, vários arquivos podem ser transferidos simultaneamente e em ambas as direções.



Se você descrever o processo de estabelecimento de uma conexão e posterior transferência de dados ponto a ponto, obterá algo como o seguinte:

1. O usuário ativa o aplicativo cliente e se conecta ao servidor inserindo um nome de usuário e uma senha.
2. — .
3. , FTP- ( , FTP — , , ), , (, , , ..).
4. ( , ), , FPT — , .
   
   .
5. Após a conclusão da transferência, esta conexão é fechada, mas o canal de controle entre os intérpretes permanece aberto, como resultado o usuário pode reabrir a transferência de dados dentro da mesma sessão.

FTP - a conexão padrão é a porta 21, a menos que outra porta seja configurada.

Implementação

Nesse caso, usaremos a classe FTPClient da biblioteca Apache (org.apache.commons.net.ftp.FTPClient). Criamos um objeto da classe, definimos um tempo limite. Em seguida, devemos primeiro conectar ao servidor usando conectar antes de fazer qualquer coisa (e lembre-se de desconectar depois que terminarmos). Em conectar, como primeiro parâmetro, escrevemos o endereço local do host, o segundo argumento é a porta de conexão. Você também precisa verificar o código de resposta do FTP (muito óbvio, mas ainda assim) para ter certeza de que a conexão foi bem-sucedida.

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 ao servidor. Qual é o próximo? Agora você precisa passar pela autorização sob o nome de usuário, que, de fato, criamos para isso. Mas antes disso, você precisa definir o modo de conexão de dados atual para PASSIVE_LOCAL_DATA_CONNECTION_MODE usando o comando enterLocalPassiveMode (). Isso significa que todas as transferências ocorrerão entre o cliente e o servidor, e que o servidor está em modo passivo, aguardando a conexão do cliente para iniciar a transferência. (por exemplo, ACTIVE_LOCAL_DATA_CONNECTION_MODE implica que o servidor iniciará a conexão).



Depois disso, no login, escreva o nome de usuário e a senha. storeFile () armazena o arquivo no servidor usando o nome fornecido e aceitando a entrada do InputStream fornecido. Eu tinha a tarefa de escrever periodicamente em um arquivo específico no servidor, então ficava assim:

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()
            }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Se você deseja copiar seu arquivo para o servidor em sua totalidade, você pode fazer isso (a essência não muda muito, mas de repente alguém precisa):

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

      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Em suma, isso é tudo de que você precisa. E, claro, um pouco sobre como configurar um servidor FTP local. Eu tenho isso, como escrevi antes, FileZilla. Deixamos tudo por padrão. Crie um usuário e atribua a ele uma pasta no host, a partir da qual ele pode ler / gravar / excluir, etc.







Isso é tudo. Inicie e visualize os logs no servidor. E aqui está o que você deve conseguir:







Boa sorte!