FRIENDLY MAP ANDROID APPLICATION FOR DISABLED

PEOPLE

SYNOPSIS

In today's world, individuals with disabilities often encounter formidable

obstacles when attempting to navigate public spaces and access essential
facilities. Recognizing this pressing need for improved accessibility, the
"Friendly Map Android Application for Disabled People" project emerges
as a beacon of empowerment and inclusivity. By harnessing the power of
mobile technology, this initiative endeavors to bridge the gap between
individuals with disabilities and their environment, offering tailored navigation
assistance and invaluable accessibility information.

At its core, the project's mission is clear: to empower disabled individuals

with the means to navigate their surroundings confidently and independently.
By leveraging the ubiquitous presence of smartphones, the Friendly Map
application provides a user-friendly interface designed to cater to the diverse
needs of individuals with disabilities. Through intuitive design and robust
functionality, users can seamlessly access crucial information about nearby
facilities, such as colleges, bus stops, and public buildings, including detailed
accessibility features, contact information, and operating hours.

In conclusion, the "Friendly Map Android Application for Disabled

People" represents a transformative step towards creating a more accessible and
inclusive world for individuals with disabilities. Through its innovative features,
user-centric design, and unwavering commitment to empowerment, the project
seeks to redefine the way disabled individuals navigate their surroundings,
empowering them to live their lives to the fullest.

0
 1. INTRODUCTION

The disabled have difficulties in accessing various facilities. They cannot

easily maneuver due to the discriminatory manner buildings were built. Visual
impaired people would have difficulties in finding bus stops as not every bus
stop has guiding tracts and not every bus has the facility to provide a slope for
people on the wheelchair to get on and off the buses. Minibuses and trams do
not have audible announcement system and mostly make use of stairs, which
causes inconvenient for people with impaired vision, hearing or walking
impairment. Some MTR stations do not equip with or only have one lift or
lifting platform for people on the wheelchair. Sometime Impaired people don’t
get the proper location and they might reach somewhere else. This android
system will help disabled people to find their way on their own just by speaking
up in the phone. This android application will ask for the desire place where the
person want to reach and navigate by speech to the person. If the disabled
individual is visually impaired the map can save all details about the particular
college and guide the disabled individual by navigating to reach till college,
classroom floor, library, etc

1
1.1 SYSTEM SPECIFICATION

1.1.1 HARDWARE CONFIGURATION

● Processor : i3
● Hard Disk : 20 GB
● Memory : 4GB RAM

1.1.2 SOFTWARE SPECIFICATION

● Frontend : xml with kotlin

● Backend : Kotlin
● Database : Sql
● Operating System : Windows or any OS
● Platform : Android
● Code Editor : Android studio

1.1.3 SOFTWARE DESCRIPTION

XML:

XML (eXtensible Markup Language) is a markup language that defines

a set of rules for encoding documents in a format that is both human-readable
and machine-readable. It is a widely used standard for storing and transporting
data, particularly in web development and data exchange between different
systems. Here are some key features of XML:

● Markup Language: XML uses tags to define the structure and meaning of
data within a document. Tags are enclosed in angle brackets (< >) and can
be nested to represent hierarchical relationships.

● Human-readable and Machine-readable: XML documents are designed to

be easily understandable by both humans and machines. The hierarchical
structure and use of tags make it intuitive for humans to read, while
parsers and software can easily interpret the structure for processing.

2
● Extensibility: The "eXtensible" in XML refers to its extensibility,
meaning that users can define their own customized tags and document
structures to suit specific needs or applications. This flexibility allows
XML to adapt to various data formats and requirements.

● Platform-independent: XML is platform-independent, meaning it can be

used on any operating system and with any programming language. This
makes it a versatile choice for data exchange in heterogeneous
environments.

● Structured Data Representation: XML provides a structured way to

represent data, allowing complex relationships and metadata to be
encoded within documents. This makes it suitable for a wide range of
applications, including configuration files, data interchange, and
document storage.

● Interoperability: XML promotes interoperability between different

systems and technologies by providing a common format for data
exchange. It is widely supported by programming languages, databases,
and web technologies, enabling seamless integration between diverse
systems.

● Validation: XML documents can be validated against a schema or

Document Type Definition (DTD), which defines the rules and structure
that the document must adhere to. This helps ensure the integrity and
consistency of the data within XML documents.

● Transformation: XML documents can be transformed into other formats

