INDUSTRIAL TRAINING REPORT

Android Development Training

Submitted in partial fulfilment of the requirements for the award of the

degree
of

BACHELOR OF TECHNOLOGY

in

Computer Science & Engineering

by

Submitted By: Harprabh Singh

Enrollment Number: 07114802721

SUBMITTED TO;

Department of Computer Science & Engineering

MAHARAJA AGRASEN INSTITUTE OF TECHNOLOGY
GGSIPU, DELHI

1
 DECLARATION

I hereby declare that the Training Report entitled Android Development Training is an authentic
record of my own work as requirements of 4 weeks Training during the period from to for the
award of degree of B.Tech. (Computer Science & Engineering), GGSIPU, under the guidance of
Denis Panjuta.

Date:

Student’s name: Harprabh Singh

Enrollment number: 07114802721

We certify that the above statement made by the student is correct to the best of our knowledge
and belief.

Date:

Mentor’s name: Ms, Neetu Garg

Designation

2
CERTIFICATE

3
 ACKNOWLEGEMENT

I would like to acknowledge the contributions of the following people, without whose help and
guidance this report would not have been completed.

I acknowledge the support of our counselor Ms. Neetu Garg, Associate Professor, CSE
department, with respect and gratitude, whose expertise, guidance, support, encouragement,
and enthusiasm have made this report possible. Their feedback vastly improved the quality of
this report and provided an enthralling experience. I am indeed proud and fortunate to be
supervised by her.

We are thankful to H.O.D. CSE department, Maharaja Agrasen Institute of Technology, New
Delhi for her constant encouragement, valuable suggestions, and moral support and blessings.

I shall remain indebted to the faculty and staff members of Maharaja Agrasen Institute of
Technology, New Delhi.

4
 ABOUT

Udemy

Udemy is one of the world's leading online learning platforms, offering a vast array of courses on
diverse subjects. Founded in 2010, Udemy's mission is to improve lives through learning. It
provides an opportunity for experts in various fields to share their knowledge with a global
audience. The platform allows instructors to create and sell courses while enabling learners to
enhance their skills and knowledge conveniently from the comfort of their homes.

Key Aspects of Udemy:

1. Wide Range of Courses:

● Diverse Subjects: Udemy offers courses on virtually every topic imaginable, including
technology, business, arts, health, and lifestyle.
● Development Courses: Udemy hosts a plethora of development-related courses, covering
programming languages (like Python, JavaScript, Java), web development frameworks
(such as React.js, Angular, and Django), mobile app development (iOS, Android), and
software engineering practices.

2. Instructor-Led Learning:

● Expert Instructors: Courses are taught by industry professionals, experienced educators,

and subject matter experts, ensuring high-quality content.
● Interactive Learning: Instructors utilize video lectures, quizzes, assignments, and hands-on
projects to create engaging and interactive learning experiences.

3. Flexible Learning Experience:

● Self-Paced Learning: Learners can study at their own pace, allowing for flexibility to
balance learning with other commitments.
● Lifetime Access: Once enrolled, students often have lifetime access to the course
materials, allowing them to revisit lessons whenever they need.

5
Course Overview

Denis Panjuta's Android Development course on Udemy is a comprehensive program designed for
beginners and intermediate learners who want to dive into the world of Android development. The
course would cover a wide range of topics, providing a strong foundation in both front-end and
back-end Android development.

The course includes over 40+ hours of HD video tutorials and builds your programming
knowledge while making real-world Android Applications.

Instructor

Denis Panjuta is a well-known instructor who has a passion for teaching and has created various
programming and development courses. He is praised for her teaching style and ability to explain
complex concepts in a simple and understandable manner.

He has a degree in engineering from the University for Applied Science Konstanz in Germany He
has helped hundreds of thousands of students learn to code and change their lives by becoming a
developer.

6
 LIST OF FIGURES

1) Android Versions
2) Android Architecture
3) Activity Lifecycle
4) Retrofit Code for Get and Post Request to server
5) Project Snapshots

7
 Table of Contents

1. Introduction
1.1 Background and Motivation
1.2 Training Objectives
2. Tools & Technology Used
3. Technical Contents
3.1 Android Fundamentals
3.1.1 Understanding Android Architecture
3.1.2 Exploring the Android Ecosystem
3.2 User Interface Design
3.2.1 Layouts and Views
3.3 SQLite Databases and Data Storage
3.4 Integration of Networking and Web Services
3.4.1 Making HTTP Requests
3.4.2 Parsing Data from Web Services
3.5 Project
3.5.1 Project Description and Objective
4. Snapshots
5. Results and Discussions
5.1 Key Learning Outcomes:
5.2 Challenges and Opportunities
6. Conclusions and Future Scope
7. Weekly Training Summary
8. Learning after Training
9. References

