Comandos para Guardar y Leer Archivos en Android

Contenido del curso

Arquitectura

Patrones de diseño

10
Patrones de Diseño en Android: Creacionales, Estructurales y Comportamiento
02:34 min

Patrones de diseño creacionales

Patrones de diseño estructurales

Patrones de comportamiento

Bonus: Architecture Components

Bonus: Custom View

31
Creación de Vistas Personalizadas en Android con Custom View
08:42 min

Conclusiones

32
Patrones de Diseño y Componentes de Texto en Android
01:19 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:009:27

Comandos para Guardar y Leer Archivos en Android

Curso de Patrones de Diseño en Android

Clase 23 de 32

Clase 23 / 32

Recursos

¿Cómo implementar el patrón Comando para guardar y leer archivos en Android?

En este ejercicio, exploramos cómo implementar un patrón Comando en Android para guardar y leer archivos eficientemente. Este enfoque ayuda a encapsular peticiones en objetos y abre la puerta a funcionalidades como el deshacer y rehacer de acciones. Aquí aprenderás cómo desarrollar comandos para crear un sistema que interactúe eficazmente con el sistema de archivos de un dispositivo Android.

¿Cómo crear un comando para guardar archivos?

Al crear un comando para guardar archivos, comenzamos implementando una interfaz que proporciona el marco para desarrollar acciones concretas. El proceso implica varios pasos, como se detalla a continuación:

Implementación de la interfaz: Comienza creando una clase SaveCommand que implementa la interfaz Command.
Definición del método de ejecución: Implementa el método execute necesario. Aquí escribimos el contenido en un archivo de la siguiente manera:

OutputStringWriter outputStringWriter = new OutputStringWriter(fileName, context);
// Suponemos que 'args' es variable con los argumentos que se desea escribir
outputStringWriter.write(args.toString());

Manejo de excepciones: Utiliza un bloque try-catch para manejar las posibles IOException que podrían surgir cuando el sistema de archivos no es accesible.

try {
    outputStringWriter.close();
} catch (IOException e) {
    // Manejo de la excepción
    System.out.println("Error al guardar el archivo: " + e.getMessage());
}

¿Cómo desarrollar un comando para leer archivos?

El comando para leer archivos es un complemento vital para el comando de guardar. Siguiendo un enfoque similar, procedemos con:

Implementación de la interfaz: Crea la clase ReadCommand implementando la interfaz Command.
Definición del método de ejecución: Aquí se lee el contenido de un archivo y se almacena en una cadena para mostrarse posteriormente.

StringBuilder fileContent = new StringBuilder();
try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(context.openFileInput(fileName)))) {
    String line;
    while ((line = bufferedReader.readLine()) != null) {
        fileContent.append(line).append("\n");
    }
} catch (IOException e) {
    // Manejo de la excepción
    System.out.println("Error al leer el archivo: " + e.getMessage());
}

¿Cómo integrar los comandos en una aplicación Android?

Para integrar los comandos, sigue estos pasos:

Crear un CommandManager: Permite agregar o solicitar comandos dados un nombre.

CommandManager commandManager = new CommandManager();
commandManager.putCommand("save", new SaveCommand());
// Agrega otros comandos siguiendo el mismo patrón

Invocar comandos: Utiliza el CommandManager para ejecutar los comandos creados.

// Para guardar un archivo
commandManager.getCommand("save").execute(context, "exampleFile.txt", "Hola Mundo", "Platzi es genial");

// Para leer un archivo
commandManager.getCommand("read").execute(context, "exampleFile.txt");

Con estos pasos, has configurado un patrón Comando que enriquece las aplicaciones Android al manejar eficazmente operaciones de E/S de archivos. El diseño modular permite expandir, reutilizar y mantener el código más fácilmente. ¡Continúa perfeccionando tus habilidades y explora lo que puedes lograr con patrones de diseño en Android!

Puni Marketing Group LLC

Hace 3 años

Vamos a crear dos comandos, uno para leer y otro para escribir

SaveCommand:

package com.cristianvillamil.platziwallet.ui.commands

import android.content.Context
import android.util.Log
import java.io.IOException
import java.io.OutputStreamWriter
import kotlin.math.log

class SaveCommand : FileCommand {
    override fun execute(context: Context, fileName: String, vararg arguments: String) {
        try {
            val outputStreamWriter = OutputStreamWriter(context.openFileOutput(fileName, Context.MODE_PRIVATE)) // Esta variable es para poder escribir desde el celular
            outputStreamWriter.write(arguments.toString()) // Escribe todos los argumentos que se le pasen
            outputStreamWriter.close() // Cerramos nuestra conexion al sistema de archivos del celular
        } catch (exception: IOException) {
            Log.e("SaveCommand", "File write failed: $exception")
        }

    }

}

ReadCommand:

package com.cristianvillamil.platziwallet.ui.commands

