La API Ink ya está en beta y se puede integrar en tu aplicación. Este hito ha sido posible gracias a los valiosos comentarios de los desarrolladores, que han llevado a mejoras continuas en el rendimiento, la estabilidad y la calidad visual de la API.

Las aplicaciones de Google, como Documentos de Google, Pixel Studio, Google Fotos, Chrome PDF y YouTube Effect Maker, así como funciones únicas de Android, como Rodea para buscar, usan las APIs más recientes. 

Para celebrar este hito, nos complace anunciar el lanzamiento de Cahier, una aplicación de ejemplo completa para tomar notas optimizada para dispositivos Android de todos los tamaños, especialmente tablets y teléfonos plegables.

¿Qué es Cahier?

Cahier (que significa "cuaderno" en francés) es una aplicación de ejemplo diseñada para mostrar cómo puedes crear una aplicación que permita a los usuarios plasmar y organizar sus ideas combinando texto, dibujos e imágenes. 

La muestra puede servir como referencia para mejorar la productividad y la creatividad de los usuarios en pantallas grandes. Muestra las prácticas recomendadas para crear este tipo de experiencias, lo que acelera la comprensión y la adopción por parte de los desarrolladores de las potentes APIs y técnicas relacionadas. En esta entrada se explican las funciones principales de Cahier, las APIs clave y las decisiones de arquitectura que hacen que la muestra sea una referencia excelente para tus propias aplicaciones.

Entre las funciones principales que se muestran en la muestra se incluyen las siguientes:

• Creación de notas versátil: muestra cómo implementar un sistema de creación de contenido flexible que admita varios formatos en una sola nota, como texto, dibujos a mano alzada e imágenes adjuntas.
• Herramientas de escritura a mano creativas: implementa una experiencia de dibujo de alto rendimiento y baja latencia mediante la API Ink. La muestra ofrece un ejemplo práctico de cómo integrar varios pinceles, un selector de color, la función de deshacer/rehacer y una herramienta de borrado.
• Integración de contenido fluido con arrastrar y soltar: muestra cómo gestionar el contenido entrante y saliente mediante la función de arrastrar y soltar. Esto incluye aceptar imágenes que se hayan soltado desde otras aplicaciones y permitir que los usuarios arrastren contenido fuera de tu aplicación para compartirlo fácilmente.
• Organización de notas: marca las notas como favoritas para acceder a ellas rápidamente. Filtra la vista para mantener la organización.
• Arquitectura de prioridad offline: se ha creado con una arquitectura de prioridad offline que usa Room, lo que garantiza que todos los datos se guarden de forma local y que la aplicación siga funcionando correctamente sin conexión a Internet.
• Potente compatibilidad con el modo multiventana y con varias instancias: muestra cómo admitir varias instancias, lo que permite que tu aplicación se inicie en varias ventanas para que los usuarios puedan trabajar en diferentes notas al mismo tiempo, lo que mejora la productividad y la creatividad en pantallas grandes.
• Interfaz de usuario adaptativa para todas las pantallas: la interfaz de usuario se adapta perfectamente a diferentes tamaños y orientaciones de pantalla mediante ListDetailPaneScaffold y NavigationSuiteScaffold para ofrecer una experiencia de usuario optimizada en teléfonos, tablets y dispositivos plegables.
• Integración profunda con el sistema: ofrece una guía sobre cómo hacer que tu aplicación sea la aplicación predeterminada para tomar notas en Android 14 y versiones posteriores respondiendo a las intenciones de Notas de todo el sistema, lo que permite capturar contenido rápidamente desde varios puntos de entrada del sistema.

Diseñada para aumentar la productividad y la creatividad en pantallas grandes

En el lanzamiento inicial, vamos a centrarnos en algunas funciones principales que hacen de Cahier un recurso de aprendizaje clave para casos prácticos de productividad y creatividad.

Una base de adaptabilidad

Cahier se ha diseñado para ser adaptativo desde el principio. En el ejemplo se utiliza la biblioteca material3-adaptive, concretamente ListDetailPaneScaffold y NavigationSuiteScaffold, para adaptar el diseño de la aplicación a diferentes tamaños y orientaciones de pantalla. Es un elemento fundamental para una aplicación Android moderna y Cahier ofrece un ejemplo claro de cómo implementarlo de forma eficaz.

Interfaz de usuario adaptativa de Cahier creada con la biblioteca adaptativa de Material 3