using technologies like XSLT (eXtensible Stylesheet Language
Transformations). This allows for the conversion of XML data into
various presentation formats such as HTML, PDF, or plain text.

● Unicode Support: XML supports Unicode, allowing for the representation

of text in different languages and character sets. This ensures that XML
documents can handle multilingual content and diverse data
requirements.

3
KOTLIN :

Kotlin is a modern programming language that runs on the Java Virtual

Machine (JVM) and can also be compiled to JavaScript or native code. It was
developed by JetBrains and was first released in 2011. Kotlin has gained
significant popularity in recent years, particularly in the Android app
development community, as it offers a more concise, safe, and expressive
alternative to Java. Here are some key features of Kotlin:

● Conciseness: Kotlin is designed to be more concise than Java, allowing

developers to write the same functionality with less code. It achieves this
through features like type inference, default parameter values, and
concise syntax for common tasks.

● Null Safety: Kotlin addresses the infamous NullPointerException (NPE)

problem by making nullability a first-class citizen in its type system.
Nullable types are explicitly declared, and the compiler enforces null
safety, reducing the risk of NPEs at runtime.

● Interoperability: Kotlin is fully interoperable with Java, meaning that

Kotlin code can call Java code and vice versa without any friction. This
makes it easy for developers to gradually migrate existing Java codebases
to Kotlin or to use Kotlin alongside existing Java libraries and
frameworks.

● Extension Functions: Kotlin allows developers to add new functions to

existing classes without modifying their source code through extension
functions. This feature promotes code reusability and enhances the
readability of code by allowing developers to write more fluent APIs.

● Coroutines: Kotlin provides first-class support for coroutines, which are

lightweight concurrent programming constructs. Coroutines enable
asynchronous programming in a more efficient and readable manner
compared to traditional threading approaches. They simplify the handling
of asynchronous tasks such as network requests and background
processing.

4
 ● Functional Programming Support: Kotlin supports functional
programming paradigms, including higher-order functions, lambda
expressions, and immutable data structures. These features enable concise
and expressive code, promote code reuse, and facilitate writing code in a
more declarative style.

● Smart Casts and Type Inference: Kotlin's type system includes smart
casts, which automatically cast types within a certain scope when certain
conditions are met, reducing the need for explicit type checks and casts.
Additionally, Kotlin's type inference capabilities allow developers to omit
type declarations in many cases, resulting in cleaner and more readable
code.

● Data Classes: Kotlin provides a concise syntax for defining classes whose
primary purpose is to hold data. Data classes automatically generate
boilerplate code for equals(), hashCode(), toString(), and copy() methods,
making them ideal for modeling immutable data.

● Object-oriented and Procedural Programming: While Kotlin supports

functional programming paradigms, it also fully supports object-oriented
and procedural programming styles. This versatility allows developers to
choose the most appropriate programming paradigm for their specific use
case.

ANDROID:

Android is a mobile operating system developed by Google, based on the

Linux kernel and designed primarily for touchscreen mobile devices such as
smartphones and tablets. It has become one of the most popular operating
systems globally, powering millions of devices worldwide. Here are some key
aspects of Android:

● Open Source: Android is an open-source platform, meaning its source

code is freely available to developers and device manufacturers. This
openness fosters innovation and allows for customization and
modification of the operating system to suit different needs.

5
● Application Ecosystem: Android has a vast ecosystem of applications
available through the Google Play Store and other third-party app stores.
These applications cover a wide range of categories, including
productivity, entertainment, communication, gaming, and more, providing
users with a rich and diverse selection of software.

● User Interface: Android features a user-friendly and customizable

interface that allows users to personalize their devices with widgets,
wallpapers, themes, and custom launchers. The interface is designed to be
intuitive and responsive, providing a smooth user experience across
different devices.

● Security: Google continuously invests in enhancing the security of the

Android platform, implementing features such as app sandboxing,
permissions system, verified boot, and Google Play Protect to protect
users from malware and security threats.

● Hardware Compatibility: Android is designed to run on a wide range of

hardware configurations, from low-end budget devices to high-end
flagship smartphones and tablets. This flexibility allows manufacturers to
create devices tailored to different market segments and price points.

● Customization and Flexibility: Android offers extensive customization

options for both users and developers. Users can customize their devices
with third-party launchers, themes, and apps, while developers have
access to a wide range of APIs and tools to build innovative and
feature-rich applications.

