Ink API kini dalam versi beta dan siap diintegrasikan ke dalam aplikasi Anda. Pencapaian ini dimungkinkan oleh masukan berharga dari developer, yang menghasilkan peningkatan berkelanjutan dalam performa, stabilitas, dan kualitas visual API.

Aplikasi Google, seperti Google Dokumen, Pixel Studio, Google Foto, PDF Chrome, Pembuat Efek YouTube, dan fitur unik di Android seperti Lingkari untuk Menelusuri semuanya menggunakan API terbaru. 

Untuk menandai pencapaian ini, dengan senang hati kami mengumumkan peluncuran Cahier, contoh aplikasi pencatat yang komprehensif dan dioptimalkan untuk perangkat Android dari semua ukuran, terutama tablet dan ponsel foldable.

Apa itu Cahier?

Cahier ("buku catatan" dalam bahasa Prancis) adalah aplikasi contoh yang dirancang untuk mendemonstrasikan cara membuat aplikasi yang memungkinkan pengguna mencatat dan mengatur pemikiran mereka dengan menggabungkan teks, gambar, dan foto. 

Contoh ini dapat berfungsi sebagai referensi utama untuk meningkatkan produktivitas dan kreativitas pengguna di layar besar. Codelab ini menunjukkan praktik terbaik untuk membangun pengalaman tersebut, mempercepat pemahaman dan adopsi developer terhadap API dan teknik canggih terkait. Postingan ini akan memandu Anda memahami fitur inti Cahier, API utama, dan keputusan arsitektur yang menjadikan sampel ini sebagai referensi yang bagus untuk aplikasi Anda sendiri.

Fitur utama yang ditunjukkan dalam contoh meliputi:

• Pembuatan catatan serbaguna: Menunjukkan cara menerapkan sistem pembuatan konten fleksibel yang mendukung beberapa format dalam satu catatan, termasuk teks, gambar bentuk bebas, dan lampiran gambar.
• Alat tinta kreatif: Menerapkan pengalaman menggambar berperforma tinggi dan berlatensi rendah menggunakan Ink API. Contoh ini memberikan contoh praktis tentang cara mengintegrasikan berbagai kuas, pemilih warna, fungsi urungkan/ulangi, dan alat penghapus.
• Integrasi konten lancar dengan tarik lalu lepas: Menunjukkan cara menangani konten masuk dan keluar menggunakan tarik lalu lepas. Hal ini mencakup menerima gambar yang dilepas dari aplikasi lain dan memungkinkan pengguna menarik konten keluar dari aplikasi Anda untuk berbagi dengan lancar.
• Pengelolaan catatan: Tandai catatan sebagai favorit untuk akses cepat. Memfilter tampilan agar tetap teratur.
• Arsitektur offline first:  Dibangun dengan arsitektur offline first menggunakan Room, sehingga semua data disimpan secara lokal dan aplikasi tetap berfungsi penuh tanpa koneksi internet.
• Dukungan multi-aplikasi dan multi-instance yang canggih: Menunjukkan cara mendukung multi-instance, yang memungkinkan aplikasi Anda diluncurkan di beberapa jendela sehingga pengguna dapat mengerjakan berbagai catatan secara berdampingan, sehingga meningkatkan produktivitas dan kreativitas di layar besar.
• UI adaptif untuk semua layar: Antarmuka pengguna beradaptasi dengan lancar ke berbagai ukuran dan orientasi layar menggunakan ListDetailPaneScaffold dan NavigationSuiteScaffold untuk memberikan pengalaman pengguna yang dioptimalkan di ponsel, tablet, dan perangkat foldable.
• Integrasi sistem yang mendalam: Memberikan panduan tentang cara menjadikan aplikasi Anda sebagai aplikasi pencatat default di Android 14 dan yang lebih tinggi dengan merespons intent Catatan di seluruh sistem, sehingga memungkinkan pengambilan konten yang cepat dari berbagai titik entri sistem.

Dibuat untuk produktivitas dan kreativitas di layar besar

Untuk peluncuran awal, kami memusatkan pengumuman pada beberapa fitur inti yang menjadikan Cahier sebagai sumber pembelajaran utama untuk kasus penggunaan produktivitas dan kreativitas.

