ChatNote is a modular, chat-style note-taking application designed for efficient note
organization.
The app follows best practices in Android development, implementing Clean Architecture, Dependency
Injection (DI), event-driven state management, and a well-structured modular approach to ensure
scalability and maintainability.
- Chat-style note-taking: Each note is entered and saved as if sending a message.
- Local storage: Notes are stored securely on the device.
- Folder-based organization: Notes are grouped into folders similar to chat conversations.
- Customizable folder icons: Default icons assigned with options for user customization.
- Optimized state management: Uses event-driven architecture for handling UI state and updates.
 |
 |
 |
 |
 |
 |
 |
ChatNote follows Clean Architecture principles with a modular approach:
core-data: Contains shared data models, database entities, and Room configurations.core-domain: Houses use cases and domain-specific business logic.core-ui: Includes shared UI components, themes, and utility classes.
common: Contains shared components and utilities used across the app.content: Centralized module for storing and managing all application strings.ui-kit: Provides shared UI building blocks such as the image picker and image viewer components.
navigation: Manages type-safe navigation throughout the app.
The feature module contains feature-specific submodules, each divided into three layers:
directnotes-data: Data layer for managing note-specific database operations.directnotes-domain: Domain layer for note-related use cases.directnotes-ui: UI layer for displaying and interacting with individual notes.
homelist-data: Data layer for managing folder-related database operations.homelist-domain: Domain layer for folder-related use cases.homelist-ui: UI layer for displaying and interacting with the folder list.
This project does not include the google-services.json file required for Firebase integration.
If
you want to build the app, you need to provide your own google-services.json file.
ChatNote uses Hilt for DI to ensure proper separation of concerns and efficient dependency
management. ViewModels only inject use cases to keep UI logic clean.
The app utilizes event-driven architecture with Flow, StateFlow, and Channel for
handling state updates and one-time events. This approach avoids unnecessary recompositions and
ensures optimal performance.
- Modularization: Clearly defined boundaries between core, common, and feature modules.
- DI with Hilt: Ensures testability and maintainability.
- Event-driven design: Efficient handling of UI events without unnecessary state persistence.
- StateFlow for UI updates: Ensures real-time updates with proper lifecycle awareness.
- Efficient data handling: Uses Room with optimized queries and caching mechanisms.
The goal of ChatNote is to provide an intuitive, lightweight note-taking experience inspired by
messaging apps. By structuring notes in a familiar chat-like format, users can quickly create,
edit,
and organize their thoughts. The app is designed to be fast, modular, and scalable, allowing
future enhancements such as cloud backup and collaboration features.
- Kotlin
- Jetpack Compose
- Hilt (DI)
- Room (Database)
- Flow, StateFlow & Channel (Reactive State Management)
- Coroutines (Asynchronous Processing)
- Type-Safe Navigation
To set up the project:
# Clone the repository
$ git clone https://github.com/8codehub/ChatNote.git
$ cd ChatNote
# Build the project
$ ./gradlew assembleDebug