● Integration with Google Services: Android integrates seamlessly with

Google's ecosystem of services, including Gmail, Google Maps, Google
Drive, Google Photos, and more. This integration provides users with
access to a comprehensive suite of productivity tools and cloud services.

6
 ● Developer Tools: Google provides a comprehensive set of developer tools
and resources for building Android applications, including the Android
Studio IDE, Android SDK, Kotlin programming language support, and
robust documentation. These tools streamline the app development
process and enable developers to create high-quality applications for the
platform.

● Updates and Support: Google releases regular updates to the Android

platform, introducing new features, performance improvements, and
security enhancements. Additionally, many device manufacturers provide
their own updates and support for their Android devices, ensuring that
users have access to the latest software and security patches.

API:

An API (Application Programming Interface) is a set of rules, protocols,

and tools that allows different software applications to communicate and
interact with each other. APIs define the methods and data formats that
developers can use to request and exchange information between systems,
enabling seamless integration and interoperability between disparate software
components. Here are some key aspects of APIs:

● Communication Protocol: APIs define the communication protocol used

for interaction between software components. This can include protocols
such as HTTP, REST (Representational State Transfer), SOAP (Simple
Object Access Protocol), GraphQL, and others.

● Request-Response Model: APIs typically follow a request-response

model, where one system (the client) sends a request to another system
(the server), and the server processes the request and returns a response.
Requests are typically made using HTTP methods such as GET, POST,
PUT, DELETE, etc.

● Data Formats: APIs define the data formats used for representing and
exchanging information between systems. Common data formats include
JSON (JavaScript Object Notation), XML (eXtensible Markup
Language), and Protocol Buffers, among others.

7
● Endpoints and Methods: APIs expose endpoints, which are URLs that
clients can send requests to, along with methods or operations that clients
can perform on those endpoints. Endpoints represent specific resources or
functionalities provided by the API.

● Authentication and Authorization: APIs often require authentication and

authorization mechanisms to control access to protected resources and
ensure the security of the system. This may involve using API keys,
OAuth tokens, JWT (JSON Web Tokens), or other authentication
schemes.

● Rate Limiting and Quotas: APIs may implement rate limiting and usage
quotas to prevent abuse and ensure fair usage of resources. Rate limiting
restricts the number of requests a client can make within a certain time
period, while quotas limit the total amount of usage allowed for a given
period.

● Documentation: Good API documentation is essential for developers to

understand how to use an API effectively. API documentation typically
includes information about endpoints, methods, request and response
formats, authentication requirements, error handling, and usage examples.

● Versioning: APIs may evolve over time, with new features being added or
existing features being modified or deprecated. Versioning allows
developers to specify which version of the API they are targeting and
ensures backward compatibility with existing client applications.

● Third-Party Integration: APIs enable third-party developers to build

applications that integrate with existing platforms and services, allowing
for the creation of rich ecosystems of interconnected software
applications.

8
ANDROID STUDIO:

Android Studio is the official integrated development environment (IDE)

for Android app development, provided by Google. It is based on IntelliJ IDEA
and is tailored specifically for Android development. Android Studio offers a
comprehensive set of tools and features to streamline the app development
process. Here are some key aspects of Android Studio:

● User Interface: Android Studio provides a user-friendly interface with

customizable layouts and panels to suit individual preferences. It includes
various tools, such as project navigation, code editor, emulator, build
system, and debugging tools, all accessible from within the IDE.

● Code Editor: Android Studio features a powerful code editor with syntax
highlighting, code completion, code refactoring, and other
productivity-enhancing features. It supports multiple programming
languages, including Java, Kotlin, and XML (for layout files).

● Layout Editor: Android Studio includes a visual layout editor that allows
developers to design user interfaces (UIs) for their apps using a
drag-and-drop interface. Developers can preview the UI in real-time
across different device screen sizes and orientations.

● Gradle Build System: Android Studio uses the Gradle build system to
automate the build process for Android apps. Gradle allows developers to
define dependencies, configure build variants, and customize the build
process through build scripts written in Groovy or Kotlin.

● Android Emulator: Android Studio includes an emulator that allows

developers to test their apps on virtual Android devices running different
versions of the Android operating system. The emulator supports features
like hardware acceleration, camera emulation, and network simulation.

● Instant Run: Android Studio's Instant Run feature allows developers to