Presentación de APIs e integraciones clave

La muestra se centra en mostrar potentes APIs de productividad que puedes aprovechar en tus propias aplicaciones, como las siguientes:

• API Ink
• Rol de notas
• Multiinstancia, Multiventana y modo Ventanas
• Arrastrar y soltar

Análisis detallado de las APIs clave

Vamos a analizar en profundidad dos de las APIs fundamentales que integra Cahier para ofrecer una experiencia de toma de notas de primera clase.

Crear experiencias de entrada de lápiz natural con la API Ink

La entrada con lápiz óptico transforma los dispositivos con pantallas grandes en cuadernos y blocs de dibujo digitales. Para ayudarte a crear experiencias de escritura a mano fluidas y naturales, hemos convertido la API Ink en la piedra angular de la muestra. La API Ink facilita la creación, la renderización y la manipulación de trazos de tinta con la mejor baja latencia de su categoría.

La API Ink ofrece una arquitectura modular, por lo que puedes adaptarla a la pila y las necesidades específicas de tu aplicación. Los módulos de la API incluyen lo siguiente:

• Módulos de creación (Componer - vistas): gestiona la entrada de escritura a mano en tiempo real para crear trazos suaves con la latencia más baja que pueda ofrecer un dispositivo.
  • En DrawingSurface, Cahier usa el nuevo elemento componible InProgressStrokes para gestionar la entrada táctil o de lápiz en tiempo real. Este módulo se encarga de capturar eventos de puntero y renderizar trazos de tinta húmeda con la menor latencia posible.
• Módulo Trazos: representa la entrada de tinta y su representación visual.Cuando un usuario termina de dibujar una línea, la retrollamada onStrokesFinished proporciona a la aplicación un objeto Stroke finalizado o de prueba. Este objeto inmutable, que representa el trazo de tinta completado, se gestiona en DrawingCanvasViewModel.
• Módulo de renderización: muestra los trazos de tinta de forma eficiente, lo que permite combinarlos con Jetpack Compose o con vistas de Android.
  • Para mostrar los trazos que ya se han secado y los que se acaban de secar, Cahier usa CanvasStrokeRenderer en DrawingSurface para dibujar y en DrawingDetailPanePreview para mostrar una vista previa estática de la nota. Este módulo dibuja de forma eficiente los objetos Stroke en un Canvas.
• Módulos de pincel (Composición - vistas): proporcionan una forma declarativa de definir el estilo visual de los trazos. Entre las últimas actualizaciones (desde la versión alfa 03), se incluye un nuevo pincel de línea discontinua, que es especialmente útil para funciones como la selección con lazo. DrawingCanvasViewModel contiene el estado de currentBrush. Una caja de herramientas de DrawingCanvas permite a los usuarios seleccionar diferentes familias de pinceles (como StockBrushes.pressurePen() o StockBrushes.highlighter()) y cambiar los colores. El ViewModel actualiza el objeto Brush, que luego usa el elemento componible InProgressStrokes para los nuevos trazos.
• Módulos de geometría (Compose - vistas): permiten manipular y analizar trazos para usar funciones como borrar y seleccionar.
  • La herramienta de borrador de la caja de herramientas y las funciones de DrawingCanvasViewModel dependen del módulo de geometría. Cuando la goma de borrar está activa, se crea un paralelogramo mutable alrededor de la trayectoria del gesto del usuario. A continuación, la goma de borrar comprueba si hay intersecciones entre la forma y los cuadros delimitadores de los trazos para determinar qué trazos borrar, lo que hace que la goma de borrar sea intuitiva y precisa.
• Módulo Storage: proporciona funciones de serialización y deserialización eficientes para los datos de tinta, lo que supone un ahorro considerable en el tamaño del disco y de la red. Para guardar los dibujos, Cahier conserva los objetos Stroke en su base de datos Room. En Converters, el ejemplo usa la función encode del módulo de almacenamiento para serializar StrokeInputBatch (los datos de puntos sin procesar) en ByteArray. La matriz de bytes, junto con las propiedades del pincel, se guarda como una cadena JSON. La función decode se usa para reconstruir los trazos cuando se carga una nota.

Además de estos módulos principales, las actualizaciones recientes han ampliado las funciones de la API Ink:

• Las nuevas APIs experimentales para objetos BrushFamily personalizados permiten a los desarrolladores crear tipos de pincel creativos y únicos, lo que ofrece la posibilidad de usar herramientas como los pinceles Lápiz y Puntero láser.

Cahier aprovecha los pinceles personalizados, incluido el pincel de música único que se muestra a continuación, para ilustrar las posibilidades creativas avanzadas.

Láser de arcoíris creado con los pinceles personalizados de la API Ink

Pincel musical creado con los pinceles personalizados de la API Ink

• Los módulos de interoperabilidad nativos de Jetpack Compose simplifican la integración de las funciones de entrada manuscrita directamente en tus interfaces de usuario de Compose para ofrecer una experiencia de desarrollo más idiomática y eficiente.

La API Ink ofrece varias ventajas que la convierten en la opción ideal para las aplicaciones de productividad y creatividad en lugar de una implementación personalizada:

• Facilidad de uso: la API Ink abstrae las complejidades de los gráficos y la geometría, lo que te permite centrarte en las funciones principales de Cahier.
• Rendimiento: la compatibilidad integrada con la baja latencia y la renderización optimizada garantizan una experiencia de escritura fluida y rápida.
• Flexibilidad: el diseño modular te permite elegir los componentes que necesitas, lo que facilita la integración perfecta de la API Ink en la arquitectura de Cahier.

La API Ink ya se ha adoptado en muchas aplicaciones de Google, como la función de marcado de Documentos y la función Rodea para buscar, así como en aplicaciones de partners como Orion Notes y PDF Scanner.

"La API Ink fue nuestra primera opción para Rodea para buscar. Gracias a su amplia documentación, integrar la API Ink fue muy sencillo, lo que nos permitió crear nuestro primer prototipo funcional en tan solo una semana. La textura de pincel personalizada y la compatibilidad con animaciones de Ink nos permitieron iterar rápidamente en el diseño de los trazos". - Jordan Komoda, ingeniero de software de Google

Convertirse en la aplicación de notas predeterminada con el rol de notas

Tomar notas es una función básica que mejora la productividad de los usuarios en dispositivos con pantallas grandes. Con la función de rol de notas, los usuarios pueden acceder a tus aplicaciones compatibles desde la pantalla de bloqueo o mientras se ejecutan otras aplicaciones. Esta función identifica y define aplicaciones predeterminadas para tomar notas en todo el sistema, y les concede permiso para iniciarse y capturar contenido. 

Implementación en Cahier

Para implementar el rol de notas, debes seguir algunos pasos clave, que se muestran en el ejemplo:

1. Declaración del archivo de manifiesto: en primer lugar, la aplicación debe declarar su capacidad para gestionar intents de toma de notas. En AndroidManifest.xml, Cahier incluye un <intent-filter> para la acción android.intent.action.CREATE_NOTE. Esto indica al sistema que la aplicación es un candidato potencial para el rol de notas.
2. Comprobar el estado del rol: SettingsViewModel usa RoleManager de Android para determinar el estado actual. SettingsViewModel comprueba si el rol de notas está disponible en el dispositivo (isRoleAvailable) y si Cahier tiene ese rol (isRoleHeld). Este estado se expone a la interfaz de usuario mediante flujos de Kotlin.
3. Solicitar el rol: en el archivo Settings.kt, se muestra un Button al usuario si el rol está disponible, pero no lo tiene. Cuando se hace clic en el botón, se llama a la función requestNotesRole en ViewModel. La función crea una intent para abrir la pantalla de configuración predeterminada de la aplicación, donde el usuario puede seleccionar Cahier. El proceso se gestiona mediante la API rememberLauncherForActivityResult, que se encarga de iniciar el intent y recibir el resultado.
4. Actualizar la interfaz de usuario: cuando el usuario vuelve de la pantalla de configuración, la retrollamada ActivityResultLauncher activa una función en ViewModel para actualizar el estado del rol, lo que asegura que la interfaz de usuario refleje con precisión si la aplicación es ahora la predeterminada.

Consulta cómo integrar la función de notas en tu aplicación en nuestra guía para crear una aplicación para tomar notas.

Cahier se inicia en una ventana flotante como aplicación predeterminada para tomar notas en una tablet Lenovo

Un gran paso adelante: Lenovo habilita el rol de notas

