mayo 25, 2024

BitCuco

¡Hola Mundo!

Jetpack Compose para novatos con ejemplos

jetpack compose

El desarrollo de aplicaciones Android ha experimentado una evolución constante a lo largo de los años, y Jetpack Compose es uno de los avances más emocionantes en la construcción de interfaces de usuario para aplicaciones Android. Este moderno kit de herramientas de IU, lanzado por Google, está cambiando la forma en que los desarrolladores crean experiencias de usuario ricas y dinámicas en dispositivos Android. En este artículo, exploraremos las ventajas de Jetpack Compose y cómo está revolucionando el desarrollo de aplicaciones para la plataforma Android.

¿Qué es Jetpack Compose?

Jetpack Compose es un conjunto de bibliotecas de Android diseñado para simplificar y mejorar la creación de interfaces de usuario (UI) en aplicaciones Android. A diferencia de los enfoques tradicionales basados en XML, utiliza un lenguaje de programación declarativo de Kotlin para construir interfaces de usuario de manera más eficiente y con menos código. Veamos algunas de las ventajas más destacadas de ésta herramienta:

1. Declarativo en lugar de Imperativo

Una de las ventajas más significativas de Jetpack Compose es su enfoque declarativo para la creación de UI. En lugar de escribir código imperativo para describir cómo se debe construir la interfaz de usuario paso a paso, los desarrolladores especifican cómo debería verse la interfaz de usuario en un estado particular y Compose se encarga de mantenerla sincronizada automáticamente.

Este enfoque hace que el código sea más claro, más fácil de mantener y menos propenso a errores, ya que los desarrolladores se centran en describir el resultado deseado en lugar de gestionar manualmente los cambios de estado.

2. Kotlin First

Jetpack Compose se basa en el lenguaje de programación Kotlin. Esto significa que los desarrolladores pueden aprovechar todas las características poderosas de Kotlin, como la concisión, la seguridad del tipo y las extensiones, para crear interfaces de usuario de manera más eficiente y elegante. Además, la integración con Kotlin permite una transición suave y natural para los desarrolladores que ya están familiarizados con este lenguaje.

3. Reutilización de Componentes

Compose promueve la reutilización de componentes de interfaz de usuario. Los desarrolladores pueden crear componentes personalizados y componerlos en interfaces de usuario complejas de manera sencilla. Esto fomenta una arquitectura modular y facilita la construcción de aplicaciones escalables.

4. Pruebas Simplificadas

La naturaleza declarativa de Jetpack Compose facilita la escritura de pruebas unitarias y de integración más efectivas. Los desarrolladores pueden probar cada componente de la interfaz de usuario de forma aislada y asegurarse de que se comporte como se espera en diferentes estados.

5. Soporte Nativo para Animaciones

La herramienta ofrece un soporte nativo para la creación de animaciones suaves y atractivas en la interfaz de usuario. Esto permite a los desarrolladores agregar elementos visuales dinámicos y atractivos a sus aplicaciones sin esfuerzo adicional.

6. Retrocompatibilidad y Adopción Gradual

Google ha diseñado Jetpack Compose de manera que los desarrolladores puedan adoptarlo gradualmente en sus aplicaciones existentes. No es necesario reescribir por completo una aplicación para empezar a utilizar Compose. Esto facilita la transición y permite a los desarrolladores aprovechar las ventajas de Compose a medida que lo integran en sus proyectos.

Ejemplo de uso de Jetpack Compose

A continuación te mostramos un ejemplo simple de cómo usar Jetpack Compose para crear una lista de tareas para una aplicación Android. Este ejemplo se centrará en la creación de una interfaz de usuario para mostrar y marcar tareas como completadas.

Primero, asegúrate de que tu proyecto Android tenga las dependencias de Jetpack Compose configuradas en el archivo build.gradle:

android {
    ...
    buildFeatures {
        compose true
    }
    ...
}

dependencies {
    ...
    implementation "androidx.compose.ui:ui:1.0.0"
    implementation "androidx.compose.material:material:1.0.0"
    implementation "androidx.activity:activity-compose:1.3.0"
    ...
}

Ahora, puedes crear una actividad con la siguiente interfaz de usuario utilizando Jetpack Compose:

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.text.BasicTextField
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.input.TextFieldValue
import androidx.compose.ui.unit.dp

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            Surface(
                modifier = Modifier.fillMaxSize(),
                color = Color.White
            ) {
                TodoApp()
            }
        }
    }
}

data class TodoItem(val task: String, var isCompleted: Boolean = false)

@Composable
fun TodoApp() {
    var taskText by remember { mutableStateOf(TextFieldValue()) }
    var tasks by remember { mutableStateOf(listOf<TodoItem>()) }

    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        Text(
            text = "Lista de Tareas",
            style = MaterialTheme.typography.h4,
            modifier = Modifier.padding(bottom = 16.dp)
        )

        BasicTextField(
            value = taskText,
            onValueChange = {
                taskText = it
            },
            placeholder = { Text(text = "Nueva tarea") },
            modifier = Modifier
                .fillMaxWidth()
                .padding(bottom = 16.dp)
        )

        Button(
            onClick = {
                if (taskText.text.isNotEmpty()) {
                    tasks = tasks + TodoItem(taskText.text)
                    taskText = TextFieldValue("")
                }
            },
            modifier = Modifier.fillMaxWidth()
        ) {
            Text(text = "Agregar Tarea")
        }

        LazyColumn(
            modifier = Modifier
                .fillMaxWidth()
                .padding(top = 16.dp)
        ) {
            items(tasks) { task ->
                TodoItemRow(
                    task = task,
                    onTaskToggle = { updatedTask ->
                        tasks = tasks.map { if (it == task) updatedTask else it }
                    }
                )
            }
        }
    }
}

