More project photos (2)
The problem
Hikers lose mobile coverage exactly where a trail record matters most — in valleys, forest sections and remote ridge lines — so a recorder that depends on a live connection or a cloud account stops being useful on the trail itself. At the same time, most ready-made trekking apps hide how recording actually works, which makes them poor material for a student who must explain GPS sampling, local storage and file formats in a viva. This project builds the recorder as a native Android app in Kotlin: location updates are sampled on the device, the track is drawn on map tiles downloaded in advance, every track point and waypoint is stored locally in a Room database, and the finished trail exports as a standard GPX 1.1 file that opens in common mapping tools. An elevation profile plotted from the recorded altitudes completes the trail summary, so the full pipeline — sensing, storage, visualisation and interchange format — is implemented and explainable end to end.
Latitude, longitude, altitude, accuracy and timestamp sampled on the device.
Follow the working sequence
How it works
- Before the hike, the user pans over the planned area while online and downloads the map tiles for offline use; the app caches them on the device so the map keeps working without a connection.
- On starting a recording, the app requests location permission and begins receiving GPS location updates at the configured interval (by default every 5 seconds or 10 metres, whichever comes later).
- Each accepted location fix — latitude, longitude, altitude, accuracy and timestamp — is inserted as a track point row in the Room database against the active trail, and the map polyline is redrawn through the new point.
- Live statistics are computed from the stored points: cumulative distance from successive coordinates, elevation gain from positive altitude changes, moving time excluding auto-paused periods, and average pace.
- When the user adds a waypoint, its name, coordinates, altitude and timestamp are saved in the waypoints table and rendered as a numbered pin on the track.
- On finishing, the trail is marked complete in the database and appears in the saved-trails library with its summary statistics.
- For the elevation profile, the app reads the trail's track points in order, applies a short moving-average smoothing to the noisy GPS altitude values, and plots altitude against cumulative distance on a chart.
- On export, the trail is serialised to GPX 1.1 XML — metadata, waypoints as wpt elements and the track as trk/trkseg/trkpt elements with elevation and time — written to a file the user can open or share.
Tech stack:
- Kotlin
- Android Jetpack · Room · ViewModel · Lifecycle
- Fused Location Provider (Google Play services location)
- osmdroid (OpenStreetMap map view and offline tiles)
- GPX 1.1 XML format
- Material 3 UI components
- Gradle · Android Studio
| Parameter | Value |
|---|---|
| Platform | Android 8.0 (API 26) and above (design target) |
| Location sampling | Every 5 seconds or 10 metres by default (configurable) |
| GPS horizontal accuracy | Approximately 3–10 metres outdoors (device- and sky-view-dependent) |
| Altitude source | GPS altitude; barometric altitude on devices with a pressure sensor (device-dependent) |
| Local database | Room (SQLite) — trails, track points and waypoints tables |
| Export format | GPX 1.1 — 1 track per file, waypoints included |
| Offline tiles | Approximately 150–300 MB per district-sized area at zoom levels 12–16 (expected) |
| Battery use | Approximately 5–9% per hour of recording (expected, device-dependent) |
| Internet required | Not required for recording, library or export; needed only to download map tiles in advance |
Project features
- [Offline GPS track recording] Records the route using the device location provider with a configurable sampling interval (distance- or time-based), continuing to log track points with no mobile data or Wi-Fi connection at all.
- [Offline map with live track] Draws the recorded polyline, waypoints and current position on osmdroid map tiles that are downloaded over Wi-Fi before the hike and cached on the device for offline display.
- [Waypoint logging] Lets the hiker drop named waypoints during recording — trailhead, water source, rest point, junction — each stored with its coordinates, altitude and timestamp and shown as numbered pins on the map.
- [Elevation profile] Plots altitude against distance for any saved trail from the altitude stored with each track point, with light smoothing and labelled start, highest and end points.
- [GPX 1.1 export and sharing] Exports any trail as a standard GPX file with one track, track segments, track points and waypoints, ready to open in tools such as Google Earth or Garmin BaseCamp or to share from the app.
- [Local trail library in Room] Stores trails, track points and waypoints in a Room (SQLite) database on the device, with a searchable saved-trails list showing distance, elevation gain and duration per trail.
- [Recording controls and stats] Live distance, moving time, elevation gain, current altitude and average pace while recording, with pause/resume, auto-pause at very low speed and finish-and-save.
What is included
- Complete Android source code (Kotlin) with Room database and GPX exporter
- Installable demo build (APK) of the recorder
- Setup instructions covering Android Studio, permissions and offline tile download
- Project report PDF (background, Android location APIs, database design, GPX format, methodology, results)
- PPT presentation for final review
- Viva Q&A preparation document (location sampling, offline storage, GPX structure, elevation data limits)
Limitations & prerequisites
- GPS accuracy is limited to approximately 3–10 metres in open sky and can drift to 20–30 metres (approximate) under dense tree cover, in deep valleys or near rock faces.
- Continuous GPS recording draws approximately 5–9% battery per hour (expected, device-dependent), so very long treks may need a power bank or a longer sampling interval.
- GPS altitude is noticeably noisier than horizontal position; the elevation profile is smoothed and should be read as approximate, not survey-grade.
- The app records and reviews trails — it provides no offline turn-by-turn navigation, route guidance or emergency/SOS feature.
- Offline maps only cover areas whose tiles were downloaded in advance; an area never cached shows a blank grid while recording continues normally.
- Altitude from a barometric sensor is available only on devices that have one, and it drifts with weather-related pressure changes unless calibrated.
Frequently Asked Questions
Does the app really work without internet?
Yes, for its core job. Recording, the trail library, statistics, the elevation profile and GPX export all run entirely on the device using GPS and the Room database. Internet is needed only once, beforehand, to download the map tiles for the area being hiked; the track itself is recorded even where no tiles were cached.
What exactly is in the exported GPX file?
A standard GPX 1.1 file containing the trail as one track with track segments, every recorded track point with latitude, longitude, elevation and timestamp, plus the named waypoints as separate wpt entries. Because GPX is an open interchange format, the file opens in Google Earth, Garmin BaseCamp, Komoot and similar tools without any conversion step.
How accurate are the distance and elevation figures?
Distance is summed between successive GPS fixes and is typically within a few percent on open trails, but it inherits GPS error — approximately 3–10 metres per fix in open sky, worse under tree cover. Elevation comes from GPS altitude, which is noisier still, so gain figures and the profile are labelled approximate in the app.
Can the recording interval or map source be changed?
Yes. The sampling rule — by default every 5 seconds or 10 metres — is a configurable setting, and longer intervals trade track detail for battery life. The osmdroid tile source can also be changed in code, and additional cached areas can be downloaded whenever the device is back online.
Is this project suitable for a final-year project?
Yes — for Computer Engineering, IT and related programs. It demonstrates Android location APIs and permission handling, foreground recording behaviour, Room database design with three related tables, offline map tile management, chart plotting from stored data and generation of a standard interchange format (GPX), all of which map cleanly to viva questions.
What will I receive with the project?
The complete Kotlin source code, an installable demo APK, setup instructions, the project report, a PPT for the final review and a viva Q&A document. The build is local-first, so no server, hosting or paid API key is needed to run or demonstrate it.
Components & software requirements
- Kotlin
- Android Jetpack · Room · ViewModel · Lifecycle
- Fused Location Provider (Google Play services location)
- osmdroid (OpenStreetMap map view and offline tiles)
- GPX 1.1 XML format
- Material 3 UI components
- Gradle · Android Studio
Delivery information
Built-to-order project. Delivery timeline is shared after order confirmation based on current queue.
Support terms
Complete documentation, setup guide, and viva preparation included. Support for setup and explanation provided.
Download free synopsis (PDF)
Enter your name and email — the synopsis PDF downloads immediately. We may send occasional project updates; no spam, unsubscribe anytime.