Nos complace anunciar un gran avance en la productividad de Android en pantallas grandes: Lenovo ha habilitado la compatibilidad con el rol de Notas en tablets con Android 15 y versiones posteriores. Con esta actualización, ahora puedes actualizar tus aplicaciones para tomar notas y permitir que los usuarios con dispositivos Lenovo compatibles las definan como predeterminadas, lo que les dará acceso directo desde la pantalla de bloqueo y desbloqueará las funciones de captura de contenido a nivel del sistema.

Este compromiso de un fabricante líder demuestra la creciente importancia del papel de las notas a la hora de ofrecer una experiencia de usuario verdaderamente integrada y productiva en Android. 

Multiinstancia, multiventana y modo Ventanas

La productividad en una pantalla grande se basa en gestionar la información y los flujos de trabajo de forma eficiente. Por eso, Cahier se ha diseñado para aprovechar al máximo las funciones avanzadas de ventanas de Android, lo que proporciona un espacio de trabajo flexible que se adapta a las necesidades de los usuarios. La aplicación admite lo siguiente:

• Multiventana: la función básica que permite ejecutar una aplicación junto con otra en el modo de pantalla dividida o de formato libre. Es esencial para tareas como consultar una página web mientras tomas notas en Cahier.
• Multiinstancia: aquí es donde la multitarea se muestra en todo su esplendor. Cahier permite a los usuarios abrir varias ventanas independientes de la aplicación simultáneamente. Imagina que comparas dos notas diferentes una al lado de la otra o que consultas una nota de texto en una ventana mientras trabajas en un dibujo en otra. Cahier muestra cómo gestionar estas instancias independientes, cada una con su propio estado, para convertir tu aplicación en una herramienta potente y polifacética.
• Ventanas de ordenador: cuando se conecta a una pantalla externa, el modo Escritorio de Android transforma una tablet o un dispositivo plegable en una estación de trabajo. Como Cahier se ha creado con una interfaz de usuario adaptativa y admite multiinstancia, la aplicación funciona perfectamente en este entorno. Los usuarios pueden abrir, cambiar el tamaño y colocar varias ventanas de Cahier como si estuvieran en un ordenador tradicional, lo que permite realizar flujos de trabajo complejos que antes no se podían llevar a cabo en dispositivos móviles.

Cahier en modo Ventanas en una Pixel Tablet

Así es como hemos implementado estas funciones en Cahier:

Para habilitar la función de multiinstancia, primero teníamos que indicar al sistema que la aplicación admite que se inicie varias veces. Para ello, añadimos la propiedad PROPERTY_SUPPORTS_MULTI_INSTANCE_SYSTEM_UI a la declaración de MainActivity en AndroidManifest:

  <activity

    android:name="com.example.cahier.MainActivity"

    android:exported="true"

    android:label="@string/app_name"

    android:theme="@style/Theme.MyApplication"

    android:showWhenLocked="true"

    android:turnScreenOn="true"

    android:resizeableActivity="true"

    android:launchMode="singleInstancePerTask">


    <property

        android:name="android.window.PROPERTY_SUPPORTS_MULTI_INSTANCE_SYSTEM_UI"

        android:value="true"/>

    ...

</activity>

A continuación, implementamos la lógica para iniciar una nueva instancia de la aplicación. En CahierHomeScreen.kt, cuando un usuario decide abrir una nota en una nueva ventana, creamos un nuevo Intent con marcas específicas que indican al sistema cómo gestionar el inicio de la nueva actividad. La combinación de FLAG_ACTIVITY_NEW_TASK, FLAG_ACTIVITY_MULTIPLE_TASK y FLAG_ACTIVITY_LAUNCH_ADJACENT asegura que la nota se abra en una ventana nueva e independiente junto a la que ya está abierta.

  fun openNewWindow(activity: Activity?, note: Note) {

    val intent = Intent(activity, MainActivity::class.java)

    intent.putExtra(AppArgs.NOTE_TYPE_KEY, note.type)

    intent.putExtra(AppArgs.NOTE_ID_KEY, note.id)

    intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_MULTIPLE_TASK or

        Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT


    activity?.startActivity(intent)

}

Para admitir el modo Multiventana, teníamos que indicar al sistema que la aplicación admite el cambio de tamaño. Para ello, debíamos definir el elemento <activity> o <application> del archivo de manifiesto.

  <activity

    android:name="com.example.cahier.MainActivity"

    android:resizeableActivity="true"

    ...>

</activity>

