Escrita e Leitura de Arquivo no Android – Parte I

Os dispositivos com o Android permitem a escrita e leitura de arquivos na memória interna. Este post descreve como criar um arquivo texto, escrever e visualizar o conteúdo do arquivo no próprio dispositivo e como exportar o arquivo do emulador do Eclipse para o computador.

Como cada aplicação do Android roda em seu próprio contexto, o arquivo só pode ser manipulado pela própria aplicação que criou o arquivo. O arquivo não é visualizado por outras aplicações e não pode ser manipulado pelo usuário.

O projeto utilizado para demonstrar a escrita e leitura do arquivo possui uma Activity com o seguinte layout:

Foi criada uma classe chamada ManageFile com os métodos WriteFile e ReadFile, que fazem a escrita e leitura do arquivo.

/**
 * Classe responsável pela escrita e leitura de arquivo.
 * @author Romar Consultoria
 *
 */
public class ManageFile {
    private static final String TAG = "ManageFile";
    private Context context;
    
    public ManageFile(Context context){
        this.context = context;
    }

    /**
     * Escreve no arquivo texto.
     * @param text Texto a ser escrito.
     * @return True se o texto foi escrito com sucesso.
     */
    public boolean WriteFile(String text){
        try {
            // Abre o arquivo para escrita ou cria se não existir
            FileOutputStream out = context.openFileOutput("romar.txt",
                    Context.MODE_APPEND);
            out.write(text.getBytes());
            out.write("\n".getBytes());
            out.flush();
            out.close();    
            return true;
            
        } catch (Exception e) {
            Log.e(TAG, e.toString());
            return false;
        }
    }
    
    /**
     * Faz a leitura do arquivo
     * @return O texto lido.
     * @throws FileNotFoundException
     * @throws IOException
     */
    public String ReadFile() throws FileNotFoundException, IOException{
        File file = context.getFilesDir();
        File textfile = new File(file + "/romar.txt");

        FileInputStream input = context.openFileInput("romar.txt");
        byte[] buffer = new byte[(int)textfile.length()];
        
        input.read(buffer);            
        
        return new String(buffer);
    }
}

Observe que no construtor da classe foi passado o argumento context da aplicação para que seja possível manipular o arquivo no contexto da aplicação.

O método writeFile tem como argumento o texto a ser escrito e utiliza o método openFileOutput para criar se o arquivo não existir ou abrir o arquivo anteriormente criado.

O método readFile busca pelo arquivo (romar.txt) criado anteriormente, faz a leitura do arquivo e retorna uma String com o conteúdo.

Na Activity do projeto foram criados dois botões Ler e Escrever que fazem a chamada dos métodos de escrita e leitura do arquivo:

@Override
public void onClick(View v) {
    
    try {
        switch (v.getId()) {
        case R.id.btnRead:
            // Faz a leitura do arquivo
            ManageFile fileread = new ManageFile(this);
                textRead.setText(fileread.ReadFile());
            break;

        case R.id.btnWrite:
            ManageFile filewrite = new ManageFile(this);
            
            // Avisa o usuário se a gravação foi bem sucedida
            if(filewrite.WriteFile(editText.getText().toString())
                 == true){
                Toast.makeText(this,
                    "Texto gravado com sucesso.",
                    Toast.LENGTH_SHORT).show();
            }
            else{
                Toast.makeText(this, 
                    "Não foi possível escrever o texto.", 
                    Toast.LENGTH_SHORT).show();
            }
            
            // Reseta o campo do texto
            editText.setText("");
            
            break;
            
        default:
            break;
        }
    
    } catch (FileNotFoundException e) {
        Log.e(TAG, e.toString());
    } catch (IOException e) {
        Log.e(TAG, e.toString());
    }

}

A aplicação funcionando apresenta a seguinte tela:

É possível exportar o arquivo (romar.txt) para o computador, através do emulador do Eclipse utilizando a perspectiva DDMS, na aba File Explorer que exibe o conteúdo nos diretórios do dispositivo.

No diretório data/data/nome_do_pacote/files fica localizado os arquivos, criados dentro do contexto da aplicação. Para exportar o arquivo selecionar o botão indicado pela seta e gravar o arquivo no computador. Mas lembre-se o acesso a este arquivo só é possível via emulador, no dispositivo real não é possível acessar este arquivo.