@Composable
fun TodoItemRow(task: TodoItem, onTaskToggle: (TodoItem) -> Unit) {
    Card(
        modifier = Modifier
            .fillMaxWidth()
            .padding(bottom = 8.dp),
        elevation = 4.dp
    ) {
        Row(
            modifier = Modifier
                .fillMaxWidth()
                .padding(16.dp),
            verticalAlignment = Alignment.CenterVertically
        ) {
            Checkbox(
                checked = task.isCompleted,
                onCheckedChange = { isChecked ->
                    onTaskToggle(task.copy(isCompleted = isChecked))
                },
                modifier = Modifier.padding(end = 16.dp)
            )
            Text(
                text = task.task,
                style = if (task.isCompleted) MaterialTheme.typography.body1.copy(
                    textDecoration = TextDecoration.LineThrough
                ) else MaterialTheme.typography.body1
            )
        }
    }
}

Este ejemplo crea una aplicación Android simple que permite al usuario agregar tareas a una lista y marcarlas como completadas. Utiliza varios componentes de Jetpack Compose, como BasicTextField, Button, LazyColumn, y Checkbox, para construir la interfaz de usuario de manera declarativa y eficiente.

Ejemplo 2: Lista de Contactos

Por supuesto, aquí tienes otro ejemplo de uso de Jetpack Compose para crear una aplicación de lista de contactos. En esta aplicación, podrás ver una lista de contactos y agregar nuevos contactos a la lista.

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.text.BasicTextField
import androidx.compose.foundation.text.KeyboardActions
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.platform.LocalFocusManager
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            Surface(
                modifier = Modifier.fillMaxSize(),
                color = Color.White
            ) {
                ContactApp()
            }
        }
    }
}

data class Contact(val name: String)

@Composable
fun ContactApp() {
    var newContactName by remember { mutableStateOf("") }
    var contacts by remember { mutableStateOf(listOf(Contact("Alice"), Contact("Bob"), Contact("Charlie"))) }

    val focusManager = LocalFocusManager.current
    val keyboardController = LocalSoftwareKeyboardController.current

    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        Text(
            text = "Lista de Contactos",
            style = MaterialTheme.typography.h4,
            fontSize = 24.sp,
            modifier = Modifier.padding(bottom = 16.dp)
        )

        BasicTextField(
            value = newContactName,
            onValueChange = {
                newContactName = it
            },
            keyboardOptions = KeyboardOptions(
                imeAction = ImeAction.Done
            ),
            keyboardActions = KeyboardActions(
                onDone = {
                    if (newContactName.isNotBlank()) {
                        contacts = contacts + Contact(newContactName)
                        newContactName = ""
                        focusManager.clearFocus()
                        keyboardController?.hide()
                    }
                }
            ),
            singleLine = true,
            modifier = Modifier
                .fillMaxWidth()
                .padding(bottom = 16.dp)
        )

        LazyColumn(
            modifier = Modifier
                .fillMaxWidth()
                .padding(top = 16.dp)
        ) {
            items(contacts) { contact ->
                ContactItem(contact = contact)
            }
        }
    }
}

@Composable
fun ContactItem(contact: Contact) {
    Card(
        modifier = Modifier
            .fillMaxWidth()
            .padding(bottom = 8.dp),
        elevation = 4.dp
    ) {
        Row(
            modifier = Modifier
                .fillMaxWidth()
                .padding(16.dp),
            verticalAlignment = Alignment.CenterVertically
        ) {
            Text(
                text = contact.name,
                style = MaterialTheme.typography.body1,
                fontSize = 16.sp
            )
        }
    }
}

En éste segundo ejemplo, puedes agregar nuevos contactos ingresando sus nombres en un campo de texto y tocando “Hecho” en el teclado. Los contactos se mostrarán en una lista a medida que los agregues. Esto demuestra cómo se simplifica la creación de interfaces de usuario interactivas y receptivas en Android.

El futuro de Jetpack Compose

Jetpack Compose representa una evolución importante en el desarrollo de aplicaciones Android al proporcionar un enfoque declarativo, basado en Kotlin y altamente modular para la creación de interfaces de usuario. Sus ventajas, que incluyen una mayor claridad en el código, la reutilización de componentes y un soporte nativo para animaciones, están cambiando la forma en que los desarrolladores crean experiencias de usuario en la plataforma Android.

A medida que la adopción de Jetpack Compose continúa creciendo, se espera que mejore la eficiencia y la calidad de las aplicaciones Android, proporcionando experiencias más ricas y atractivas para los usuarios.

Otros artículos recomendados