Dasar adaptasi

Cahier dibuat agar adaptif dari awal. Contoh ini menggunakan library material3-adaptive, khususnya ListDetailPaneScaffold dan NavigationSuiteScaffold untuk menyesuaikan tata letak aplikasi dengan lancar ke berbagai ukuran dan orientasi layar. Ini adalah elemen penting untuk aplikasi Android modern, dan Cahier memberikan contoh yang jelas tentang cara menerapkannya secara efektif.

UI adaptif Cahier yang dibuat dengan library Adaptif Material 3

Menampilkan API dan integrasi utama

Contoh ini berfokus pada demonstrasi API produktivitas canggih yang dapat Anda manfaatkan dalam aplikasi Anda sendiri, termasuk:

• Ink API
• Peran catatan
• Multi-instance, Multi-aplikasi, dan Mode jendela desktop
• Tarik lalu lepas

Mempelajari lebih lanjut API utama

Mari kita pelajari lebih dalam dua API utama yang diintegrasikan Cahier untuk memberikan pengalaman mencatat yang terbaik.

Membuat pengalaman penintaan alami dengan Ink API

Input stilus mengubah perangkat layar besar menjadi buku catatan dan buku sketsa digital. Untuk membantu Anda membangun pengalaman penulisan tangan yang lancar dan alami, kami telah menjadikan Ink API sebagai fondasi contoh. Ink API memudahkan pembuatan, rendering, dan manipulasi goresan tulisan tangan yang indah dengan latensi rendah terbaik di kelasnya.

Ink API menawarkan arsitektur modular, sehingga Anda dapat menyesuaikannya dengan stack dan kebutuhan spesifik aplikasi Anda. Modul API mencakup:

• Modul penulisan (Compose - tampilan): Menangani input tinta real-time untuk membuat goresan halus dengan latensi terendah yang dapat disediakan perangkat.
  • Di DrawingSurface, Cahier menggunakan composable InProgressStrokes yang baru diperkenalkan untuk menangani input sentuh atau stylus real-time. Modul ini bertanggung jawab untuk merekam peristiwa penunjuk dan merender goresan tinta basah dengan latensi serendah mungkin.
• Modul Stroke:Merepresentasikan input tinta dan representasi visualnya. pengguna selesai menggambar garis, callback onStrokesFinished memberikan objek Stroke yang telah diselesaikan/dikeringkan ke aplikasi. Objek yang tidak dapat diubah ini, yang merepresentasikan goresan tinta yang telah selesai, kemudian dikelola di DrawingCanvasViewModel.
• Modul rendering: Menampilkan goresan tinta secara efisien, sehingga dapat digabungkan dengan Compose Jetpack atau tampilan Android.
  • Untuk menampilkan goresan yang sudah ada dan yang baru dikeringkan, Cahier menggunakan CanvasStrokeRenderer di DrawingSurface untuk gambar aktif dan di DrawingDetailPanePreview untuk menampilkan pratinjau statis catatan. Modul ini secara efisien menggambar objek Stroke ke Canvas.
• Modul kuas (Compose - tampilan): Memberikan cara deklaratif untuk menentukan gaya visual goresan. Update terbaru (sejak rilis alpha03) mencakup kuas garis putus-putus baru, yang sangat berguna untuk fitur seperti seleksi lasso. DrawingCanvasViewModel menyimpan status untuk currentBrush. Kotak alat di DrawingCanvas memungkinkan pengguna memilih berbagai jenis kuas (seperti StockBrushes.pressurePen() atau StockBrushes.highlighter()) dan mengubah warna. ViewModel memperbarui objek Brush, yang kemudian digunakan oleh composable InProgressStrokes untuk goresan baru.
• Modul geometri (Compose - tampilan): Mendukung manipulasi dan analisis goresan untuk fitur seperti menghapus dan memilih.
  • Alat penghapus dalam toolbox dan fungsi di DrawingCanvasViewModel mengandalkan modul geometri. Saat penghapus aktif, penghapus akan membuat MutableParallelogram di sekitar jalur gestur pengguna. Kemudian, penghapus memeriksa persimpangan antara bentuk dan kotak pembatas goresan yang ada untuk menentukan goresan mana yang akan dihapus, sehingga penghapus terasa intuitif dan presisi.