quickly deploy and test code changes on a connected device or emulator
without restarting the app. This accelerates the development cycle and
improves productivity.

9
 ● Debugging Tools: Android Studio provides robust debugging tools for
identifying and fixing issues in Android apps. Developers can set
breakpoints, inspect variables, view call stacks, and analyze performance
metrics to diagnose and troubleshoot problems.

● Version Control Integration: Android Studio seamlessly integrates with

version control systems like Git, allowing developers to manage source
code repositories directly from the IDE. It provides features such as
commit, push, pull, merge, and code review workflows.

● Android SDK Manager: Android Studio includes the Android SDK

Manager, which allows developers to download and manage Android
SDK components, platform tools, system images, and emulator images.
This ensures that developers have access to the latest APIs and
development tools.

● Extensibility: Android Studio is highly extensible, with support for

plugins and extensions that enhance its functionality. Developers can
install plugins for additional features, code generators, template libraries,
and integration with third-party services.

SQLite:

SQLite is a lightweight, embedded relational database management

system (RDBMS) that is widely used in mobile and desktop applications,
including Android apps. Here are some key aspects of SQLite:

● Self-contained: SQLite is self-contained, meaning it operates without

requiring a separate server process. It stores the entire database as a single
file on the disk, making it easy to distribute and deploy with applications.

● Serverless: Unlike traditional client-server databases, SQLite is

serverless, meaning there is no separate server process that needs to be
installed and configured. Applications interact directly with the SQLite
database file on the local disk.

10
● Zero Configuration: SQLite requires minimal configuration and setup.
Developers can simply include the SQLite library in their application and
start using it immediately without any additional configuration steps.

● Relational Database: Despite its lightweight nature, SQLite is a fully

featured relational database that supports SQL (Structured Query
Language) for defining, manipulating, and querying data. It provides
support for tables, indexes, views, triggers, and transactions.

● Cross-Platform: SQLite is cross-platform and runs on various operating

systems, including Android, iOS, Windows, macOS, and Linux. This
makes it a popular choice for building applications that need to run on
multiple platforms.

● ACID Compliance: SQLite is ACID (Atomicity, Consistency, Isolation,

Durability) compliant, ensuring that database transactions are reliable,
consistent, and durable. It supports transactions, which allow multiple
database operations to be grouped together and treated as a single unit of
work.

● Small Footprint: SQLite has a small memory and disk footprint, making it
well-suited for embedded and mobile environments with limited
resources. The SQLite library is typically only a few hundred kilobytes in
size, making it ideal for use in mobile apps.

● High Performance: Despite its lightweight design, SQLite offers high

performance for most common database operations. It is optimized for
read-heavy workloads and can efficiently handle thousands of
transactions per second on modern hardware.

● Open Source: SQLite is open source and released into the public domain,
allowing developers to use, modify, and distribute it freely without any
licensing restrictions.

11
JETPACK COMPOSE:

Jetpack Compose," which is a modern toolkit for building native Android

user interfaces (UIs) using declarative Kotlin syntax. Jetpack Compose is part of
the larger Android Jetpack library, which provides a set of components, tools,
and architectural guidance to help developers build high-quality Android apps
more easily and efficiently. Here's an overview of Jetpack Compose:

● Declarative UI: Jetpack Compose uses a declarative approach to UI

development, allowing developers to describe the desired UI hierarchy
and behavior using Kotlin code. This contrasts with the traditional
imperative approach used with XML layouts and imperative UI
frameworks like View-based UI in Android.

● Kotlin-first: Jetpack Compose is designed to be Kotlin-first, meaning it

leverages the features and capabilities of the Kotlin programming
language to provide a more concise, readable, and type-safe UI
development experience. Developers can take advantage of Kotlin
language features such as extension functions, lambdas, and DSLs
(domain-specific languages) to define UI components and layouts.

● Composable Functions: In Jetpack Compose, UI components are defined

as composable functions, which are regular Kotlin functions annotated
with @Composable. These functions describe the UI elements and their
properties, and they can be composed together to build complex UIs from
simple building blocks.

● Reactive UI: Jetpack Compose embraces a reactive programming model,

where UI components automatically update in response to changes in
their underlying state. This simplifies UI development by eliminating the
need for manual view updates and event handling, resulting in a more
predictable and efficient UI programming model.