import android.content.Context
import android.util.Log
import java.io.BufferedReader
import java.io.InputStreamReader

class ReadCommand : FileCommand {
    override fun execute(context: Context, fileName: String, vararg arguments: String) {
        var fileString = "" // Almacena lo que escribimos en la consola que despues ira en el archivo
        val inputStream = context.openFileInput(fileName) // Abrimos una conexion con el sistema de archivos para solo lectura
        val stringBuilder = StringBuilder() // Hacemos un append en todos los archivos que vamos trayendo de la memoria
        val inputStreamReader = InputStreamReader(inputStream) // Nos ayuda a leer los archivos
        val bufferedReader = BufferedReader(inputStreamReader) // Nos permite leer linea por linea del archivo
        bufferedReader.forEachLine { stringBuilder.append("\n").append(it) } // Por cada linea agrega un salto de linea al final
        fileString = stringBuilder.toString() // Lo convertimos a string
        Log.e("ReadedFile", fileString) // Mostramos en el log los archivos
    }

}

MainActivity: Este es el archivo raíz del proyecto

package com.cristianvillamil.platziwallet

import android.os.Bundle
import com.google.android.material.bottomnavigation.BottomNavigationView
import androidx.appcompat.app.AppCompatActivity
import androidx.navigation.findNavController
import androidx.navigation.ui.AppBarConfiguration
import androidx.navigation.ui.setupActionBarWithNavController
import androidx.navigation.ui.setupWithNavController
import com.cristianvillamil.platziwallet.ui.commands.FileCommandsManager
import com.cristianvillamil.platziwallet.ui.commands.ReadCommand
import com.cristianvillamil.platziwallet.ui.commands.SaveCommand

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val navView: BottomNavigationView = findViewById(R.id.nav_view)

        val navController = findNavController(R.id.nav_host_fragment)
        navView.setupWithNavController(navController)

				// Commands
        val commandsManager = FileCommandsManager() // Instanciamos el manager
        val saveCommand = SaveCommand() // Instanciamos el comando de guardado
        val readCommand = ReadCommand() // Instanciamos el comando de lectura

        commandsManager.putCommand("SaveCommand", saveCommand) // Registramos el comando
        commandsManager.putCommand("ReadCommand", readCommand) // Resgistramos el comando

        commandsManager.getCommand("SaveCommand")
            .execute(this, "exampleFile", "Hola Mundo", "Platzi Wallet") // Generamos el archivo

        commandsManager.getCommand("ReadCommand").execute(this, "exampleFile") // Leemos el archivo
    }
}

Arquitectura

Patrones de Diseño en Android: Soluciones y Aplicación Práctica

Fundamentos de Arquitectura de Software y su Impacto en Proyectos

Arquitecturas en Android: MVC y MVVM

Desarrollo de una Billetera Virtual con Git y Android Studio

Arquitectura MVP: Modelo, Vista y Presentador en Desarrollo de Software

Arquitectura MVP: Implementación en Proyectos Android

Implementación de Arquitectura MVP en Android

Implementación de Loaders en Arquitectura MVP con Android

Arquitectura MVVM en Android: Comunicación entre Capas

Patrones de diseño

Patrones de Diseño en Android: Creacionales, Estructurales y Comportamiento

Patrones de diseño creacionales

Implementación del Patrón Singleton en Kotlin para Android

Patrón Singleton en Kotlin para Gestión de Estados en Android

Patrón Builder en Android: Creación de Objetos Complejos

Implementación del Patrón Builder en Clases de Usuario

Funciones de Alcance en Kotlin: Uso de Apply

Patrón Factory: Creación y Uso en Desarrollo de Software

Patrones de diseño estructurales

Patrón de Diseño Adaptador para Transformar Datos en Clases Java

Aplicación del Patrón Proxy en Transferencias Seguras

Patrón de Diseño Fast Add en Aplicaciones Android

Patrones de comportamiento

Patrones de Diseño: Implementación del Patrón Observer en Proyectos

Patrón Observer en Android: Implementación y Uso Práctico

Patrón Comando: Implementación y Gestión de Comandos en Kotlin

Comandos para Guardar y Leer Archivos en Android

Ejecución de Comandos y Debugging en Android Studio

Bonus: Architecture Components

Componentes de Android Jetpack para Mejora de Aplicaciones

Implementación de LiveData en Android para Ciclo de Vida

Implementación de Room en Android para Gestión de Base de Datos

Creación de Entidades y DAO en Base de Datos con Room en Kotlin

Conexión y manejo de transferencias en Room Database

Implementación de ViewModel en Arquitectura MVVM en Android

Bonus: Custom View

Creación de Vistas Personalizadas en Android con Custom View

Conclusiones

Patrones de Diseño y Componentes de Texto en Android

Comandos para Guardar y Leer Archivos en Android