A Flutter-powered, RFID-driven attendance kiosk with real-time online sync, intelligent offline resilience, voice feedback, and live ambient intelligence — designed to run 24 × 7 without manual intervention.
The Attendance Marker is a fully self-contained, kiosk-style Flutter application built by Inurum Technologies. It is installed on Android tablets or mobile phones, connects to an external RFID/NFC reader via USB serial, and provides a complete, automated attendance recording experience — entirely hands-off for employees.
An external RFID reader is connected to the Android device via USB. The app listens for
card UIDs in real time using a custom USB serial protocol, parses the $02,
packet format, and triggers the full attendance workflow instantly.
When the internet is available, every scan is sent to the Inurum cloud backend in real time. When offline, scans are queued locally in a Hive database. The moment the connection is restored, the system automatically bulk-syncs all pending records.
Every check-in greets the employee by name: "Welcome, Manish!" Every check-out bids farewell: "Goodbye, Manish!" The TTS engine uses a natural Indian-English male voice for a professional experience.
The UI automatically shifts between a warm golden daytime theme and a cool deep-indigo night theme based on the current hour, complete with sun and moon illustrations and context-aware greetings.
Using device GPS and the Open-Meteo API, the idle screen displays current temperature and wind speed in real time, refreshed every 2 hours — making the kiosk feel like a smart office display.
While the system is idle on a tablet in landscape mode, the right half of the screen can show a server-configured video or image advertisement fetched from the backend, turning the kiosk into a productive communication display.
Traditional attendance systems require manual entry, are prone to proxy attendance, and generate mountains of paper. The Attendance Marker eliminates all of that.
From device boot to attendance recorded — every step is automatic. No logins, no buttons, no waiting. The employee simply holds their card near the reader.
On boot, the app initialises the Hive local database, enables the screen wakelock (screen never turns off), hides the Android status bar and navigation bar for a true kiosk experience, and locks the display orientation — landscape for tablets, portrait for phones.
The device shows a beautiful ambient idle screen with a live clock (updated every second), current date & day of the week, a day/night greeting with sun or moon illustration, local weather conditions (temperature + wind speed), a daily motivational quote, and — if configured — a scrolling marquee message from the backend. Wi-Fi and sync status indicators are always visible in the corner.
The employee holds their RFID card near the USB-connected NFC reader. The
UsbService continuously monitors the serial stream, parses the
$02,<UID>## packet, extracts the raw UID, adds the
'M' prefix to create a unique RFID identifier, and hands it off
to the AttendanceController. A scan cooldown of 10 seconds per card
prevents double-registrations.
The app checks the local Hive employees box. If the RFID is already
registered, the standard attendance flow begins. If it is an entirely new card,
the app sends it to the backend via WebSocket as a "newTag" event,
saves a placeholder employee locally, and shows an enrollment prompt on screen
so an administrator can assign the card to a person.
When online, the app simultaneously: (A) sends a JSON payload to the backend via
TCP WebSocket containing rfid_serial_number, device_id,
timestamp, and Result; (B) fetches the employee's full
profile from the REST API at /api/attendance/get_attendance_by_rfid;
(C) updates or creates the employee record in the local Hive cache; (D) records a
timestamped attendance event locally; and (E) triggers the result overlay.
When offline, the scan is saved to the offline_scans Hive box with
the device ID, RFID, and Unix timestamp. The employee's details are retrieved from
the local cache to show the scan result screen. When internet connectivity is
restored, all queued offline scans are automatically bulk-uploaded via
POST /api/attendance and then cleared from local storage.
A polished result card replaces the idle screen, showing: the employee's profile photo (with placeholder fallback), full name, the exact check-in and check-out times for the current day, the current timestamp, and a colour-coded greeting — green "Welcome!" for check-in, amber "Goodbye!" for check-out. Simultaneously, the Text-to-Speech engine speaks the greeting aloud. The result screen auto-dismisses after 5 seconds and returns to idle.
The system uses an event counter per employee per day. An odd event count (1st, 3rd, 5th scan…) is recorded as a Check-In; an even count (2nd, 4th…) is recorded as a Check-Out. This allows unlimited in-out cycles throughout the day without any manual configuration. At 23:59:59 every night, the system automatically inserts a checkout record for any employee still checked in — ensuring perfect daily records with no stranded check-ins.
After 5 minutes without any card scan, the app enters Dim Mode — it dramatically reduces screen brightness to 5% and switches to a minimal all-black ambient display showing only the clock and greeting. The moment a card is scanned, brightness is immediately restored to 100% and the full idle screen reappears.
The application has a single-route design. All states are managed reactively through GetX observables, switching seamlessly between the following screens.
Shown between 19:00–06:00. Deep indigo gradient, moon illustration, live clock, quote of the day, and live weather.
Shown between 06:00–19:00. Warm golden palette, sun illustration, live weather data, and daily quote.
Displays profile photo, name, first check-in time, last check-out, and a colour-coded "Welcome!" or "Goodbye!" greeting. Auto-dismisses in 5 seconds.
On tablets when an advertisement is configured, the screen splits: left half shows the idle clock, right half streams a server-side video or image.
When an unknown RFID card is scanned, this full-screen overlay appears, notifying the system and broadcasting the new card to the backend for assignment.
After 5 minutes of inactivity, screen brightness drops to 5% and this minimal all-black view is shown. Any card scan instantly restores full brightness.
The attendance engine is smart, stateless per scan, and fully automatic. No buttons, no modes — the system determines everything from context.
| Scan Number (Today) | Event Type | Display | TTS Message |
|---|---|---|---|
| 1st scan of the day | Check-In | Green — "Welcome, [Name]!" | "Welcome, [First Name]!" |
| 2nd scan of the day | Check-Out | Amber — "Goodbye, [Name]!" | "Goodbye, [First Name]!" |
| 3rd scan (re-entry) | Check-In | Green — "Welcome, [Name]!" | "Welcome, [First Name]!" |
| Any odd scan | Check-In | Green greeting | Welcome message |
| Any even scan | Check-Out | Amber farewell | Goodbye message |
| 23:59:59 (midnight) | Auto Check-Out | Automatic — no card needed | Silent |
Every scan that happens on the device ripples through two communication channels simultaneously — a WebSocket for real-time event streaming and a REST API for employee data retrieval.
| Communication Channel | Protocol | Purpose | Direction |
|---|---|---|---|
| Socket Service | TCP Socket | Real-time scan event streaming with RFID, device ID, timestamp, result type | Device → Server |
| Server Commands | TCP Socket | Receive mode-change commands (cmdMode) and enrollment confirmations (cmdEnroll) from server |
Server → Device |
| Employee Profile API | REST GET | GET /api/attendance/get_attendance_by_rfid/{rfid}?device_id={id} — fetches employee name, photo, ID |
Device → Server |
| Offline Bulk Sync | REST POST | POST /api/attendance — uploads all queued offline scans in one batch |
Device → Server |
| Marquee Text | REST GET | GET /api/get-text — fetches scrolling announcement text, refreshed hourly |
Device → Server |
| Advertisement Media | REST GET | GET /api/media/{device_id} — fetches video/image URL for the split-screen ad panel |
Device → Server |
| Weather Data | REST GET | Open-Meteo API — fetches temperature and wind speed using device GPS coordinates | Device → External |
| Daily Quote | REST GET | Motivational Spark API — fetches one quote per day, cached in SharedPreferences | Device → External |
SocketService detects
disconnections and automatically retries the TCP connection after 5 seconds — indefinitely —
ensuring no scan events are missed even if the server momentarily goes offline.
The device maintains three Hive boxes that power offline operation, attendance history, and employee caching.
employees BoxStores a local cache of every known employee whose RFID card has been scanned. Updated on every online scan.
attendance_events BoxEvery scan event is persisted locally with NFC ID, timestamp, event count, and date. Powers the check-in/check-out history display.
offline_scans BoxScans captured when offline are queued here. Automatically flushed to the backend the moment connectivity returns.
The codebase follows a clean, layered architecture separating concerns across domain, data, and presentation layers — managed with GetX.
Every dependency was selected with purpose — for performance, reliability, and specific capability on Android kiosk hardware.
| Package | Category | Purpose |
|---|---|---|
flutter + get ^4.6.6 |
Framework | UI framework + reactive state management, dependency injection, routing |
hive + hive_flutter |
Database | Fast, lightweight NoSQL local database for employees, events, offline queue |
usb_serial ^0.5.1 |
Hardware | USB-to-serial communication with the external RFID reader hardware |
http ^1.6.0 |
Network | REST API calls to the Inurum backend, weather, and quote services |
connectivity_plus ^7.1.1 |
Network | Real-time network connectivity monitoring for online/offline switching |
flutter_tts ^4.2.3 |
Audio | Text-to-speech voice greeting in Indian English on every attendance event |
geolocator ^12.0.0 |
Sensor | GPS coordinates for real-time local weather fetching via Open-Meteo |
screen_brightness ^1.0.1 |
Hardware | Programmatic screen brightness control for dim mode (5%) and full mode (100%) |
wakelock_plus ^1.2.8 |
Hardware | Prevents the device from sleeping — critical for an always-on kiosk |
video_player ^2.10.0 |
Media | Stream and play server-side advertisement videos in the split-screen panel |
shared_preferences ^2.5.3 |
Storage | Cache daily quotes with date key to avoid redundant API calls |
device_info_plus 11.1.0 |
Device | Reads Android ID as a stable, unique device identifier for multi-device deployments |
marquee ^2.3.0 |
UI | Scrolling marquee widget for server-configured announcement text |
intl ^0.19.0 |
Utility | Date and time formatting throughout the entire UI (HH:mm:ss, dd MMM yyyy, EEEE) |
An Android tablet is mounted at the office entrance. A USB RFID reader is connected to it. Every employee is given a personal RFID card. When they arrive each morning, they tap their card — the system greets them by name, shows their check-in time, and simultaneously uploads the record to the Inurum cloud backend. At the end of the day, the same card tap records a checkout. The HR team can view all records in real time from the backend dashboard. The device operates 24 hours a day without any manual intervention.
From card tap to result on screen takes under a second. Employees don't stop walking — the system keeps up with them.
Even if the office Wi-Fi goes down, attendance continues. Every record is safely queued and synced when connectivity returns.
The screen never sleeps, dims intelligently at night, auto-checkouts at midnight, and reconnects to sockets automatically.
A complete, natural narration script — ready to be read on camera or as a voice-over. Written in a professional, demonstration style.
Hello everyone, and welcome! Today I'm going to walk you through our Attendance Marker — a smart, kiosk-based attendance system developed by Inurum Technologies.
This is not just another punch-in app. This is a fully automated, always-on Flutter application running on an Android device, designed to handle hundreds of employee attendance records every single day — without anyone pressing a single button.
Live Demo — Watch it in Action
Watch on YouTube →The Attendance Marker is a kiosk application installed on an Android tablet or phone that is permanently mounted at a building entrance, factory gate, or office lobby. It connects to an external RFID or NFC card reader via a USB cable.
Every employee is given a personal RFID card. When they arrive for work, they simply hold their card near the reader — and that's it. The system does everything else automatically.
No login screens. No passwords. No one has to touch the screen. The device runs 24 hours a day, 7 days a week, and it manages itself.
When no one is scanning, the device shows a beautiful ambient screen. Let me describe what you see.
The background changes based on the time of day. During working hours, you'll see a warm golden palette with a bright sun illustration — and a greeting that says "Good Morning!" or "Good Afternoon!" In the evening, that shifts to a cool deep indigo theme with a moon graphic and "Good Night." It feels alive.
The clock in the centre updates every single second. Below it, you see the date and full day name. And if the device has location access, it also shows the current temperature and wind speed — pulled live from the Open-Meteo weather API.
At the top you can always see two status indicators — the Wi-Fi connection icon and the data sync icon. Green means everything is live and in sync. If the internet drops, you'll see that change in real time.
There's also a scrolling marquee text that runs across the screen — this is configured from the server and can contain any announcement the company wants to push to the display. It refreshes every hour.
And right below the clock, you'll find the Quote of the Day — a daily motivational quote fetched from an external API, cached so it only changes at midnight. It gives the display personality and purpose beyond just a clock.
Now let's walk through what happens when an employee taps their RFID card.
The moment the card comes near the reader, the USB NFC reader sends a serial data packet to the Android device. Our app continuously monitors the USB serial stream, parses the raw data packet, and extracts the card's unique ID. This happens in milliseconds.
First, the app checks its local database to see if this card has been seen before. If yes, the attendance flow kicks in. If this is a brand new card — maybe a new employee who just joined — the system broadcasts it to the backend and shows an enrollment screen, prompting an administrator to assign the card to the right person.
For a known card and an active internet connection, two things happen simultaneously: the app streams a real-time event over a TCP socket to the Inurum server — including the RFID number, the device ID, and an exact Unix timestamp — and it also calls the REST API to retrieve the employee's full profile.
Once the profile comes back — which takes under a second — the device shows the attendance result screen. We see the employee's profile photo, their full name, and their check-in and check-out times for the day. The display transitions from the clock to a beautiful employee card.
Here's one of the clever parts. The system determines whether each scan is a check-in or a check-out automatically — using a simple but powerful rule.
The first scan of the day is always a check-in. The second is a check-out. The third is a check-in again. And so on. This means employees can tap in and out multiple times throughout the day — for lunch breaks or external trips — and the system handles all of it correctly without any configuration.
Check-ins show a green "Welcome!" greeting — and the system speaks the words out loud: "Welcome, Manish!" Using a clear, natural Indian English voice from the Text-to-Speech engine. Check-outs show an amber "Goodbye!" with a matching voice announcement.
At exactly 23:59:59 every night, the system runs an automatic checkout for every employee who is still marked as checked in. No one is left with a hanging open attendance record — ever.
After the result card is shown, it automatically disappears after 5 seconds, returning the screen to the ambient idle view — ready for the next person.
What happens if the internet goes down? This is a real concern for any attendance system.
Our app handles it gracefully. When the device detects it has gone offline, it continues to work perfectly. Every scan is saved to the device's local storage in our offline queue — with the device ID, the RFID, and the exact timestamp.
The employee still sees their profile and the result card — because we have the information cached locally from previous online scans.
The moment the internet connection is restored — automatically, without anyone doing anything — the app detects the reconnection, uploads all queued scans to the backend in a single bulk operation, and clears the queue. The sync icon at the top of the screen gives you real-time visual feedback of this process.
A few more intelligent features that make this truly kiosk-grade.
The app uses Android's Immersive Sticky mode — meaning the status bar and navigation bar are completely hidden. Employees cannot accidentally exit the app. The screen orientation is permanently locked — landscape for tablets, portrait for phones.
The screen wakelock is enabled from startup — so the device screen never turns off automatically. The kiosk is always ready.
After 5 minutes without any scan, the app dims the screen to 5% brightness and shows a minimal black ambient display — saving energy overnight. The moment anyone taps a card, the screen instantly returns to full brightness.
On tablets in landscape mode, if the backend has configured an advertisement, the idle screen splits in half — the left side shows the clock and ambient info, the right side streams a promotional video or image. This turns the kiosk into a dual-purpose communication display.
Each device has a unique Android hardware ID. This ID is included in every scan event, so the backend always knows exactly which device — which door, which floor, which building — a scan came from. Multi-device deployments are fully supported out of the box.
What you've just seen is a complete, production-ready attendance kiosk solution built entirely in Flutter and powered by the Inurum backend platform.
It handles the full attendance lifecycle — from card enrollment to daily check-ins and check-outs — reliably online or offline, with voice feedback, ambient intelligence, and zero manual maintenance required.
If your organisation is looking to modernise how attendance is tracked — with a system that is fast, accurate, beautiful to look at, and built to run 24 hours a day without failure — the Attendance Marker by Inurum Technologies is exactly that.
Thank you for watching. Tap your card, and let the system handle the rest.