12
● Material Design Integration: Jetpack Compose provides built-in support
for Material Design, Google's design language for creating intuitive and
visually appealing user interfaces. It includes a rich set of Material
Design components and styles that developers can use to quickly build
modern and consistent UIs.

● Preview and Testing: Jetpack Compose includes tools for previewing UI

components directly within Android Studio, allowing developers to see
how their UIs will look and behave without needing to run the app on a
device or emulator. Additionally, Jetpack Compose supports unit testing
and UI testing, enabling developers to verify the correctness of their UI
logic and behavior.

● Interoperability: Jetpack Compose is designed to be interoperable with

existing Android UI frameworks and libraries, allowing developers to
gradually adopt it into their existing projects. It can coexist with
View-based UI code, and developers can integrate Jetpack Compose
components into their existing XML layouts.

● Early Adopter Program: As of my last update, Jetpack Compose was still

in an early adopter phase, with ongoing development and improvements.
While it was not yet considered stable for production use, developers
could experiment with it and provide feedback to help shape its future
direction.

13
 2. SYSTEM STUDY

2.1 EXISTING SYSTEM

In the existing system, individuals with disabilities face significant

challenges in accessing facilities and navigating their surroundings. Several
drawbacks are inherent in the current landscape, exacerbating the difficulties
faced by this demographic.

2.1.1 DRAWBACKS
​
Limited Accessibility Information: Existing navigation systems often lack
detailed information about accessibility features in public spaces, such as
wheelchair ramps, elevators, and Braille signage, making it challenging for
disabled individuals to plan their routes effectively.

● Inconvenient User Interfaces: Many navigation applications have

complex user interfaces that are difficult for individuals with disabilities
to navigate independently. This complexity hinders their ability to access
essential features and customize settings according to their needs.

● Lack of Voice-Based Navigation: Traditional navigation systems

primarily rely on visual cues, making them inaccessible to visually
impaired individuals. The absence of voice-based navigation options
further limits the independence and mobility of this demographic.

● Inaccurate or Outdated Information: Some existing systems may provide

inaccurate or outdated information about accessibility features, leading to
potential navigational challenges and frustration for disabled users.

2.2 PROPOSED SYSTEM

To address the shortcomings of the existing system and enhance the

accessibility and inclusivity of navigation for individuals with disabilities, the
proposed system introduces innovative features and functionalities tailored to
their specific needs.

14
2.2.1 FEATURES

● Comprehensive Accessibility Information: The proposed system will

provide detailed information about accessibility features in public spaces,
including wheelchair accessibility, tactile paving, audible signals, and
designated parking spaces. This information will enable users to plan
their routes more effectively and navigate with confidence.

● Intuitive User Interface: The user interface of the proposed system will be
designed with accessibility in mind, featuring simple navigation menus,
high contrast visuals, and customizable font sizes. These design elements
will ensure that individuals with disabilities can easily navigate the
application and access essential features.

● Voice-Based Navigation: A key feature of the proposed system is

voice-based navigation, allowing users to navigate their surroundings
using simple voice commands. This feature will provide an intuitive and
hands-free navigation experience, particularly beneficial for visually
impaired individuals.

● Real-Time Updates: The proposed system will leverage real-time data to

provide users with accurate and up-to-date information about accessibility
features and navigation routes. This will help prevent potential
navigational challenges caused by outdated or inaccurate information.

● Personalized Preferences: Users will have the option to customize their

preferences within the application, such as preferred navigation modes,
favorite locations, and accessibility settings. These personalized features
will enhance the user experience and cater to the diverse needs of
individuals with disabilities.

15
 3. SYSTEM DESIGN AND DEVELOPMENT

3.1 FILE DESIGN

File design involves organizing and structuring the files used in the
application. For an Android application like the Friendly Map Android
Application for Disabled People, the file design includes layout XML files, Java
source code files, resource files (such as images and audio files), and
configuration files (such as AndroidManifest.xml).

3.2 INPUT DESIGN

Input design focuses on designing user interfaces and mechanisms for

user input. For this project, input design includes creating intuitive and
accessible interfaces for users to interact with the application. This involves
designing forms for user registration, search interfaces for finding locations, and
voice input mechanisms for voice-based navigation.

3.3 OUTPUT DESIGN

Output design involves determining how information is presented to the

user. In this project, output design includes designing user interfaces to display
navigation instructions, search results for nearby facilities, and information
about accessibility features at various locations. The output should be presented
in a clear and understandable manner, with consideration for users with different
types of disabilities.