La interfaz de usuario se ha creado con la biblioteca adaptativa Material 3, lo que le permite adaptarse perfectamente a situaciones multiventana, como el modo Pantalla dividida de Android. 

Para mejorar la experiencia de usuario, hemos añadido la función de arrastrar y soltar. A continuación, te explicamos cómo lo hemos implementado en Cahier.

Arrastrar y soltar

Una aplicación verdaderamente productiva o creativa no funciona de forma aislada, sino que interactúa perfectamente con el resto del ecosistema del dispositivo. La función de arrastrar y soltar es fundamental en esta interacción, sobre todo en pantallas grandes, donde los usuarios suelen trabajar con varias ventanas de aplicaciones. Cahier aprovecha al máximo esta función implementando una función intuitiva de arrastrar y soltar para añadir y compartir contenido.

• Importación sencilla: los usuarios pueden arrastrar imágenes de otras aplicaciones (como un navegador web, una galería de fotos o un administrador de archivos) y soltarlas directamente en el lienzo de una nota. Para ello, Cahier usa el modificador dragAndDropTarget para definir una zona de colocación, comprobar si el contenido es compatible (como image/*) y procesar el URI entrante.
• Compartir contenido fácilmente: el contenido de Cahier se puede compartir con la misma facilidad que el de otras aplicaciones. Los usuarios pueden mantener pulsada una imagen en una nota de texto o mantener pulsado todo el lienzo de una nota de dibujo y una composición de imagen, y arrastrarla a otra aplicación.

Información técnica detallada: arrastrar desde el lienzo de dibujo

Implementar el gesto de arrastre en el lienzo de dibujo supone un reto único. En nuestro DrawingSurface, los composables que gestionan la entrada de dibujo en directo (los InProgressStrokes de la API Ink) y el Box que detecta el gesto de pulsación larga para iniciar un arrastre son composables hermanos.

De forma predeterminada, el sistema de entrada de puntero de Jetpack Compose está diseñado para que solo un elemento componible del mismo nivel (el primero en orden de declaración que se superpone a la ubicación del toque) reciba el evento. En el caso de Cahier, queremos que nuestra lógica de gestión de entradas de arrastrar y soltar tenga la oportunidad de ejecutarse y, potencialmente, consumir entradas antes de que el elemento componible InProgressStrokes use todas las entradas no consumidas para dibujar y, a continuación, consuma esas entradas. Si no colocamos los elementos en el orden correcto, nuestro Box no detectará el gesto de pulsación prolongada para iniciar un arrastre o InProgressStrokes no recibirá la entrada para dibujar.

Para solucionar este problema, hemos creado un modificador pointerInputWithSiblingFallthrough personalizado y hemos colocado nuestro Box con ese modificador antes de InProgressStrokes en el código componible. Esta utilidad es un envoltorio fino del sistema pointerInput estándar, pero con un cambio fundamental: anula la función sharePointerInputWithSiblings() para devolver true. Esto indica al framework Compose que permita que los eventos de puntero se transfieran a los elementos componibles hermanos, incluso después de que se hayan consumido.

  internal fun Modifier.pointerInputWithSiblingFallthrough(

    pointerInputEventHandler: PointerInputEventHandler

) = this then PointerInputSiblingFallthroughElement(pointerInputEventHandler)


private class PointerInputSiblingFallthroughModifierNode(

    pointerInputEventHandler: PointerInputEventHandler

) : PointerInputModifierNode, DelegatingNode() {


    var pointerInputEventHandler: PointerInputEventHandler

        get() = delegateNode.pointerInputEventHandler

        set(value) {

            delegateNode.pointerInputEventHandler = value

        }


    val delegateNode = delegate(

        SuspendingPointerInputModifierNode(pointerInputEventHandler)

    )


    override fun onPointerEvent(

        pointerEvent: PointerEvent,

        pass: PointerEventPass,

        bounds: IntSize

    ) {

        delegateNode.onPointerEvent(pointerEvent, pass, bounds)

    }


    override fun onCancelPointerInput() {

        delegateNode.onCancelPointerInput()

    }


    override fun sharePointerInputWithSiblings() = true

}


private data class PointerInputSiblingFallthroughElement(

    val pointerInputEventHandler: PointerInputEventHandler

) : ModifierNodeElement<PointerInputSiblingFallthroughModifierNode>() {


    override fun create() = PointerInputSiblingFallthroughModifierNode(pointerInputEventHandler)


    override fun update(node: PointerInputSiblingFallthroughModifierNode) {

        node.pointerInputEventHandler = pointerInputEventHandler

    }


    override fun InspectorInfo.inspectableProperties() {

        name = "pointerInputWithSiblingFallthrough"

        properties["pointerInputEventHandler"] = pointerInputEventHandler

    }

}

Así se usa en DrawingSurface:

  Box(

    modifier = Modifier

        .fillMaxSize()

        // Our custom modifier enables this gesture to coexist with the drawing input.

        .pointerInputWithSiblingFallthrough {

            detectDragGesturesAfterLongPress(

                onDragStart = { onStartDrag() },

                onDrag = { _, _ -> /* consume drag events */ },

                onDragEnd = { /* No action needed */ }

            )

        }

) 