8
1. Introduction
1.1 Background and Motivation
Mobile applications have fundamentally transformed the way we live, work, and interact with the
world. Android, as the dominant mobile operating system, plays a pivotal role in shaping how we
interact with technology and the applications we rely on for various aspects of our lives.
Mobile apps serve as innovative solutions to address various societal challenges. They bridge
gaps, enhance access, and facilitate connectivity, leading to tangible improvements in the quality
of life. These apps empower individuals with tools to tackle issues, share knowledge, and foster
collaboration, ultimately creating a more inclusive and well-informed society. Whether by
facilitating communication, streamlining services, or promoting sustainable practices, mobile apps
are instrumental in crafting practical solutions and driving positive societal change.
With an understanding of the global prevalence and influence of Android, I recognized the course
as a gateway to a world of opportunities in app development.
The growing emphasis on user-centric design, continuous innovation, and the economic potential
of Android app development heightened my enthusiasm. It was clear that mastering Android
development would not only enhance my skills but also enable me to participate in shaping the
future of mobile technology.
The ubiquity of smartphones in today's society and the increasing reliance on Android as a
platform inspired my pursuit of this course. I sought to transform my passion for technology into a
concrete skill set that could not only enhance my career prospects but also allow me to contribute
to the ever-evolving mobile app landscape.
This Android development training program is underpinned by several key motivators:
1. Innovation and Problem-Solving: The opportunity to engage in innovative projects and
solve complex problems through app development.
2. Professional Challenge: Android development offers a technical challenge that is
intellectually stimulating. Mastering the intricacies of the Android platform and
programming languages is a personal goal.
3. Diversifying Skill Set: Expanding one's skill set is a serious motivator for some. Android
development courses provide a chance to diversify technical capabilities, which can be
valuable for career growth and versatility in the tech industry.

9
1.2 Training Objectives

1. Understanding Android Fundamentals

Gain a comprehensive understanding of the fundamental components of the Android operating
system, including the structure of Android apps, activities, services, and application components.

2. Effective User Interface Design and Interaction

Learnt how to design user-friendly and visually appealing user interfaces (UI) for Android apps,
incorporating layouts, widgets, and responsive design principles.

3. Data Handling and Storage

Training participants in effective data management and storage mechanisms in Android was a crucial goal.
This included utilizing shared preferences, SQLite databases, and content providers for data storage.

4. Integration of Networking and Web Services

Participants were encouraged to integrate networking and web services into their Android applications.
This involved making HTTP requests, parsing data from web services, and connecting their apps to online
resources.

5. Performance Optimization
Discover strategies for optimizing app performance, including minimizing resource usage,
enhancing responsiveness, and reducing load times.

10
2. Tools & Technology Used
● Android Studio: Android Studio is the official Integrated Development Environment
(IDE) for Android app development. It provides a rich set of features, including an
emulator for testing apps, a visual layout editor, code completion, debugging tools, and
more.

● Kotlin: This is the primary programming language used for Android app development.
While Java has been the traditional language, Kotlin has gained popularity due to its
concise syntax and improved safety features. Kotlin is now the preferred language for
Android development.
● Android SDK: The Android Software Development Kit (SDK) is a set of tools and
libraries that developers use to create Android applications. It includes the Android API
libraries, development tools, and system images for testing on virtual devices.
● XML: XML is used for designing the user interface of Android apps. Developers create
layout files using XML, defining the structure and appearance of the app's UI components.
● Gradle: Gradle is the build system used to automate the build process for Android apps. It
manages dependencies, compiles code, and packages the app for distribution.
● Version Control (e.g., Git): Developers use version control systems like Git to manage
the source code of their Android apps. Git is used for tracking changes, collaborating with
a team, and maintaining code history.

11
 ● Room Library: Room is an Android library that simplifies local data storage, providing
an object-oriented way to work with SQLite databases in Android applications.
● Android Emulator: The Android Emulator, included with Android Studio, allows
developers to test their apps on virtual devices with different Android versions and screen
sizes.
● Material Design: Material Design is Google's design language for creating visually
appealing and consistent Android app interfaces. Android developers often follow these
design principles.
● Alarm Manager: Alarm Manager is an Android class for scheduling tasks at specific
times or intervals, such as notifications, data updates, or other actions, even when an app is
not actively running.

3. Technical Contents
3.1. Kotlin Fundamentals.
Kotlin, a modern and concise programming language, has emerged as a favored choice for
developers across the Android ecosystem and beyond. This comprehensive write-up
explores the foundational elements of Kotlin, delving into its core features and principles.
Kotlin, officially introduced by JetBrains in 2011, offers a pragmatic and expressive
alternative to Java. It's a statically typed language that can be used in a wide range of
application domains, from mobile app development to web applications and backend
systems.

12
Simplicity and Conciseness:
Kotlin prides itself on its simplicity and conciseness. It reduces boilerplate code and
employs smart type inference, making it more succinct and readable compared to Java.
This results in fewer errors and less time spent debugging.

Null Safety:
One of Kotlin's standout features is its approach to null safety. Null references are a
common source of runtime crashes in many programming languages. Kotlin tackles this
issue head-on by distinguishing nullable and non-nullable types. Developers must
explicitly define whether a variable can hold a null value, reducing the chances of null
pointer exceptions.

Interoperability:

Kotlin can seamlessly work with Java. It allows developers to migrate existing Java
codebases to Kotlin gradually, ensuring that legacy code remains functional while new
features are written in Kotlin.

Extension Functions:

Kotlin introduces extension functions, a powerful feature that lets developers add new
functions to existing classes without modifying their source code. This facilitates the
creation of more expressive and natural APIs

13
.

Lambdas and Higher-Order Functions:

Kotlin supports functional programming constructs like lambdas and higher-order

functions, enabling concise and elegant solutions for various tasks. These features are
particularly beneficial in scenarios where data processing and manipulation are involved.

Data Classes:

Kotlin introduces data classes that automatically generate useful methods like equals(),
hashCode(), and toString() for simpler and more efficient data modeling.

14
 Coroutines:

Coroutines in Kotlin enable asynchronous programming without the callback hell often
seen in other languages. They simplify managing asynchronous tasks, improving code
readability and maintainability.

3.2. User Interface and Custom Layout.