3.4 DATABASE DESIGN

Database design involves designing the structure of the database used by

the application. For the Friendly Map Android Application, the database design
includes creating tables to store information about users, locations, navigation
routes, and user preferences. This involves defining the schema, relationships
between tables, and constraints to ensure data integrity.

16
3.5 SYSTEM DEVELOPMENT

System development involves implementing the design specifications to

build the application. For this project, system development includes writing
Java code for the Android application, creating layout XML files for the user
interface, implementing database operations using SQLite, and integrating
external APIs for features such as maps and voice recognition.

3.5.1 DESCRIPTION OF MODULES

​ User Registration and Authentication Module:

● This module enables users to register for an account within the
application, providing their details such as username, password,
and email. It also includes functionality for user authentication to
ensure secure access to the application.
​
​ Location Search and Information Module:
This module allows users to search for locations, such as colleges,
bus stops, and public buildings, based on various criteria. It
retrieves detailed information about each location, including
accessibility features, contact information, and operating hours.
​
​ Navigation and Route Planning Module:
The navigation module provides users with options for route
planning and navigation between different locations. It calculates
optimal routes based on user preferences and accessibility
requirements, considering factors such as distance, time, and
available transportation options.
​
​ Voice-Based Navigation Module:
This module offers voice-based navigation functionality, allowing
users to navigate their surroundings using voice commands. It
integrates with speech recognition APIs to interpret user voice
inputs and provide audible navigation instructions.
​
​
​

17
​ User Preferences and Customization Module:
The customization module allows users to personalize their
experience within the application by setting preferences for
navigation modes, favorite locations, and accessibility settings. It
provides options for users to customize the application interface
according to their needs and preferences.
​
​ Accessibility Features Module:
This module focuses on enhancing accessibility within the
application for users with disabilities. It includes features such as
high contrast interfaces, text-to-speech functionality, and support
for alternative input methods to ensure usability for all users,
regardless of their abilities.

18
 4. TESTING AND IMPLEMENTATION

4.1 TESTING

Testing is a crucial phase to ensure the reliability, functionality, and

usability of the Friendly Map Android Application for Disabled People. Various
types of testing should be conducted to identify and address any issues or bugs
before the application is deployed to users.

4.1.1 TYPES OF TESTING:

● Unit Testing: Verify the functionality of individual components and

modules of the application, such as database operations, navigation
algorithms, and user interface elements.

● Integration Testing: Ensure that different components of the application

work together seamlessly. Test the integration of database operations, user
input mechanisms, and external APIs.

● User Acceptance Testing (UAT): Involve disabled individuals in testing

the application to gather feedback on its accessibility, usability, and
effectiveness in meeting their needs. Consider conducting UAT with
individuals representing various disabilities, such as visual impairment,
hearing impairment, and mobility impairment.

● Accessibility Testing: Evaluate the application against accessibility

standards and guidelines, such as the Web Content Accessibility
Guidelines (WCAG). Test the application using assistive technologies,
such as screen readers and voice input devices, to ensure compatibility
and usability for disabled users.

● Performance Testing: Assess the performance of the application under

various conditions, such as different network speeds and device
specifications. Measure factors such as response time, memory usage, and
battery consumption to optimize performance and efficiency.

19
4.1.2 TESTING TOOLS:

● Android Studio: Use the built-in testing tools provided by Android

Studio, such as the Android Emulator and Device Manager, for testing on
different devices and Android versions.

● Accessibility Testing Tools: Utilize accessibility testing tools and plugins,

such as Axe for Android, Accessibility Scanner, and TalkBack screen
reader, to evaluate the accessibility of the application and identify
potential accessibility issues.

● Continuous Integration (CI) Tools: Implement CI tools, such as Jenkins or

CircleCI, to automate the testing process and ensure that new code
changes do not introduce regressions or break existing functionality.

4.2 IMPLEMENTATION

Implementation involves deploying the Friendly Map Android

Application for Disabled People to users, making it available for download and
use on Android devices. Before deployment, ensure that the application has
undergone thorough testing and meets the necessary quality standards and
accessibility requirements.

20
 5. CONCLUSION

The development of the Friendly Map Android Application for Disabled

People represents a significant step towards enhancing accessibility, inclusivity,
and independence for individuals with disabilities. Through the implementation
of innovative features and functionalities, the application aims to address the
challenges faced by disabled individuals in accessing facilities and navigating
their surroundings.