// The Ink API's composable for live drawing sits here as a sibling.

InProgressStrokes(...)

De esta forma, el sistema detecta correctamente tanto los trazos del dibujo como el gesto de arrastrar con pulsación prolongada simultáneamente. Una vez que se inicia la acción de arrastrar, creamos un URI content:// compartible con FileProvider y pasamos el URI al marco de arrastrar y soltar del sistema mediante view.startDragAndDrop(). Esta solución ofrece una experiencia de usuario intuitiva y fiable, y muestra cómo superar conflictos complejos de gestos en interfaces de usuario en capas.

Construido con arquitectura moderna

Además de APIs específicas, Cahier muestra patrones de arquitectura cruciales para crear aplicaciones adaptativas de alta calidad.

La capa de presentación: Jetpack Compose y adaptabilidad

La capa de presentación se ha creado por completo con Jetpack Compose. Como hemos mencionado, Cahier adopta la biblioteca material3-adaptive para la adaptabilidad de la interfaz de usuario. La gestión del estado sigue un patrón estricto de flujo de datos unidireccional (UDF), con instancias de ViewModel que se usan como contenedores de datos que almacenan información de notas y el estado de la interfaz de usuario.

La capa de datos: repositorios y Room

En el caso de la capa de datos, Cahier usa una interfaz NoteRepository para abstraer todas las operaciones de datos. Esta decisión de diseño permite que la aplicación cambie entre una fuente de datos local (Room) y un posible backend remoto en el futuro. El flujo de datos de una acción como editar una nota es sencillo:

1. La interfaz de usuario de Jetpack Compose activa un método en ViewModel.
2. El ViewModel obtiene la nota de NoteRepository, gestiona la lógica y devuelve la nota actualizada al repositorio.
3. NoteRepository guarda la actualización en una base de datos Room.

Compatibilidad integral con las entradas

Para ser una auténtica herramienta de productividad, una aplicación debe gestionar una gran variedad de métodos de entrada sin problemas. Cahier se ha diseñado para cumplir las directrices de entrada para pantallas grandes y admite lo siguiente:

• Lápiz: integración con la API Ink, rechazo de la palma de la mano, registro para el rol de notas, entrada con lápiz en campos de texto y modo inmersivo.
• Teclado: compatibilidad con las combinaciones y las combinaciones de teclas más habituales (como Ctrl + clic o Meta + clic) e indicación clara del foco del teclado.
• Ratón y panel táctil: compatibilidad con los estados de clic con el botón derecho y de colocación del cursor.

La compatibilidad con interacciones avanzadas con el teclado, el ratón y el panel táctil es un aspecto clave para seguir mejorando. 

Empieza hoy mismo

Esperamos que Cahier te sirva de plataforma de lanzamiento para tu próxima gran aplicación. La hemos creado para que sea un recurso completo de código abierto que muestre cómo combinar una interfaz de usuario adaptativa, APIs potentes como Ink y el rol de notas, y una arquitectura moderna y adaptativa.

¿Empezamos?

• Explora el código: visita nuestro repositorio de GitHub para descubrir la base de código de Cahier y ver los principios de diseño en acción.
• Crea tu propia aplicación: usa Cahier como base para tu propia aplicación de toma de notas, marcado de documentos o creativa.
• Contribuye: tus aportaciones son muy valiosas. Ayúdanos a convertir Cahier en un recurso aún mejor para la comunidad de desarrolladores de Android.

Consulta las guías oficiales para desarrolladores y empieza a crear tu aplicación de productividad y creatividad de nueva generación hoy mismo. ¡Estamos deseando ver tus creaciones!