In the realm of Android app development, crafting the user interface (UI) is of paramount
importance. The design and structure of an app's UI not only impact its visual appeal but
also influence user experience and functionality. To create visually appealing and
responsive UIs for Android applications, developers rely on XML-based layouts.

15
 Understanding XML Layouts:

XML (eXtensible Markup Language) is a markup language used to structure data and
define content hierarchies. In the context of Android app development, XML serves as the
standard for defining the layout of the app's UI components. XML layouts provide a clear,
structured, and declarative way to specify how different UI elements are arranged and
styled.

Key Concepts in XML Layouts:

​ View Hierarchy: XML layouts define a hierarchy of views and view groups, where views
represent individual UI elements (e.g., buttons, text fields) and view groups are containers
that hold multiple views (e.g., layouts like LinearLayout or RelativeLayout).
​ Attributes: XML layouts allow developers to set attributes for UI elements, including
properties such as dimensions, colors, text, and positioning. Attributes control the
appearance and behavior of the UI components.
​ Resources: To promote reusability and efficient management of UI elements, XML
layouts can reference external resources such as colors, strings, and styles, stored in
separate XML files or resource folders.
​ Layout Types: Various types of layouts are available, including linear, relative, constraint,
and frame layouts, each serving different purposes and accommodating diverse UI design
requirements.

Layout Types:

1. LinearLayout:

LinearLayout arranges child views in a single row or column, depending on whether it's set
to horizontal or vertical orientation. It's a simple and straightforward layout for linear
arrangement of views.

2. RelativeLayout:

RelativeLayout allows developers to specify the position of child views in relation to each
other or the parent layout. This layout is highly flexible and useful for creating complex
and dynamic UIs.

16
3. ConstraintLayout:

ConstraintLayout is another versatile layout that allows developers to create responsive

and flexible UIs by defining constraints between views. It's ideal for complex UI designs
and adapts well to different screen sizes.

4. FrameLayout:

FrameLayout is a simple layout that places child views on top of one another. It's often
used for displaying a single view at a time, such as fragments in a container or a single
view for animations.

5. GridLayout:

GridLayout arranges views in a grid, making it suitable for creating tabular layouts or
arranging items in rows and columns. It's particularly useful for displaying data in a
structured format.

6. TableLayout:

TableLayout is another option for creating tabular layouts, often used when you want to
present data in a table-like format. It's designed for aligning views in rows and columns.

7. ScrollView:

ScrollView is a view group that enables scrolling when the content inside exceeds the
available screen space. It's commonly used when you need to display a large amount of
content within a confined space.

8. CoordinatorLayout:

CoordinatorLayout is designed for creating complex and coordinated UIs, often used in
conjunction with app bars, collapsing toolbars, and floating action buttons. It provides
precise control over the behavior of child views.

9. CardView:

17
 CardView is not a layout in the traditional sense, but it's a view group that is used to
display content in a card-like format with rounded corners and elevation. It's frequently
used in material design for displaying information in a visually appealing manner.

10. GridLayout (in combination with ScrollView):

A GridLayout can also be nested within a ScrollView, allowing for scrollable grids of
content. This approach is often used when you have a grid of items that need to be
scrollable, which doesn't fit on the screen all at once.

3.3. RecyclerView
The RecyclerView is a powerful and efficient Android UI component designed to display large
sets of data in a flexible and performance-oriented way.

Key Features and Benefits of RecyclerView:

​ Efficient Scrolling: RecyclerView is designed to efficiently handle scrolling through large

datasets. It recycles and reuses view items as they scroll off the screen, minimizing
memory consumption and improving performance.
​
​ Flexible Layout Managers: RecyclerView supports various layout managers, such as
LinearLayoutManager, GridLayoutManager, and StaggeredGridLayoutManager, enabling
developers to create a variety of list and grid layouts.
​
​ View Recycling: As the name suggests, RecyclerView recycles views to minimize the
creation and destruction of view items. This recycling process improves scrolling
performance and reduces memory overhead.

Creating a RecyclerView:

To implement a RecyclerView in an Android app, developers need to follow a few key steps:

​ Layout Definition: Start by defining the layout for the RecyclerView in the XML layout
file. Typically, this layout includes the RecyclerView widget itself.

18
 ​ Adapter Creation: Create an adapter class that extends RecyclerView.Adapter. This
adapter is responsible for binding data to the view items and creating view holders for each
item.
​ Layout Manager: Choose an appropriate layout manager based on the desired UI layout
(linear, grid, staggered, etc.).
​ Item Layout: Create a layout for each item in the list. This layout defines the visual
structure of each item and is inflated by the adapter.
​ Binding Data: Within the adapter, implement methods for binding data to the view items.
This is where the data from the dataset is associated with the item's UI elements.
​ RecyclerView Setup: In the activity or fragment, set up the RecyclerView by attaching the
layout manager, creating an instance of the adapter, and assigning the adapter to the
RecyclerView.
​ Data Population: Populate the dataset with the data you want to display in the
RecyclerView.
​ User Interaction Handling: Implement item click or touch handling based on the
application's requirements.

3.4. Android Building Blocks

Each building block is a different point through which the system can enter your application. Not
all components are actual entry points for the user and some depend on each other, but each one
exists as its own entity and plays a specific role each one is a unique building block that helps
define your application's overall behavior.

3.4.1 Activities
An activity is an application component that provides a screen with which users can interact in
order to do something, such as dial the phone, take a photo, send an email, or view a map. Each