KEY ACHIEVEMENTS:

● Accessibility: By providing detailed information about accessibility

features and offering voice-based navigation options, the application
makes it easier for disabled individuals to navigate public spaces
independently.

● User-Centric Design: The user interface of the application is designed

with accessibility in mind, featuring intuitive navigation menus, high
contrast visuals, and customizable settings to cater to the diverse needs of
disabled users.

● Empowerment: The application empowers disabled individuals to plan

their routes effectively, save favorite locations, and customize navigation
preferences, promoting independence and mobility.

FUTURE DIRECTIONS:

● Continuous Improvement: The development team will continue to gather

feedback from users and iterate on the application to address any
remaining issues, enhance existing features, and introduce new
functionalities.

● Expansion of Accessibility Features: Future updates may include

additional accessibility features, such as support for alternative input
methods, integration with wearable devices, and enhanced compatibility
with assistive technologies.

21
 BIBLIOGRAPHY

● World Health Organization. (2021). Disability and health. [Online].

Available:
https://www.who.int/news-room/fact-sheets/detail/disability-and-health
● Web Content Accessibility Guidelines (WCAG) 2.1. (2018). W3C
Recommendation. [Online]. Available:
https://www.w3.org/TR/WCAG21/
● Android Developer Documentation. (n.d.). Android Developers. [Online].
Available: https://developer.android.com/docs
● SQLite Documentation. (n.d.). SQLite. [Online]. Available:
https://www.sqlite.org/docs.html
● Google Maps Platform Documentation. (n.d.). Google Developers.
[Online]. Available: https://developers.google.com/maps/documentation
● Android Accessibility Documentation. (n.d.). Android Developers.
[Online]. Available:
https://developer.android.com/guide/topics/ui/accessibility
● Axe for Android. (n.d.). Deque Systems. [Online]. Available:
https://www.deque.com/axe/android/
● TalkBack Screen Reader. (n.d.). Google Accessibility. [Online].
Available:
https://support.google.com/accessibility/android/answer/9711874?hl=en
● Jenkins Documentation. (n.d.). Jenkins. [Online]. Available:
https://www.jenkins.io/doc/
● CircleCI Documentation. (n.d.). CircleCI. [Online]. Available:
https://circleci.com/docs/

22
 APPENDICES

A. DATA FLOW DIAGRAM

Level 0

23
Level 1

24
B. TABLE STRUCTURE

Location Table

Colum name Data type NULL Constraints

location_id int(11) NO Primary key
name varchar(255) NO NO
latitude decimal(10,8) NO NO
longitude decimal(11,8) NO NO
description text Yes NO

Navigationrout Table

Colum name Data type NULL Constraints

route_id int(11) NO Primary key
start_location_id int(11) NO Foreign key
end_location_id int(11) NO Foreign key
distance decimal(10,2) NO NO
duration int(11) NO NO

25
User Table

Colum name Data type NULL Constraints

user_id int(11) NO Primary key
username varchar(255) NO NO
password varchar(255) NO NO
email varchar(255) NO NO

Userfavorites Table

Colum name Data type NULL Constraints

favorite_id int(11) NO Primary key
user_id int(11) NO Foreign key
location_id int(11) NO Foreign key

26
C. SAMPLE CODING

package com.example.wander

import android.Manifest
import android.content.pm.PackageManager
import android.content.res.Resources
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import android.view.Menu
import android.view.MenuItem
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import com.example.wander.R

import com.google.android.gms.maps.CameraUpdateFactory
import com.google.android.gms.maps.GoogleMap
import com.google.android.gms.maps.OnMapReadyCallback
import com.google.android.gms.maps.SupportMapFragment
import com.google.android.gms.maps.model.*
import java.util.*

