Risk Management/Find Health Care

This learning resource supports learners in creating an web application for mobile phones to find health care facilities (HCF) according the User's current geolocation. The learning environment will approach this topic from different angles:
 * Application for disaster management
 * Application in developing countries (requirements and constraints analysis)
 * Open Data for health care facilities (e.g. https://healthsites.io/)
 * Types of App Development (e.g. Offline Use vs. Online Use)

Application Requirements
In this learning resource we aim to build a web application that:
 * 1) finds the next Health Care Facility based on the User's geolocation
 * 2) navigates the User to found HCF
 * 3) after being opened in a mobile browser once, uses the device's local browser storage to provide main services even without cellular infrastructure

Possible extensions/features
Once the application requirements are implemented, following extensions should be considered:
 * use better metric to find best HCF match by taking into account more information, e.g.
 * general HCF data (specialization, equipment, insurance/ payment requirements)
 * real-time HCF data (opening hours, available capacity, level of destruction in case of close disaster)
 * traffic information
 * facilitate navigation through use of augmented reality methods (e.g. display direction arrows in real environment, highlight HCF in environment to provide a broad orientation and distance understanding), possible tool would be ARKit
 * enable automatic data exchange between close devices (e.g. over WiFi or Bluetooth, see Serval Mesh and smart phone ad hoc networks), thus providing real-time data even when the User's cellular infrastructure fails

Development in Django

 * In this learning resource you will see how a Django application can be developed for finding health care facilities.

Implementation Roadmap

 * 1) Implement basic web app with Django framework
 * 2) Read User's geolocation via Javascript frontend and save it in Django backend with GeoDjango
 * 3) Display map in frontend (maybe connect OpenLayers with GeoDjango through LinkParam)
 * 4) Highlight and track own geolocation in map
 * 5) Import and highlight all HCF within a certain distance from datasource like healthsites.io
 * 6) Display further information about selected HCF on click
 * 7) Build filter to find best HCF match (default is distance, further search criteria like mentioned above could be added later)
 * 8) Integrate navigation service to guide User to the chosen HCF (possible plugin is leaflet)
 * 9) Enable offline web app usage through caching
 * 10) (feature) Add methods to facilitate navigation
 * 11) * Read mobile phone sensors and use ARKit to display navigation arrows in a most understandable way
 * 12) * Display compass rose to improve orientation understanding
 * 13) * Add voice output option
 * 14) (feature) Enable incorporation of real-time data, possibly provided by Users (e.g. traffic information, available capacities at visited HCF)
 * 15) (feature) Enable offline-communication between devices to provide best information even without working cellular infrastucture (maybe applied the Several Project's methods)

Web App vs Native App
Advantages of using a web app instead of a native app are: On the other hand, native apps are superior in some aspects: Although implementing native apps might be more comfortable in total, we decided for the web app approach, as far reach and easy access are the most important factors for this kind of project.
 * web apps are platform-independent, so there is no need to develop a special app for each iOS, Android or WindowsPhone
 * web apps can be easily accessed via a mobile web browser and do not be downloaded via an app store
 * This way the mental barrier to use the web app is lower, thus increasing it's reach and availability
 * There are no developer licenses needed to publish the app
 * native apps usually perform better, with higher speed and lower power usage
 * native apps easily provide access to device sensors such as the gyroscope and accelerometer, thus facilitating AR development
 * native apps have their own data storage