A concept Android application exploring how citizens, volunteers, and emergency responders could continue coordinating when conventional communication infrastructure becomes unreliable.
Overview • Features • Tech Stack • Getting Started • Roadmap
When networks fail, coordination should not.
Junex explores how critical emergency information could be stored locally, relayed through nearby devices, and eventually delivered to responders or network gateways.
A one-minute walkthrough of the current Junex prototype is available here:
Watch the Junex demo on Google Drive
The video demonstrates the current prototype workflow and interaction model.
During natural disasters and large-scale emergencies, communication infrastructure can become unreliable or unavailable.
Junex explores an alternative model for emergency coordination built around three groups:
| Citizen | Volunteer | Responder |
|---|---|---|
| 🚨 | 🤝 | 🛡️ |
| Request help | Assist nearby people | Manage incidents |
The current version focuses on the product experience, emergency workflows, and interaction model behind a potential community-supported communication system.
🟠 Project Status: Prototype / Concept Implementation
Junex demonstrates how emergency information could move through a disaster coordination workflow.
┌──────────────┐
│ CITIZEN │
│ Creates SOS │
└──────┬───────┘
│
▼
┌──────────────┐
│ LOCAL DEVICE │
│ Stores Data │
└──────┬───────┘
│
▼
┌──────────────┐
│ VOLUNTEER │
│ Relay Node │
└──────┬───────┘
│
▼
┌──────────────┐
│ GATEWAY │
│ Sync Point │
└──────┬───────┘
│
▼
┌──────────────┐
│ RESPONDER │
│ Incident │
└──────────────┘
The current implementation simulates this workflow without requiring physical mesh networking hardware.
Citizens can create emergency requests through a guided SOS workflow.
The request can include:
- Emergency category
- Number of affected people
- Additional emergency information
- Request status
- Delivery progress
🟡 Saved Locally
↓
🔵 Accepted by Relay Node
↓
🟣 Received by Gateway
↓
🟢 Acknowledged by Responders
This allows users to understand where an emergency request is within the simulated delivery workflow.
Users can report potentially dangerous situations in their area.
Hazard reports can include:
- Hazard category
- Approximate location
- Description
- Number of people affected
- Photo availability
Community reports can exist alongside official emergency information to provide additional awareness during developing situations.
Junex provides a dedicated system for viewing emergency information.
Alerts can include:
- Verified emergency information
- Alert severity
- Safety instructions
- Affected areas
- Alert expiration information
- Community hazard reports
Responder workflows also demonstrate the creation of verified emergency alerts.
Volunteers act as an important bridge between citizens and emergency coordination systems.
Volunteer functionality includes:
- Viewing nearby help requests
- Reviewing emergency request details
- Offering assistance
- Relaying emergency messages
- Monitoring relay activity
- Managing relay mode
- Emergency battery mode controls
Responders have access to an incident management workflow.
Available functionality includes:
- Viewing active incidents
- Opening incident details
- Acknowledging emergency requests
- Assigning response teams
- Updating incident status
- Marking incidents as resolved
- Creating verified emergency alerts
Junex currently includes an interactive simulation of emergency message delivery.
The simulation demonstrates:
- Relay hops between nearby devices
- Gateway delivery
- Message delivery status changes
- Incident synchronization across different user roles
Citizen Device
│
│ Emergency Message
▼
Volunteer Node
│
│ Relay
▼
Gateway
│
│ Incident Delivery
▼
Responder
🔵 The current system is a simulation designed to demonstrate the workflow and interaction model.
Junex includes an offline safety section containing emergency guidance.
The goal is to keep essential information accessible even when conventional connectivity is unavailable.
Potential guidance includes:
- Disaster preparation
- Emergency evacuation
- Basic safety procedures
- Communication guidance
- Situation-specific instructions
|
Request help and receive emergency information. Capabilities
|
Assist people and support emergency communication. Capabilities
|
Coordinate and manage active incidents. Capabilities
|
| Core | Architecture | Additional |
|---|---|---|
| Kotlin | MVVM-inspired | Room |
| Android SDK | ViewModel | Firebase |
| Jetpack Compose | StateFlow | Retrofit |
| Material 3 | Coroutines | OkHttp |
| Moshi | ||
| KSP |
Some integrations are currently reserved for future development and are not part of the active prototype workflow.
app/
├── src/
│ ├── main/
│ │ ├── java/
│ │ │ └── com/example/
│ │ │ ├── data/
│ │ │ │ └── model/
│ │ │ │
│ │ │ ├── ui/
│ │ │ │ ├── components/
│ │ │ │ ├── screens/
│ │ │ │ └── theme/
│ │ │ │
│ │ │ ├── viewmodel/
│ │ │ └── MainActivity.kt
│ │ │
│ │ └── res/
│ │
│ └── test/
│
├── build.gradle.kts
├── proguard-rules.pro
└── README.md
Make sure you have:
- Android Studio
- Android SDK
- A compatible Android emulator or physical Android device
Clone the repository:
git clone https://github.com/Jofil-Joby/Junex.gitMove into the project:
cd JunexThen:
- Open the project in Android Studio
- Allow Gradle to synchronize
- Select an emulator or physical device
- Run the application
Junex currently demonstrates the product and interaction model of a disaster communication system.
The following functionality is currently simulated:
- Device-to-device emergency message relaying
- Gateway delivery
- Network status changes
- Cross-role incident synchronization
🔴 Important: Junex does not currently implement a real peer-to-peer mesh networking protocol between physical devices.
The simulation exists to demonstrate how information could move through such a system and how different user roles could interact with shared emergency incidents.
Potential directions for Junex include:
- Bluetooth-based device communication
- Wi-Fi Direct communication
- Device discovery
- Offline-first persistent storage
- Persistent message queues
- Encrypted emergency message transport
- Real GPS integration
- Photo capture and attachments
- Persistent incident history
- Backend synchronization
- Verified responder authentication
- Push notifications
- Multi-language emergency guidance
- Integration with disaster management organizations
- Role-based citizen, volunteer, and responder workflows
- SOS request simulation and delivery tracking
- Hazard reporting
- Emergency alerts
- Volunteer assistance workflow
- Responder incident management
- Simulated message relaying
- Offline-first persistent storage
- Bounded Bluetooth-based device communication
- Wi-Fi Direct fallback
- Device discovery
- GPS integration
- Encrypted message transport
- Persistent incident history
- Verified responder authentication
- Offline message queue
How can communities continue to communicate and coordinate when traditional communication infrastructure becomes unreliable?
Junex explores a role-based emergency ecosystem where:
🚨 Citizens
Request help and report hazards
↓
🤝 Volunteers
Assist communities and relay information
↓
🛡️ Responders
Coordinate and manage incidents
While the current version is a prototype, the broader goal is to explore more resilient and community-supported approaches to emergency communication.
⚠️ Junex is currently a prototype and must not be relied upon as a real emergency communication system.
The application does not replace:
- Official emergency services
- Disaster management authorities
- Established emergency communication infrastructure
- Professional emergency response systems
The networking and emergency workflows currently demonstrated are conceptual and simulated.
Resilient communication. Community coordination. Emergency response.
Built as an Android prototype exploring emergency coordination and communication when conventional networks become unreliable.
This project is licensed under the MIT License. See the LICENSE file for details.