//This class allows you to interact with the map by adding markers, styling its appearance
and
// displaying the user's location.
class MapsActivity : AppCompatActivity(), OnMapReadyCallback {

private lateinit var map: GoogleMap

private val TAG = MapsActivity::class.java.simpleName
private val REQUEST_LOCATION_PERMISSION = 1

override fun onCreate(savedInstanceState: Bundle?) {

super.onCreate(savedInstanceState)
setContentView(R.layout.activity_maps)
// Obtain the SupportMapFragment and get notified when the map is ready to be used.
val mapFragment = supportFragmentManager
.findFragmentById(R.id.map) as SupportMapFragment
mapFragment.getMapAsync(this)
}

/**
* Manipulates the map once available.
* This callback is triggered when the map is ready to be used.

27
 * This is where we can add markers or lines, add listeners or move the camera. In this
case,
* we just add a marker near the Googleplex.
* If Google Play services is not installed on the device, the user will be prompted to install
* it inside the SupportMapFragment. This method will only be triggered once the user has
* installed Google Play services and returned to the app.
*/
override fun onMapReady(googleMap: GoogleMap) {
map = googleMap

//These coordinates represent the lattitude and longitude of the Googleplex.

val latitude = 37.422160
val longitude = -122.084270
val zoomLevel = 15f
val overlaySize = 100f

val homeLatLng = LatLng(latitude, longitude)

map.moveCamera(CameraUpdateFactory.newLatLngZoom(homeLatLng, zoomLevel))
map.addMarker(MarkerOptions().position(homeLatLng))

val googleOverlay = GroundOverlayOptions()

.image(BitmapDescriptorFactory.fromResource(R.drawable.android))
.position(homeLatLng, overlaySize)
map.addGroundOverlay(googleOverlay)

setMapLongClick(map)
setPoiClick(map)
setMapStyle(map)
enableMyLocation()
}

// Initializes contents of Activity's standard options menu. Only called the first time options
// menu is displayed.
override fun onCreateOptionsMenu(menu: Menu?): Boolean {
val inflater = menuInflater
inflater.inflate(R.menu.map_options, menu)
return true
}

// Called whenever an item in your options menu is selected.

override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
// Change the map type based on the user's selection.
R.id.normal_map -> {
map.mapType = GoogleMap.MAP_TYPE_NORMAL
true
}
R.id.hybrid_map -> {
map.mapType = GoogleMap.MAP_TYPE_HYBRID

28
 true
}
R.id.satellite_map -> {
map.mapType = GoogleMap.MAP_TYPE_SATELLITE
true
}
R.id.terrain_map -> {
map.mapType = GoogleMap.MAP_TYPE_TERRAIN
true
}
else -> super.onOptionsItemSelected(item)
}

// Called when user makes a long press gesture on the map.

private fun setMapLongClick(map: GoogleMap) {
map.setOnMapLongClickListener { latLng ->
// A Snippet is Additional text that's displayed below the title.
val snippet = String.format(
Locale.getDefault(),
"Lat: %1$.5f, Long: %2$.5f",
latLng.latitude,
latLng.longitude
)
map.addMarker(
MarkerOptions()
.position(latLng)
.title(getString(R.string.dropped_pin))
.snippet(snippet)

.icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_BLUE))
)
}
}

// Places a marker on the map and displays an info window that contains POI name.
private fun setPoiClick(map: GoogleMap) {
map.setOnPoiClickListener { poi ->
val poiMarker = map.addMarker(
MarkerOptions()
.position(poi.latLng)
.title(poi.name)
)
poiMarker.showInfoWindow()
}
}

// Allows map styling and theming to be customized.

private fun setMapStyle(map: GoogleMap) {

29
 try {
// Customize the styling of the base map using a JSON object defined
// in a raw resource file.
val success = map.setMapStyle(
MapStyleOptions.loadRawResourceStyle(
this,
R.raw.map_style
)
)

if (!success) {
Log.e(TAG, "Style parsing failed.")
}
} catch (e: Resources.NotFoundException) {
Log.e(TAG, "Can't find style. Error: ", e)
}
}

// Checks that users have given permission

private fun isPermissionGranted() : Boolean {
return ContextCompat.checkSelfPermission(
this,
Manifest.permission.ACCESS_FINE_LOCATION) ==
PackageManager.PERMISSION_GRANTED
}

// Checks if users have given their location and sets location enabled if so.
private fun enableMyLocation() {
if (isPermissionGranted()) {
map.isMyLocationEnabled = true
}
else {
ActivityCompat.requestPermissions(
this,
arrayOf<String>(Manifest.permission.ACCESS_FINE_LOCATION),
REQUEST_LOCATION_PERMISSION
)
}
}

// Callback for the result from requesting permissions.

// This method is invoked for every call on requestPermissions(android.app.Activity,
String[],
// int).

30
D. SAMPLE SCREEN

GPS coordinates recorder screen

31
Click the play option, and then the Voice assistant assists the blind person
in navigating the correct destination

32