Native Android application for monitoring and exploring earthquakes in Italy through list browsing, live search, map visualization, and local persistence.
|
Mik1810 |
|
LucaFraMacera |
Earthquake Mobile is a native Android application designed to help users explore earthquake activity in Italy through a clean and practical mobile interface.
The application combines:
- remote earthquake retrieval
- local persistence with Room
- live search by location
- map-based visualization with Google Maps
- a dedicated detail screen for focused event inspection
This project is a compact but complete example of a real Android application, bringing together networking, persistence, navigation, and UI interaction in a single product.
The app provides a list-based view of the downloaded earthquake dataset.
This allows users to:
- scan recent events quickly
- compare multiple earthquakes at a glance
- open a specific earthquake for detailed inspection
The main list supports manual refresh through a swipe-down gesture.
This gives the user direct control over updating the data and makes the application feel more dynamic.
The search feature filters earthquakes in real time while the user types.
The filtering logic is based on textual location-related fields such as:
- place
- country
- state
This makes the dataset much easier to explore when many events are available.
The map screen displays earthquake positions through Google Maps.
This helps users:
- understand where events occurred
- visually compare geographic distribution
- move from a map marker to the earthquake detail view
Each earthquake can be opened in a dedicated detail page.
This screen is useful for focusing on a single event and understanding it more clearly through:
- event metadata
- map-based context
- visual impact representation
Earthquake data is cached locally with Room.
This means the app can reuse stored data and follow a more realistic mobile architecture instead of relying only on fresh requests.
|
The Homepage is the main entry point of the application and provides an overview of the available earthquake data. From this screen, users can browse the list of recorded earthquakes, get a quick overview of recent events, access the main navigation flow of the application, and refresh the dataset manually. This screen acts as the central hub of the app and makes the earthquake dataset immediately accessible. |
|
The Search screen allows users to filter earthquakes in real time by typing a location-related keyword. This feature is useful for narrowing the dataset quickly, finding earthquakes related to a specific place, and improving usability when many events are available. The live filtering behavior makes earthquake exploration faster and more interactive than a static list. |
|
The Details screen is dedicated to a single earthquake event. Here the user can inspect the main information in a clearer and more focused way, such as title and place, magnitude, depth, coordinates, and other event-specific information. This screen shifts the experience from general exploration to focused event analysis. |
|
The Map Detail screen provides a geographic view centered on a selected earthquake. Its purpose is to give more spatial context to the event and improve interpretation through location-based visualization. This makes the selected earthquake easier to understand not only as raw data, but also as a real geographic occurrence. |
|
The Map screen displays earthquake positions on Google Maps, giving the user a broader spatial overview of the dataset. This screen is useful for understanding where earthquakes are distributed, visually comparing multiple events, exploring the data geographically, and opening a more focused view for a selected event. It is one of the most visually powerful parts of the application and adds strong value to the overall experience. |
- Language: Java
- Platform: Android
- Build System: Gradle Kotlin DSL
- Persistence: Room
- Navigation: Android Navigation Component
- Networking: Cronet
- Maps: Google Maps SDK
- UI Binding: ViewBinding + DataBinding
The project is organized as a native Android application with a clear separation between screens, state handling, networking, and persistence.
The UI layer includes the main screens and user-facing components:
MainActivityListFragmentSearchFragmentMapFragmentDetailActivityEarthquakeAdapter
The application state is coordinated through:
MainViewModel
The ViewModel is responsible for exposing earthquake data to the UI, refreshing data, and filtering the dataset by location.
The data flow is handled through:
RepositoryRequest
This is where remote data retrieval is performed and prepared for the rest of the app.
Local data is cached through Room components:
DBEarthquakeDAODateConverter
The core domain entity is:
Earthquake
A simplified version of the application flow is the following:
- The app starts and loads the main interface
- Cached earthquakes are checked locally
- If needed, remote earthquake data is downloaded
- The response is parsed into earthquake objects
- The local database is updated
- The UI observes the dataset and renders it
- The user can browse, search, visualize, and inspect earthquakes
This makes the project more than a simple UI prototype: it behaves like a real mobile application with a complete data lifecycle.
app/
└── src/main/
├── java/com/example/earthquakemobile/
│ ├── database/
│ │ ├── DB.java
│ │ ├── DateConverter.java
│ │ └── EarthquakeDAO.java
│ ├── model/
│ │ └── Earthquake.java
│ ├── service/
│ │ ├── LocationHelper.java
│ │ ├── MainViewModel.java
│ │ ├── Repository.java
│ │ └── Request.java
│ ├── DetailActivity.java
│ ├── EarthquakeAdapter.java
│ ├── EarthquakeMobile.java
│ ├── ListFragment.java
│ ├── MainActivity.java
│ ├── MapFragment.java
│ └── SearchFragment.java
├── res/
└── AndroidManifest.xml