19
activity is given a window in which to draw its user interface. The window typically fills the
screen, but may be smaller than the screen and float on top of other windows. An application
usually consists of multiple activities that are loosely bound to each other. Typically, one activity
in an application is specified as the "main" activity, which is presented to the user when launching
the application for the first time. Each activity can then start another activity in order to perform
different actions. Each time a new activity starts, the previous activity is stopped, but the system
preserves the activity in a stack (the "back stack"). When a new activity starts, it is pushed onto
the back stack and takes user focus. The back stack abides to the basic "last in, first out" stack
mechanism, so, when the user is done with the current activity and presses the Back button, it is
popped from the stack (and destroyed) and the previous activity resumes. When an activity is
stopped because a new activity starts, it is notified of this change in state through the activity's
lifecycle callback methods. There are several callback methods that an activity might receive, due
to a change in its state- whether the system is creating it, stopping it, resuming it, or destroying
it-and cach callback provides you the opportunity to perform specific work that's appropriate to
that state change. For instance, when stopped, your activity should release any large objects, such
as network or database connections. When the activity resumes, you can reacquire the necessary
resources and resume actions that were interrupted. These state transitions are all part of the
activity lifecycle.

20
 Activity Lifecycle
3.4.2 Services
A service is an application component that can perform long-running operations in the
background, and it does not provide a user interface. Another application component can start a
service, and it continues to run in the background even if the user switches to another application.
Additionally, a component can bind to a service to interact with it and even perform inter-process
communication (IPC). For example, a service can handle network transactions, play music,
perform file I/O, or interact with a content provider, all from the background.

21
These are the three different types of services:
1. Scheduled
A service is scheduled when an API such as the JobScheduler, introduced in Android 5.0 (API
level 21), launches the service. You can use the JobScheduler by registering jobs and specifying
their requirements for network and timing. The system then gracefully schedules the jobs for
execution at the appropriate times. The JobScheduler provides many methods to define
service-execution conditions.
2. Started
A service is started when an application component (such as an activity) calls startService(). After
it's started, a service can run in the background indefinitely, even if the component that started it is
destroyed.
Usually, a started service performs a single operation and does not return a result to the caller. For
example, it can download or upload a file over the network. When the operation is complete, the
service should stop itself.
3. Bound
A service is bound when an application component binds to it by calling bindService(). A bound
service offers a client-server interface that allows components to interact with the service, send
requests, receive results, and even do so across processes with inter process communication (IPC).
A bound service runs only as long as another application component is bound to it. Multiple
components can bind to the service at once, but when all of them unbind, the service is destroyed.

3.4.3 Content Providers

A content provider manages a shared set of application data. You can store the data in the file
system, an SQLite database, on the web, or any other persistent storage location your application
can access. A content provider provides a structured interface to application data. Via a content
provider, your application can share data with other applications. Android contains an SQLite
database which is frequently used in conjunction with a content provider.

22
3.4.4 Broadcast Receivers
Broadcast Receivers simply respond to broadcast messages from other applications or from the
system itself. These messages are sometimes called events or intents. For example, applications
can also initiate broadcasts to let other applications know that some data has been downloaded to
the device and is available for them to use, so this is the broadcast receiver who will intercept this
communication and initiate appropriate action.

3.4.5 Intent
Intents are asynchronous messages that allow the application to request functionality from other
Android components, e.g. from services or activities. An application can call a component directly
(explicit Intent) or ask the Android system to evaluate registered components based on the intent
data (implicit intent). For example, the application could implement sharing of data via an intent
and all components which allow sharing of data would be available for the user to select
Applications to register themselves to an intent via an intent. Filter Intents allow an Android
application to start and interact with components from other Android applications.

3.4.6 Using the intent to launch the activities

There are separate methods for activating each type of component:
● You can start an activity (or give it something new to do) by passing Intent to
startActivity() or startActivityForResult().
● You can start a service (or give new instructions to an ongoing service) by passing an
Intent tostartService(). Or you can bind to the service by passing an Intent to bindService().
● You can initiate a broadcast by passing an Intent to methods like sendBroadcast(),
sendOrderedBroadcast(),or sendStickyBroadcast().
● You can perform a query to a content provider by calling query on a ContentResolver.

23
3.5. Android UI Components
3.5.1 Introducing Layouts

Frame Layout
Frame layouts are one of the simplest layout types used to organize controls within the user
interface of an Android application. They are used less often than some other layouts, simply
because they are generally used to display only one view, or views which overlap. The efficiency
of the frame layout makes it a good choice for screens containing few view controls (home
screens, game screens with a single canvas, and the like). Sometimes other inefficient layout
designs can be reduced to a frame layout design that is more efficient, while other times a more
specialized layout type is appropriate. Frame layouts are the normal layout of choice when you
want to overlap views.

Linear Layout
Linear layouts are one of the simplest and most common types of layouts used by Android
developers to organize controls within their user interfaces. The linear layout works much as its
name implies: it organizes controls linearly in either a vertical or horizontal fashion. When the
layout's orientation is set to vertical, all child controls within it are organized in a single column;
when the layout's orientation is set to horizontal, all child controls within it are organized in a
single row. Some of the most important attributes you'll use with linear layouts include:
● The orientation attribute (required), which can be set to vertical or horizontal.
● The gravity attribute (optional), which controls how all child controls are aligned and
displayed within the linear layout (class: LinearLayout).
● The layout_weight attribute (optional, applied to each child control) specifies each child
control's relative
● Importance within the parent linear layout (class: LinearLayout.LayoutParams).

Relative Layout
The relative layout works much as its name implies: it organizes controls relative to one another,
or to the parent control itself. It means that child controls, such as ImageView. TextView, and
Button controls, can be placed above, below, to the left or right, of one another. Child controls can
also be placed in relation to the parent (the relative layout container);

