A native Android task management application built with Java and Room Database, featuring local user authentication, custom categories, task priorities, deadlines, completion tracking and persistent local storage.
SmartTodo Android is a native Android task management application developed in Java.
The application allows users to register and log in locally, organise tasks into custom categories, assign priorities and deadlines, track remaining time, mark tasks as completed, update existing tasks and remove individual or groups of tasks.
Rather than storing tasks only for the duration of an application session, SmartTodo uses Room Database for persistent local storage. The project separates database access through entities, DAOs, a repository and ViewModels, while LiveData is used to expose stored data to the user interface.
The application was originally developed as an Android project and has been preserved as a demonstration of native Android development, local persistence and structured task-management functionality.
The main task list provides an overview of saved tasks, their priorities, deadlines and current completion state.
SmartTodo includes user registration and login backed by the application's local Room database.
The authentication flow includes:
- User registration
- Email and password input
- Password confirmation
- Phone number input
- Form validation
- Credential checking
- Invalid-login feedback
- Persistent login state using
SharedPreferences - Logout functionality
Note: Authentication is implemented locally as part of the original project and is not intended to represent a production-grade authentication or security system.
Users can create tasks containing detailed information rather than only a task title.
Each task can contain:
- Title
- Description
- Category
- Due date
- Due time
- Priority
- Completion state
Tasks are persisted locally through Room Database and displayed through a RecyclerView-based task interface.
Tasks can be assigned one of three priority levels:
- 🔴 High
- 🟡 Medium
- 🟢 Low
Priority is visually represented in the task list, allowing important tasks to be identified quickly.
SmartTodo provides deadline-aware task tracking using the selected due date and time.
For active tasks, the application calculates and displays the remaining time until the deadline.
For example:
remaining:
2d 4h 17m
Expired tasks can be identified when their deadline has passed.
For completed tasks, the application calculates the elapsed time between task creation and completion and displays a completed-in duration instead of the remaining-time countdown.
Users can create their own categories to organise tasks into meaningful groups.
Category functionality includes:
- Creating categories
- Viewing saved categories
- Editing categories
- Deleting categories
- Clearing categories
- Associating tasks with categories
- Viewing tasks belonging to a selected category
The task-category relationship is maintained through the Room database. If a category is removed, associated tasks can remain in the database without retaining an invalid category reference.
Existing tasks can be reopened and modified.
When editing a task, its existing information is loaded back into the form, allowing the user to change its:
- Title
- Description
- Category
- Deadline
- Priority
- Completion state
The updated information is then persisted back to the local database.
SmartTodo uses mobile gestures to make common task operations faster.
Task cards support swipe-based interaction:
- Swipe right → Delete task
- Swipe left → Mark task as completed
This provides a more natural mobile interaction than requiring every operation to be accessed through additional buttons or menus.
The task menu provides additional management functionality.
Available operations include:
- Add Task
- Delete all tasks
- Delete all completed tasks
- Open the Category List
- Logout
This allows users to manage both individual tasks and the wider task collection.
The application separates the user interface from local data access through Android architecture components.
┌─────────────────────────────┐
│ Activities / UI │
│ Fragments │
└──────────────┬──────────────┘
│
▼
┌─────────────────────────────┐
│ ViewModels │
│ LiveData │
└──────────────┬──────────────┘
│
▼
┌─────────────────────────────┐
│ Repository │
└──────────────┬──────────────┘
│
▼
┌─────────────────────────────┐
│ DAOs │
│ │
│ UserDao │
│ CategoryDao │
│ TodoDao │
└──────────────┬──────────────┘
│
▼
┌─────────────────────────────┐
│ Room Database │
│ │
│ User • Category • Todo │
└─────────────────────────────┘
The repository acts as an intermediary between the ViewModels and Room DAOs, while database write operations are handled away from the main UI thread.
The Room database is centred around three primary entities.
Stores information required for local account registration and login.
Represents user-created organisational groups for tasks.
Examples include:
Personal
University
Work
Represents an individual task and stores information including:
Title
Description
Due Date / Time
Priority
Category
Completion State
Creation Date
Completion Time
A Todo can reference a Category through the application's Room relationship.
SmartTodo implements the complete task CRUD lifecycle:
| Operation | Implementation |
|---|---|
| Create | Add new tasks and categories |
| Read | Display stored tasks and categories |
| Update | Edit existing task/category information |
| Delete | Delete individual tasks/categories and perform bulk deletion |
This functionality is implemented through dedicated Room DAO operations and exposed to the application through the repository and ViewModel layers.
| Technology | Purpose |
|---|---|
| Java | Primary application language |
| Android SDK | Native Android application development |
| Room 2.5.1 | Local relational persistence |
| SQLite | Underlying local database |
| AndroidX | Android support libraries |
| ViewModel | UI-related data management |
| LiveData | Observable application data |
| RecyclerView | Dynamic task/category lists |
| Material Components | Android interface components |
| ConstraintLayout | Responsive Android layouts |
| SharedPreferences | Local login/session state |
| Gradle | Build and dependency management |
| Glide | Image/resource handling |
| android-gif-drawable | GIF support |
The original project configuration uses:
compileSdk: 33
targetSdk: 33
minSdk: 24
Java compatibility: Java 8
Room: 2.5.1
The application has also been successfully run on a modern Android emulator while preserving the original project implementation.
app/
└── src/
└── main/
├── java/
│ └── ...
│ ├── Activities / Fragments
│ ├── Adapters
│ ├── ViewModels
│ ├── Repository
│ ├── DAOs
│ └── Room Entities
│
├── res/
│ ├── drawable/
│ ├── layout/
│ ├── mipmap/
│ └── values/
│
└── AndroidManifest.xml
- Android Studio
- Android SDK
- Compatible JDK
- Android emulator or physical Android device
- Clone the repository:
git clone https://github.com/Avis-shek/SmartTodo-Android.git-
Open Android Studio.
-
Select Open and choose the project root directory.
-
Allow Gradle to sync and download the required dependencies.
-
Select an Android emulator or connected physical device.
-
Run the
appconfiguration.
The original application targets Android API 33, with a minimum supported API level of 24.
SmartTodo demonstrates practical experience with:
- Native Android development using Java
- Android application lifecycle and navigation
- Room Database
- Relational local data modelling
- Entity relationships
- DAO-based database operations
- Repository-based data access
- ViewModels and LiveData
- RecyclerView interfaces
- CRUD functionality
- Form validation
- Local authentication
- SharedPreferences
- Category-based data organisation
- Date and time handling
- Dynamic countdown calculations
- Priority-based task management
- Gesture-based mobile interactions
- Persistent application state
If rebuilding SmartTodo today, I would consider:
- Migrating the interface to Jetpack Compose
- Using Kotlin for modern Android development
- Implementing secure password hashing or external authentication
- Adding cloud synchronisation
- Adding push notifications and deadline reminders
- Introducing recurring tasks
- Adding task search, sorting and advanced filtering
- Adding dark mode
- Expanding automated unit and UI testing
- Migrating remaining asynchronous database operations to modern coroutine-based patterns
- Introducing dependency injection for improved maintainability and testability
Completed Android application — maintained as a portfolio project demonstrating native Android development, Room persistence and structured task management.