• Modul Storage: Menyediakan kemampuan serialisasi dan deserialisasi yang efisien untuk data tinta, sehingga menghemat ukuran disk dan jaringan secara signifikan. Untuk menyimpan gambar, Cahier mempertahankan objek Stroke di database Room-nya. Di Converter, contoh menggunakan fungsi encode modul penyimpanan untuk melakukan serialisasi StrokeInputBatch (data titik mentah) menjadi ByteArray. Array byte, beserta properti kuas, disimpan sebagai string JSON. Fungsi decode digunakan untuk merekonstruksi goresan saat catatan dimuat.

Selain modul inti ini, update terbaru telah memperluas kemampuan Ink API:

• API eksperimental baru untuk objek BrushFamily kustom memungkinkan developer membuat jenis kuas yang kreatif dan unik, sehingga memberikan kemungkinan untuk alat seperti kuas Pensil dan Pointer Laser.

Cahier memanfaatkan kuas kustom, termasuk kuas musik unik yang ditampilkan di bawah, untuk menggambarkan kemungkinan kreatif tingkat lanjut.

Laser pelangi dibuat dengan kuas kustom Ink API

Kuas musik yang dibuat dengan kuas kustom Ink API

• Modul interoperabilitas Jetpack Compose native menyederhanakan integrasi fungsi tinta langsung dalam UI Compose Anda untuk pengalaman pengembangan yang lebih idiomatik dan efisien.

Ink API menawarkan beberapa keuntungan yang menjadikannya pilihan ideal untuk aplikasi produktivitas dan kreativitas dibandingkan dengan implementasi kustom:

• Kemudahan penggunaan: Ink API menyederhanakan kompleksitas grafis dan geometri, sehingga Anda dapat berfokus pada fitur inti Cahier.
• Performa: Dukungan latensi rendah bawaan dan rendering yang dioptimalkan memastikan pengalaman penulisan tangan yang lancar dan responsif.
• Fleksibilitas: Desain modular memungkinkan Anda memilih komponen yang diperlukan, sehingga memungkinkan integrasi Ink API yang lancar ke dalam arsitektur Cahier.

Ink API telah diterapkan di banyak aplikasi Google, termasuk untuk markup di Dokumen dan untuk fitur Lingkari untuk Menelusuri serta aplikasi partner seperti Orion Notes, dan PDF Scanner.

“Ink API adalah pilihan pertama kami untuk fitur Lingkari untuk Menelusuri (CtS). Dengan memanfaatkan dokumentasi yang ekstensif, integrasi Ink API menjadi sangat mudah, sehingga kami dapat mencapai prototipe kerja pertama dalam waktu hanya satu minggu. Dukungan animasi dan tekstur kuas kustom Ink memungkinkan kami melakukan iterasi dengan cepat pada desain goresan.” - Jordan Komoda, Software Engineer - Google

Menjadi aplikasi catatan default dengan peran catatan

Pembuatan catatan adalah kemampuan inti yang meningkatkan produktivitas pengguna di perangkat layar besar. Dengan fitur peran catatan, pengguna dapat mengakses aplikasi yang kompatibel dari layar kunci atau saat aplikasi lain sedang berjalan. Fitur ini mengidentifikasi dan menyetel aplikasi pencatat default di seluruh sistem serta memberikan izin untuk diluncurkan guna merekam konten. 

Penerapan di Cahier

Penerapan peran catatan melibatkan beberapa langkah penting, yang semuanya ditunjukkan dalam contoh:

1. Deklarasi manifes: Pertama, aplikasi harus mendeklarasikan kemampuannya untuk menangani intent pencatatan. Di AndroidManifest.xml, Cahier menyertakan <intent-filter> untuk tindakan android.intent.action.CREATE_NOTE. Hal ini memberi sinyal kepada sistem bahwa aplikasi adalah kandidat potensial untuk peran catatan.
2. Memeriksa status peran: SettingsViewModel menggunakan RoleManager Android untuk menentukan status saat ini. SettingsViewModel memeriksa apakah peran catatan tersedia di perangkat (isRoleAvailable) dan apakah Cahier saat ini memegang peran tersebut (isRoleHeld). Status ini diekspos ke UI menggunakan aliran Kotlin.
3. Meminta peran: Dalam file Settings.kt, Button ditampilkan kepada pengguna jika peran tersedia tetapi tidak dimiliki. Saat diklik, tombol akan memanggil fungsi requestNotesRole di ViewModel. Fungsi ini membuat intent untuk membuka layar setelan aplikasi default tempat pengguna dapat memilih Cahier. Proses ini dikelola menggunakan API rememberLauncherForActivityResult, yang menangani peluncuran intent dan penerimaan hasil.
4. Memperbarui UI: Setelah pengguna kembali dari layar setelan, callback ActivityResultLauncher memicu fungsi di ViewModel untuk memperbarui status peran, sehingga memastikan UI mencerminkan secara akurat apakah aplikasi kini menjadi aplikasi default.

Pelajari cara mengintegrasikan peran catatan di aplikasi Anda dalam panduan membuat aplikasi pencatatan kami.

Cahier diluncurkan di jendela mengambang sebagai aplikasi pencatat default di tablet Lenovo

Langkah maju yang signifikan: Lenovo mengaktifkan peran catatan

Dengan senang hati kami mengumumkan langkah maju yang signifikan untuk produktivitas Android di layar besar: Lenovo telah mengaktifkan dukungan untuk Peran Catatan di tablet yang menjalankan Android 15 dan yang lebih tinggi. Dengan update ini, Anda kini dapat mengupdate aplikasi pencatat untuk memungkinkan pengguna dengan perangkat Lenovo yang kompatibel menyetelnya sebagai aplikasi default, sehingga memberikan akses yang lancar dari layar kunci dan membuka fitur pengambilan konten tingkat sistem.

Komitmen dari OEM terkemuka ini menunjukkan semakin pentingnya peran catatan dalam memberikan pengalaman pengguna yang benar-benar terintegrasi dan produktif di Android. 

Multi-instance, multi-aplikasi, dan mode jendela desktop

Produktivitas di layar besar adalah tentang mengelola informasi dan alur kerja secara efisien. Itulah sebabnya Cahier dibuat untuk sepenuhnya memanfaatkan kemampuan tampilan jendela canggih Android, sehingga memberikan ruang kerja fleksibel yang beradaptasi dengan kebutuhan pengguna. Aplikasi ini mendukung:

• Multi-aplikasi: Kemampuan mendasar untuk berjalan bersama aplikasi lain dalam mode layar terpisah atau bentuk bebas. Hal ini penting untuk tugas seperti merujuk halaman web saat membuat catatan di Cahier.
• Multi-instance: Di sinilah multitasking yang sebenarnya terlihat. Cahier memungkinkan pengguna membuka beberapa jendela aplikasi yang independen secara bersamaan. Bayangkan membandingkan dua catatan yang berbeda secara berdampingan atau merujuk catatan teks di satu jendela saat mengerjakan gambar di jendela lain. Cahier menunjukkan cara mengelola instance terpisah ini, yang masing-masing memiliki statusnya sendiri, sehingga mengubah aplikasi Anda menjadi alat yang canggih dan multifaset.
• Mode jendela desktop: Saat terhubung ke layar eksternal, mode desktop Android mengubah tablet atau perangkat foldable menjadi workstation. Karena Cahier dibuat dengan UI adaptif dan mendukung multi-instance, aplikasi ini berfungsi dengan baik di lingkungan ini. Pengguna dapat membuka, mengubah ukuran, dan memosisikan beberapa jendela Cahier seperti di desktop tradisional, sehingga memungkinkan alur kerja kompleks yang sebelumnya tidak dapat dilakukan di perangkat seluler.

Cahier berjalan dalam mode jendela desktop di Pixel Tablet

Berikut cara kami menerapkan fitur ini di Cahier:

Untuk mengaktifkan multi-instance, kita harus memberi sinyal terlebih dahulu kepada sistem bahwa aplikasi mendukung peluncuran beberapa kali dengan menambahkan properti PROPERTY_SUPPORTS_MULTI_INSTANCE_SYSTEM_UI ke deklarasi MainActivity di 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>

Selanjutnya, kita menerapkan logika untuk meluncurkan instance baru aplikasi. Di CahierHomeScreen.kt, saat pengguna memilih untuk membuka catatan di jendela baru, kita membuat Intent baru dengan tanda tertentu yang menginstruksikan sistem tentang cara menangani peluncuran aktivitas baru. Kombinasi FLAG_ACTIVITY_NEW_TASK, FLAG_ACTIVITY_MULTIPLE_TASK, dan FLAG_ACTIVITY_LAUNCH_ADJACENT memastikan catatan terbuka di jendela baru yang terpisah bersama dengan jendela yang ada.

  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)

}

Untuk mendukung mode multi-aplikasi, kita perlu memberi sinyal kepada sistem bahwa aplikasi mendukung pengubahan ukuran dengan menyetel elemen <activity> atau <application> Manifes.

  <activity

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

    android:resizeableActivity="true"

    ...>

</activity>

UI yang dibuat dengan library adaptif Material 3 dapat beradaptasi dengan lancar dalam skenario multi-aplikasi seperti mode layar terpisah Android. 

Untuk meningkatkan pengalaman pengguna, kami menambahkan dukungan untuk tarik lalu lepas. Lihat di bawah cara kami menerapkan hal ini di Cahier.

Tarik lalu lepas

Aplikasi yang benar-benar produktif atau kreatif tidak berfungsi secara terpisah; aplikasi berinteraksi dengan lancar dengan ekosistem perangkat lainnya. Tarik lalu lepas adalah fondasi interaksi ini, terutama di layar besar tempat pengguna sering kali bekerja di beberapa jendela aplikasi. Cahier sepenuhnya mendukung hal ini dengan menerapkan fungsi tarik lalu lepas yang intuitif untuk menambahkan dan membagikan konten.