24
 including placement of controls aligned to the top, bottom, left or right edges of the layout. Some
specific attributes apply to relative layouts-namely the child rules, including:

● Rules for child control centering within the parent layout, including: center horizontally, center
vertically or both.
● Rules for child control alignment within the parent layout, including: align with top, bottom, left
or right
● edge of another control.
● Rules for child control alignment in relation to other child controls, including: align with top,
bottom, left or right edge.
● Rules for child control placement in relation to other child controls, including: placement to the
left or right of a specific control, or above or below another control.

Table Layout
A table layout is exactly what you might expect: a grid made up of rows and columns, where a cell
can display a view control. From a user interface design perspective, a TableLayout is comprised
of TableRow controls-one for each row in your table. The contents of a TableRow are simply the
view controls that will go in each “cell” of the table grid. Although table layouts can be used to
design entire user interfaces, they usually aren't the best tool for doing so, as they are derived from
LinearLayout and not the most efficient of layout controls. However, for data that is already in a
format suitable for a table, such as spreadsheet data, table layout may be a reasonable choice.

3.5.2 Different UI widgets available in Android

● Text View
● Edit Text
● List View
● Spinner
● Button
● Check Box
● Radio Button
● Scroll View

25
3.5.3 Menus
Options menu and action bar
The options menu is the primary collection of menu items for an activity. It's where you should
place actions that have a global impact on the app, such as "Search”, “Compose email", and
"Settings". On Android 3.0 and higher, items from the options menu are presented by the action
bar as a combination of on-screen action items and overflow options. Beginning with Android 3.0,
the Menu button is deprecated (some devices don't have one), so you should migrate toward using
the action bar to provide access to actions and other options.

Context Menu and Contextual Action Mode

A context menu is a floating menu that appears when the user performs a long-click on an
element. It provides actions that affect the selected content or context frame. A contextual menu
offers actions that affect a specific item or context frame in the UI. You can provide a context
menu for any view, but they are most often used for items in a ListView, GridView, or other view
collections in which the user can perform direct actions on each item.

Popup Menu
A popup menu displays a list of items in a vertical list that's anchored to the view that invoked the
menu. It's good for providing an overflow of actions that relate to specific content or to provide
options for a second part of a command.

3.5.4 Dialog Box

A dialog is a small window that prompts the user to make a decision or enter additional
information. A dialog does not fill the screen and is normally used for modal events that require
users to take an action before they can proceed.
3.5.4 Toast
A toast provides simple feedback about an operation in a small popup. It only fills the amount of
space required for the message and the current activity remains visible and interactive.
3.5.6 Adapters
An Adapter acts as a bridge between a ListView and the underlying data for that view. The
Adapter provides access to the data items. The Adapter is also responsible for making a View for
each item in the data set.

26
Array Adapter
Array Adapter is a concrete BaseAdapter that is backed by an array of arbitrary objects. By default
this class expects that the provided resource id references a single TextView. If you want to use a
more complex layout, use the constructor that also takes a field id. That field id should reference a
TextView in the larger layout resource.

3.6. Data Persistence

In Android app development, efficient data management is essential, and local databases play a
crucial role in this regard. The Room API is an integral part of the Android Architecture
Components and offers a powerful and convenient solution for working with SQLite databases
locally. This comprehensive guide explores the Room API, its components, and its best practices.

Introduction to Room API:

Room is an Android library that serves as an abstraction layer over SQLite, making it easier for
developers to work with local databases. It provides a high-level, object-oriented interface for
database operations, enabling the creation, modification, and management of database entities
with minimal boilerplate code.

Key Components of Room:

​ Entity: In Room, an entity is a class that represents a database table. Each entity typically
corresponds to a specific data type or model within the application. Annotations are used
to define entities, and the data members of the entity class become the columns of the
database table.’
​
​ Database: The database class is an abstract representation of the app's database. It serves
as the central access point for the application to access the underlying database. The Room
library automatically generates code for this class based on defined entities. It includes
methods for obtaining instances of DAOs (Data Access Objects).
​
​ DAO (Data Access Object): DAOs are interfaces or abstract classes that define the
database operations (e.g., insert, update, delete, and query) on the entities. Room generates

27
 the implementation of these interfaces at compile time, eliminating the need for manual
SQL queries.

Main Advantages of Room:

​ Type Safety: Room uses compile-time checks to ensure that SQL queries are accurate and
well-formed, reducing the likelihood of runtime errors and SQL injection vulnerabilities.
​ Convenience: It abstracts the low-level details of database operations, such as opening
connections, executing queries, and handling cursor operations, allowing developers to
focus on the application's logic.
​ Performance: Room's built-in mechanisms for threading and efficient querying make it
highly performant for database operations, improving the app's responsiveness.
​ Room Database Migrations: Room offers database migration support for schema
changes. Developers can define how the database schema should be modified when the
app is updated.

Best Practices for Using Room API:

​ Define Clear Data Model: Carefully design and define your entity classes to mirror the
data model of your application accurately. Use appropriate data types and annotations for
each field.
​ Use Background Threads: Perform database operations on background threads to prevent
blocking the main UI thread and ensure smooth user interactions.
​ LiveData and ViewModel: Consider using LiveData and ViewModel from the Android
Architecture Components in conjunction with Room to handle UI-related data and
maintain a lifecycle-aware connection between the UI and the data source.
​ Database Versioning: When making schema changes to your database, create migration
paths to preserve existing data and avoid data loss.
​ Indexes and Constraints: Use Room annotations to define database indexes and
constraints where necessary to enhance query performance and enforce data integrity.
​ Repository Pattern: Implement a repository layer to separate the data source from the rest
of the application, providing a clean and organized structure for database operations.

28
3.6 Integration of Networking and Web Services
In the realm of modern Android app development, the integration of networking and web services
is pivotal. This section delves into the core aspects of making HTTP requests and parsing data
from web services, essential skills for creating apps that connect to external resources and
leverage data from the web.
3.6.1 Making HTTP Requests
To interact with web services, you typically use the HTTP protocol to make requests and receive
responses. This is done through HTTP libraries or frameworks available in various programming
languages.
HTTP GET Request:
A GET request is used to retrieve data from a web service.

HTTP POST Request:

A POST request is used to send data to a web service, often used for creating or updating
resources.

29
3.6.2 Parsing Data from Web Services
In modern Android app development, parsing data from web services is a fundamental skill. It
involves fetching data from external sources, such as RESTful APIs, and converting it into usable
objects within your Kotlin-based Android application. This guide will walk you through the
process using the Retrofit library for networking and Kotlin for concise and expressive code.

Prerequisites

Before you dive into parsing data, ensure you have the following prerequisites in place:
● A Kotlin-based Android project.
● Retrofit library added to your project.

Define a Data Model

To parse data effectively, you need to create data models (POJOs - Plain Old Kotlin Objects) that
mirror the structure of the data you expect from the web service. Use Kotlin data classes to
represent these models. For example, if you are fetching data about movies from a RESTful API,
create a Movie data class with properties like title, releaseDate, and rating.

Create a Retrofit Interface

Define an interface that outlines the HTTP operations your app will perform. Specify the base
URL and create methods that represent the API endpoints. Use Retrofit annotations to define the
request type (GET, POST, etc.), the endpoint path, and query parameters. This interface acts as a
contract between your app and the web service.

30
Set Up Retrofit
Configure Retrofit to work with your API service. Create an instance of Retrofit, passing the base
URL and a converter (e.g., GsonConverterFactory for JSON parsing) that Retrofit should use to
parse the responses.

Make a Network Request

Use the Retrofit service you've created to make a network request to the web service. In this
example, we fetch a list of movies and parse the JSON response into a list of Movie objects.

31
3.7 Project
3.7.1 Project Description
Project Title: JalSanket - A Water-Hazard Reporting/Prevention App

Abstract:

To address the growing water-related challenges, we suggest the creation of a mobile app called
"जलSanket" (JalSanket) designed to empower community members in actively identifying and
reporting local water-related issues. This app leverages crowd participation to collect information
and reports on a wide range of water-related problems, including floods, water quality concerns in
ponds and lakes, urban flooding, and drainage issues. The collected data is geographically
referenced and visually presented on a map, encouraging community engagement and assisting
authorities in prioritizing and efficiently addressing water-related challenges.

Introduction:

Project Overview:
The application called “जलSanket” enables community members to crowdsource and report
water-related problems within their locality. The app will aggregate, visualize, and provide open
access to this data on a map, foster community engagement and help authorities prioritize and
address water-related issues effectively.

Objective:
The "जलSanket" (JalSanket) mobile app is designed with the objective of actively involving
community members in addressing pressing water-related challenges. It serves as a platform for
users to report and collect data on a wide array of issues, such as floods, water quality concerns,
urban flooding, and drainage problems, in a user-friendly and accessible manner. By harnessing
the collective wisdom of the community, the app assembles a comprehensive repository of
geographically referenced data, which is then visually presented on a map. In turn, this
information assists local authorities in efficiently prioritizing and addressing these water-related
challenges. Ultimately, the "जलSanket" app aims to enhance community engagement, promote
better water management, and contribute to the sustainable management of water resources for the
benefit of the entire community.

32
Features:

● User Registration & Authentication: Users can create a personalized profile

that will show them the common problems faced in their nearby areas
● Simplified Problem Reporting: Users can conveniently report water-related
issues on a click, streamlining the reporting process for swift resolution. They
can report various water-related issues, such as leaks, contamination, or
infrastructure damage.
● Dynamic Geospatial Visualization: The core feature of the app is an
interactive map that displays the active reported problems near the user's
current location. Each issue is represented as a marker on the map, and users
can click on a marker to view details.
● Support and notification alerts: Contacts will be displayed regarding
resolution of particular problems and Users can receive notifications about
updates on reported issues and solutions implemented.
● Alarming Authorities: Concerned Authorities are informed about the issue
as and when the Number of reporting by the community members cross a
certain threshold decided by an algorithm.
● Tracking Issues Around You: Users can monitor the Issues around them
using a Bottom sheet which displays all the Issues around a certain location.

33
Technical Architecture:

Frontend:
The UI development of the JalSanket application follows a modern and user-friendly

approach, incorporating various elements:

● Recycler View and Card View for Bottom Sheet: The use of a Recycler View in
the Bottom sheet provides a structured and organized visual representation of Issues
around the user. It allows users to view theses water related issues efficiently.
● Google Maps Activity: Home page uses Google Map API to interactively display
the issues on the map using a marker.
● XML for Layouts: XML (Extensible Markup Language) is used to define the
layouts of various app screens, ensuring a standardized, platform-independent
structure. It simplifies the management of UI components and their properties.
● Material 3 Guidelines and Components: The app adheres to the Material Design
3 guidelines, which provide a consistent and intuitive user interface. Material 3
components, such as buttons, cards, and navigation bars, create a unified and
visually appealing design.
● Custom Theming with Material Theme Builder: Custom theming using the
Material Theme Builder allows for personalized color schemes, typography, and
other design elements, giving the app a unique and branded appearance while still
adhering to Material Design principles.

This approach to UI development not only ensures a visually pleasing and user-friendly

interface but also enhances the user experience by providing clear navigation and intuitive

interaction. The use of Material Design guidelines and components contributes to a

cohesive and modern aesthetic, while custom theming allows for brand-specific design

elements and color schemes.

34
Backend:
The app's backend is built on a robust foundation, incorporating the following key
components:

● Room Library: Room is used as the local database library, offering an efficient and
convenient way to store, access, and manage data. It simplifies database
interactions, provides data integrity, and offers SQL abstraction for seamless
integration with the app.
● CNN Classification Model: The CNN model which classifies the water hazard into
categories is called using Retrofit.
● Data Access and Storage: The backend utilizes Room to access and store data in
the local database.
● Data Retrieval: Google Maps API and Camera API are called and ML model is
integrated using Retrofit library.
● Data Synchronization: The backend may also support data synchronization with
cloud services or other devices, enhancing data accessibility and security.

Overall, the backend of the app combines the power of the Room Library for local data
storage with the efficiency of Retrofit for making network calls for data retrieval. This
combination ensures a seamless user experience while maintaining the integrity and
security of the user's data.

35
User Experience:

1. Google Maps Activity:

The app offers an intuitive and visually appealing Google Maps Activity as the central
component of the user experience. In this view, Water-Hazard struck areas are marked on
the map using an interactive marker. Users can click on the marker to know more about the
situation and location of the issue. Key features include:

● Interactive Interface: Users can click on a marker to view the associated location
and more details for that issue.
● Efficient Navigation: Easy navigation around the map to view different locations .

2. Bottom Sheet Recycler View:

The Bottom Sheet Recycler View provides a comprehensive list of all the Issues users
have added to the app. This component is vital for users to track issues around them. Key
features include:

● Organization of Issues: All the issues are well organized and can be viewed
interactively using card view.

3. Authorization Page:

Users can Sign in to their respective accounts by entering their Name and Password to
retain their progress.

4. Problem Reporting:

The problem reporting screen includes a Problem title, Problem Description and Image of
the issue to be clicked. Key features include:

● Real-time Image Capturing: Users need to click live image of the problem which
helps us keep track of the location.

36
The app provides a holistic user experience, seamlessly integrating the calendar view for
scheduling spaced repetition, a notes list view for content management, an efficient note
editor, and a reminder notification system tailored to optimize memory retention. This
well-rounded experience empowers users to enhance their learning, memory recall, and
productivity effectively and conveniently.

Future Development:
The "JalSanket" app, with its focus on empowering communities to address water-related
challenges, has significant future scope and potential for expansion. Here are some areas
where "JalSanket" could evolve:

1. Global Expansion: "JalSanket" could be adapted for use in different regions and
countries, addressing local water-related challenges and providing a platform for
global water resource management.

2. Integration with IoT: By incorporating Internet of Things (IoT) technology,

"JalSanket" could collect real-time data from sensors placed in various
water-related infrastructure, enabling quicker response to issues like flooding and
water quality concerns.

3. Education and Awareness: Develop educational features within the app to raise
awareness about water conservation and sustainability, fostering responsible water
usage in communities.
4. Climate Adaptation: As climate change impacts water resources, "JalSanket"
could evolve to address climate adaptation strategies, such as flood preparedness
and drought mitigation.

37
 5. Gamification: Incorporate gamification elements to engage users in monitoring and
improving water resources in a fun and interactive manner.

6. Multi-Language Support: Expand language support to make the app accessible to

a broader user base.

7. Sentimental Analysis: Implement machine learning algorithms to analyze the

Problem description to deduce the severity of the issue.

8. Offline Functionality: Develop offline capabilities to ensure usability in areas with

limited connectivity.

The future scope for "JalSanket" is promising, as it can evolve to become a comprehensive
water resource management platform, addressing a wide range of water-related challenges
and fostering global and community-level water sustainability and resilience.

Conclusion:
In conclusion, "JalSanket" is not just an app; it represents a vision for more sustainable and
resilient communities in the face of water-related challenges. By harnessing the power of
technology and community participation, "JalSanket" empowers users to actively engage
in identifying, reporting, and collectively addressing water-related issues. Its potential for
the future is vast, with opportunities for global expansion, IoT integration, and advanced
analytics, ensuring its relevance in an ever-changing world. "JalSanket" serves as a
testament to the transformative impact of user-driven initiatives in addressing
environmental concerns, raising awareness, and fostering a sense of collective
responsibility. With its ongoing evolution and commitment to community collaboration,
"JalSanket" represents a vital tool in the journey towards better water resource
management, resilience, and sustainability.

38
4. Snapshots

39
40
5. Results and Discussions

The Android development course has been a transformative learning experience, equipping
participants with a comprehensive set of skills and knowledge to become proficient
Android developers. This chapter summarizes the key outcomes and insights gained during
the training, including the challenges and opportunities encountered.

5.1 Key Learning Outcomes:

● Programming Proficiency: Participants have acquired a solid foundation in
Kotlin, the primary programming languages for Android app development. This
proficiency extends to writing clean, efficient code and debugging.
● Android Studio Mastery: The course included in-depth training on using Android
Studio, the official Integrated Development Environment (IDE) for Android
development. Participants can comfortably navigate the IDE, create projects, and
manage resources.
● User Interface Design: Design principles and practices for creating user-friendly
and visually appealing app interfaces have been a central focus. Participants have
learned to create layouts, utilize widgets, and optimize UI/UX.
● Database Integration: The training covered database integration, with a particular
focus on Room API for local data storage. Participants can implement data storage
and retrieval within Android apps.
● Development Patterns: Understanding various development patterns, including
Model-View-Controller (MVC) and Model-View-ViewModel (MVVM), has been a
key component. Participants can apply these patterns to structure app architecture
effectively.
● API Integration: Participants have gained insights into integrating external APIs,
enabling apps to access data from web services and external sources.

41
5.2 Challenges and Opportunities:
● Version Compatibility: Adapting to the evolving Android platform and ensuring
compatibility with different Android versions is an ongoing challenge. Staying
up-to-date with the latest APIs and best practices is vital.
● User-Centric Design: Designing user interfaces that provide a seamless and
intuitive experience remains a priority. Continual attention to user feedback and
usability testing is essential.
● Testing and Debugging: Rigorous testing and debugging are essential for
delivering robust apps. The course has emphasized the importance of identifying
and resolving issues.

6. Conclusions and Future Scope

Conclusion

Learning Android development represents the beginning of a promising journey in the

dynamic field of mobile app development. This educational endeavor equips individuals
with the skills and knowledge required to create, innovate, and contribute to the
ever-expanding world of Android applications.
Android development courses provide a solid foundation in programming, design, and
mobile app architecture. Graduates emerge with the ability to bring ideas to life in the form
of user-friendly, functional, and visually appealing Android applications. These skills not
only open doors to exciting career opportunities but also empower individuals to create
innovative solutions that can benefit diverse user communities.
The journey of an Android developer doesn't end with the completion of a course; rather, it
marks the commencement of an exciting and ever-evolving career. Android development
offers a wealth of prospects and avenues for personal and professional growth, ensuring
that skills remain relevant and in-demand in the fast-paced tech industry.

42
Future Scope:

● Career Opportunities: Completing an Android development course opens the door

to various career paths, including mobile app development, game development,
UI/UX design, and full-stack development.
● Cross-Platform Development: Graduates can expand their skills into cross-platform
frameworks like Flutter or React Native, allowing them to develop apps for multiple
platforms with a single codebase.
● Specialization: Android developers can choose to specialize in areas such as
augmented reality (AR), virtual reality (VR), IoT, blockchain, or fintech, depending
on their interests and career goals.
● Entrepreneurship: Individuals can leverage their Android development skills to
start their own app development companies, create innovative startups, and bring
unique solutions to the market.
● Research and Development: Android developers can engage in R&D, staying at the
forefront of emerging technologies and trends, and contributing to the industry's
evolution.
● Community Building: In addition to developing apps, graduates can become active
contributors to the developer community by sharing knowledge, open-source
contributions, and mentorship.
● Continuous Learning: Given the ever-evolving nature of technology, Android
developers must commit to ongoing learning and skill enhancement to remain
competitive in the field.

43
7. Weekly Training Summary

Week What I Learnt Time Spent (in hrs.)

1 Basics of Kotlin and Android Studio 7 Hours

2 Basics of XMLand UI design, 10 Hours

coroutines

3 Retrofit and Room Db 13 Hours

4 Basics of Firebase 14 Hours

44
8. Learning after Training

1. Understanding the Android Stack:

a. Backend (Kotlin):
i. Building on your training, continue to deepen your proficiency in
back-end logic and services development, particularly in Kotlin. Stay
updated with the latest features and best practices in the language to
optimize your server-side code for Android apps.
b. Frontend (XML/Layouts):
i. Explore advanced techniques in designing interactive user interfaces
using XML layouts. Investigate custom view components,
animations, and responsive design principles to create highly
engaging and user-friendly interfaces that set your apps apart.
c. Database (SQLite):
Consider further mastering database design by delving into advanced
topics such as database optimization, query performance tuning, and the
use of third-party libraries like Room Persistence Library to simplify data
storage and retrieval tasks.

2. Data Management:
a. CRUD Operations:
i. Extend your proficiency in Create, Read, Update, and Delete (CRUD)
operations by optimizing database queries, implementing batch
processing, and understanding transaction management. These skills
are essential for efficient data management in complex applications.
b. Data Persistence:
i. Advance your skills in data persistence by exploring techniques such
as data synchronization across devices, implementing data encryption,
and using advanced caching strategies. This ensures that your app can

45
 effectively manage and store data in various scenarios, including
offline usage.

3. Authentication and Authorization:

a. User Authentication: Implemented secure user authentication using Firebase
b. Authorization: Proficient in role-based access control, ensuring appropriate
permissions for different user roles.

4. Frontend Interactivity:
a. UI Components: Understand Android UI components, including Activity and
Fragment lifecycles for dynamic rendering based on state changes.
b. User Input Handling: Proficient in handling user input, form validation, and
managing UI state for a seamless user experience.

5. Project Management:
a. Project Structure: Organized Android code into modular packages or
modules for improved code organization and maintainability.
b. Version Control: Utilized Git or other version control systems for
collaborative development and tracking changes.

6. Error Handling and Debugging:

a. Error Handling: Implemented error handling strategies, preventing crashes
and ensuring graceful degradation of the Android app.
b. Debugging Tools: Utilized Android Studio's debugging tools and logs for
efficient debugging.

46
7. References

1)Official Android Documentation: -

URL: https://developer.android.com/

2) Android Architecture Retrieved from

URL: https://tutorialspoint.com

3) Google APIs
URL: https://developers.google.com/android/guides/api-client

4) OpenAI. (2021). GPT-3.5 Documentation.

URL: https://beta.openai.com/docs/

47