• Pengimporan yang Mudah: Pengguna dapat menarik gambar dari aplikasi lain—seperti browser web, galeri foto, atau pengelola file—dan meletakkannya langsung ke kanvas catatan. Untuk itu, Cahier menggunakan pengubah dragAndDropTarget untuk menentukan area pelepasan, memeriksa konten yang kompatibel (seperti image/*), dan memproses URI yang masuk.
• Berbagi yang mudah: Konten di dalam Cahier sama mudahnya untuk dibagikan seperti konten dari aplikasi lain. Pengguna dapat menekan lama gambar dalam catatan teks, atau menekan lama seluruh kanvas catatan gambar dan komposit gambar, lalu menariknya ke aplikasi lain.

Pembahasan mendalam teknis: Menarik dari kanvas gambar

Menerapkan gestur tarik di kanvas gambar menghadirkan tantangan yang unik. Di DrawingSurface, composable yang menangani input gambar langsung (InProgressStrokes Ink API) dan Box yang mendeteksi gestur tekan lama untuk memulai penarikan adalah composable saudara.

Secara default, sistem input pointer Jetpack Compose dirancang agar hanya satu composable turunan—yang pertama dalam urutan deklarasi yang tumpang-tindih dengan lokasi sentuhan—yang menerima peristiwa. Dalam kasus Cahier, kita ingin logika penanganan input tarik lalu lepas kita memiliki kesempatan untuk berjalan dan berpotensi menggunakan input sebelum composable InProgressStrokes menggunakan semua input yang tidak digunakan untuk menggambar, lalu menggunakan input tersebut. Jika kita tidak mengatur hal-hal dalam urutan yang benar, Box tidak akan mendeteksi gestur tekan lama untuk memulai penarikan, atau InProgressStrokes tidak akan menerima input untuk menggambar.

Untuk mengatasinya, kita membuat pengubah pointerInputWithSiblingFallthrough kustom, dan kita menempatkan Box menggunakan pengubah tersebut sebelum InProgressStrokes dalam kode composable. Utilitas ini adalah wrapper tipis di sekitar sistem pointerInput standar, tetapi dengan satu perubahan penting: mengganti fungsi sharePointerInputWithSiblings() untuk menampilkan true. Tindakan ini memberi tahu framework Compose untuk mengizinkan peristiwa pointer diteruskan ke composable saudara, bahkan setelah digunakan.

  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

    }

}

Berikut cara menggunakannya di 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(...)

Dengan adanya hal ini, sistem akan mendeteksi goresan gambar dan gestur tarik tekan lama secara bersamaan dengan benar. Setelah penarikan dimulai, kita membuat URI content:// yang dapat dibagikan dengan FileProvider dan meneruskan URI ke framework tarik lalu lepas sistem menggunakan view.startDragAndDrop(). Solusi ini memastikan pengalaman pengguna yang andal dan intuitif, yang menunjukkan cara mengatasi konflik gestur yang kompleks dalam UI berlapis.

Dibangun dengan arsitektur modern

Selain API tertentu, Cahier menunjukkan pola arsitektur penting untuk membangun aplikasi adaptif berkualitas tinggi.

Lapisan presentasi: Jetpack Compose dan kemampuan beradaptasi

Lapisan presentasi dibuat sepenuhnya dengan Jetpack Compose. Seperti yang disebutkan, Cahier mengadopsi library material3-adaptive untuk kemampuan beradaptasi UI. Pengelolaan status mengikuti pola Aliran Data Searah (UDF) yang ketat, dengan instance ViewModel digunakan sebagai penampung data yang menyimpan informasi catatan dan status UI.

Lapisan data: Repositori dan Room

Untuk lapisan data, Cahier menggunakan antarmuka NoteRepository untuk memisahkan semua operasi data. Pilihan desain ini memungkinkan aplikasi beralih dengan mudah antara sumber data lokal (Room) dan backend jarak jauh yang mungkin ada di masa mendatang. Alur data untuk tindakan seperti mengedit catatan sangat mudah:

1. UI Jetpack Compose memicu metode di ViewModel.
2. ViewModel mengambil catatan dari NoteRepository, menangani logika, dan meneruskan catatan yang diperbarui kembali ke repositori.
3. NoteRepository menyimpan pembaruan ke database Room.

Dukungan input komprehensif

Agar menjadi pendorong produktivitas yang sesungguhnya, aplikasi harus menangani berbagai metode input dengan sempurna. Cahier dibuat agar sesuai dengan pedoman input layar besar dan mendukung:

• Stilus: Integrasi dengan Ink API, penolakan telapak tangan, pendaftaran untuk peran catatan, input stilus di kolom teks, dan mode imersif.
• Keyboard: Dukungan untuk sebagian besar pintasan dan kombinasi keyboard umum (seperti ctrl+klik, meta+klik) dan indikasi yang jelas untuk fokus keyboard.
• Mouse dan trackpad: Dukungan untuk klik kanan dan status pengarahan kursor.

Dukungan untuk interaksi keyboard, mouse, dan trackpad lanjutan adalah fokus utama untuk peningkatan lebih lanjut. 

Mulai sekarang juga

Kami harap Cahier dapat menjadi titik awal untuk aplikasi hebat Anda berikutnya. Kami membangunnya sebagai referensi open source yang komprehensif yang menunjukkan cara menggabungkan UI adaptif, API canggih seperti peran tinta dan catatan, serta arsitektur modern dan adaptif.

Siap untuk memulai?

• Jelajahi kode: Buka repositori GitHub kami untuk menjelajahi codebase Cahier dan melihat penerapan prinsip desain.
• Bangun aplikasi Anda sendiri: Gunakan Cahier sebagai dasar untuk aplikasi pencatatan, markup dokumen, atau aplikasi kreatif Anda sendiri.
• Beri kontribusi: Kami menerima kontribusi Anda. Bantu kami menjadikan Cahier sebagai sumber daya yang lebih baik lagi bagi komunitas developer Android.

Lihat panduan developer resmi dan mulai bangun aplikasi produktivitas dan kreativitas generasi berikutnya sekarang. Kami tidak sabar ingin melihat kreasi Anda.