Summer Industry Internship – I Report

ANDROID DEVELOPER VIRTUAL INTERNSHIP

During
III Year I Semester Summer

Submitted to
The Department of Information Technology
In partial fulfillment of the academic requirements of
Jawaharlal Nehru Technological University
For
The award of the degree
of Bachelor of
Technology
in
INFORMATION TECHNOLOGY

By

N AKSHAYA
SOWMIKA(22311A1265)
VOOTKURI AKSHARA(22311A1279)
CHARANI AETUKURI(22311A1267)

Name of Internship Co-Ordinator: Ms . Siva jyothi

Designation: Assistant Professor

Sreenidhi Institute of Science and Technology

Yamnampet, Ghatkesar, R.R. District, Hyderabad - 501301
 CERTIFICATE

This is to certify that this Summer Industry Internship W e Report i n Android Developer
Virtual Internship”, submitted by N.AKSHAYA SOWMIKA(22311A1265),VOOTKURI
AKSHARA(22311A1279),CHARANI AETUKURI(22311A1267) I n the year 2024 in partial
fulfillment of the academic requirements of Jawaharlal Nehru Technological University for the
award of the degree of Bachelor of Technology in Computer Science and E n g i n e e r i n g -
I T , is bonafide work in industry internship that has been carried out during III B Tech IT
Semester Summer, will be evaluated in III B Tech IT I Semester under guidance. This report has
not been submitted to any other institute university for the award of any degree.

Ms. SIVA JYOTHI Dr. SUNIL BHUTADA

Department of IT
Internship Coordinator Head of Department IT

External Examiner
Date:-
 DECLARATION

We, N.AKSHAYA SOWMIKA(22311A1265),VOOTKURI

AKSHARA(22311A1279),CHARANI
AETUKURI(22311A1267) students of SREENIDHI INSTITUTE OF
SCIENCE AND TECHNOLOGY, YAMNAMPET, GHATKESAR, studying III
year I semester, IT solemnly declare that the Summer Industry Internship-I Report, titled Android

Developer Virtual Internship” is submitted to SREENIDHI INSTITUTE OF SCIENCE AND

TECHNOLOGY for partial fulfillment for the award of degree of Bachelor of technology in

INFORMATION TECHNOLOGY

It is declared to the best of y o u r knowledge that the work reported does not form part of any
dissertation submitted to any other University or Institute for award of any degree

N. AKSHAYA SOWMIKA(22311A1265)
VOOTKURI AKSHARA(22311A1279)
CHARANI AETUKURI(22311A1267)
 ACKNOWLEDGEMENT

We would like to express my gratitude to all the people behind the s c r e e n who helped m to
transform an idea into a real application.

We would like to thank my Project coordinator MS siva jyothi for his technical guidance,
constant encouragement and support in carrying out my project at college.

We profoundly thank Dr. SUNIL BHUTADA Head of the Department of Computer Science &
Engineering –IOT who has been excellent guide and also great of inspiration to
my work.
We would like to express my heart-felt gratitude to my parents without whom I would not have
been privileged to achieve and fulfill my dreams. We are grateful to o u r principal, Dr. T. Ch.
Siva Reddy, who most ably the institution and has had the major hand in enabling to do my
project.
The satisfaction and euphoria that accompany the successful completion of the task would be
great but incomplete without the mention of the people who made it possible with their constant
guidance and encouragement o w n s all the efforts with success In this context, We would like
thank all the other staff members, both teaching and non-teaching, who have extended their
timely help and eased my task.

N.AKSHAYA SOWMIKA(22311A1265)
VOOTKURI AKSHARA(22311A1279)
CHARANI AETUKURI(22311A1267)
 ANDROID DEVELOPER VIRTUAL INTERNSHIP

Abstract

Android development involves creating applications for Android devices using Java or Kotlin
programming languages. During the of Android development, developers work with
Android Studio, which provides a comprehensive environment for building, testing, and
debugging apps. Android apps designed with interactive interfaces (UIs) that include
features like navigation, data display (using RecyclerView), and integration with web services
via APIs. Developers also work with local data storage options like SQLite and
SharedPreferences for persistent data storage. Additionally, Android development includes
handling background tasks using WorkManager, ensuring apps can continue operations ven
when the app is not actively running. Modern UI design is implemented using Material Design
for consistent and intuitive user experience across devices. With the introduction of Jetpack
Compose, Android development has shifted toward declarative UI design, enabling developers to
create apps faster with less code. This learning path helps developers acquire the skills needed to
build feature-rich, high-performance Android apps that provide seamless user experiences.
 INDEX

NAME PAGE

ABSTRACT i

1. INTRODUCTION 1-6

1.1 Overview of Android Development 1-2

1.2 Setting up Android Studio 2-3

1.3 Basics of Kotlin Programming 4-5

1.4 Building the First Android App 6

2. SYSTEM ANALYSIS 7-9

2.1 Understanding User Requirements 7

2.2 Technical Considerations 7

2.3 Potential Challenges and Solutions 9

3. SYSTEM DESIGN 10

4. SYSTEM IMPLEMENTATION 10-12

4.1 Interactive UI Components and Material Design 10

4.2 Fetching Data Using REST APIs 11

5. OUTPUT SCREENS 13-16

NAME PAGE

6. INTERNSHIP FEEDBACK 17

6.1 Challenges Faced 17

7. CONCLUSIONS AND FUTURE SCOPE 18

8. CAPSTONE PROJECT 19-20

9. BIBLIOGRAPHY 21

Appendix A: Abstract

Appendix B: Domain of Internship and Nature of Internship

1. INTRODUCTION

1. Overview of Android Development

Android development refers to the process of creating applications (apps) for devices running
the Android operating system. Android, developed by Google, is the most widely used mobile
operating system in the world, with billions of globally. Android development involves
writing code, designing user interfaces (UIs), integrating features, and testing apps on different
devices.
Why it's important:
1. Wide Reach: With the majority of smartphones running Android, developers an reach
massive audience, making Android development valuable skill for building apps that
cater to diverse users.
2. Open-source: Android is open-source, which developers modify and optimize
the operating system to suit their needs, leading to greater flexibility and customization.
3. Innovative and Dynamic Platform: Android continually evolves, introducing new
features, tools, and APIs, which allows developers to create cutting-edge, feature-rich
applications.

Eligibility
The internship is open to students, recent graduates, and professionals looking to
transition into Android development. Basic knowledge of programming concepts and
familiarity with Java or Kotlin is often required.

Role in creating mobile applications:

Android development plays crucial role in creating mobile applications by providing
structured environment where developers can build, test, and distribute their apps. Developers
tools like Android Studio, comprehensive integrated development environment (IDE), to
create apps that integrate with device hardware (like cameras, sensors), connect to the internet
(through APIs), store data (via databases), and background tasks. Android's open nature and
vast ecosystem of libraries, frameworks, and resources allow developers to create wide range
of apps, from simple utilities to complex, data-driven applications.

Management (IAM) policies and network security policies like security groups.

1
1.2 SETTING UP ANDROID STUDIO
Setting up Android Studio is the first step toward developing Android applications. Android
Studio is the official Integrated Development Environment (IDE) for Android development,
providing the tools and features needed to design, build, and test Android apps Here’s how you
can set up Android Studio:

Step 1: Download Android Studio

1. Go to the official Android Studio website
2. Click on the "Download Android Studio" button.
3. Select the appropriate version for your operating system (Windows, macOS, or Linux).
4. Once the file is downloaded, run the installer.

Step 2: Install Android Studio

1. For Windows:
Run the downloaded file.
Follow the installation wizard to install Android Studio. It will also install the
Android SDK (Software Development Kit) and Android Virtual Device (AVD)
for testing apps.
2. For macOS:
Open the downloaded dmg file and drag Android Studio to the Applications
folder.
Follow the prompts to install the necessary components.
3. For Linux:
Extract the zip file and move the folder to an appropriate location.
Open a terminal and run studio.sh to start Android Studio.

Step 3: First Launch of Android Studio

1. After installation, launch Android Studio.
2. On the first launch, Android Studio will guide you through setting up the IDE, including
downloading any additional necessary components like the Android SDK, emulators, and
build tools.
3. Android Studio will check for system requirements and make ur everything is installed
properly. This can take some time, depending on your internet connection speed.

Step 4: Configure the Android SDK and Emulator

1. Android Studio will prompt you to install the Android SDK and setup the Android
Emulator. These tools are essential for building and testing your apps.
2. Make ure you download the necessary SDK packages for the Android versions you
wish to target.
3. You can also set up n Android Virtual Device (AVD) to test your apps without needing
physical device. This can be done through the AVD Manager within Android Studio.

2
Step 5: Create a New Project
1. Once Android Studio is installed and set up, you can start by creating a new project.
2. Select "Start a new Android Studio project"
3. Choose a project template (e.g., Empty Activity, Basic Activity).
4. Name your project, select the language (Java Kotlin), and choose the minimum API
level you want to support.
5. Click "Finish", and Android Studio will create the project and open the workspace.

Step 6: Test the Setup

1. Once your project is created, click the Run button (a green triangle) in Android Studio.
2. You will be asked to choose an emulator or connect a physical device to run your app.
3. If everything is set up correctly, your app will compile and run n the selected
device/emulator.

Step 7: Install Updates

Occasionally, Android Studio releases updates. Make ure to check for updates regularly
to keep your development environment up-to-date.

3
3. BASICS OF KOTLIN PROGRAMMING
Kotlin is modern, statically-typed programming language that run on the Java Virtual Machine
(JVM) and is used for Android development. Kotlin is known for being concise, expressive, and
interoperable with Java, making it great choice for developing Android applications. Here are
the fundamental concepts you should understand when starting with Kotlin programming:

1.3.1 Variables and Data Types

Kotlin provides two types of variables: mutable and immutable

Mutable variables can be changed after initialization. They re declared using the
keyword.
Immutable variables cannot be changed assigned. They declared using the val
keyword.
Kotlin has a variety of data types such as:
Integers Int Long
Floating point numbers Float Double
Boolean Boolean
Characters Char
Strings String

1.3.2 Functions

In Kotlin, functions declared using the fun keyword. You define functions that take
parameters and return values.

Figure

4
1.3.3 Control Flow: Conditional Statements
Kotlin supports the typical control flow structures such as if else when, and loops.

Figure 1.3.3.1

1.3.4 Loops
Kotlin supports several looping structures:

while loop:

Figure 1.3.4.1

for loop:

Figure
1.3.4.2
1.4 Building the First Android App
In this section,we create very first Android app, which will display simple message the
screen
1. Create a New Project Open Android Studio click "Start Android Studio
project," and select "Empty Activity." Give your app name and choose Kotlin s the
language.
2. Understand the Project: Your project will have two main parts:
MainActivity: The code that controls the app’s behavior.
activity_main.xml: The design or layout of your app.
3. Design the UI In the layout file you’ll add a text element (called a TextView) that
shows the message on the screen.
4. Add Functionality You will change the message in your app by writing code in
MainActivity. When the app runs, it will show your message on the screen.
5. Run the App You test your app either emulator (virtual phone) real
Android device by connecting it to your computer.
Now you’ve created basic Android app! You try adding features like buttons extra
screens as you continue learning.

6
2 SYSTEM ANALYSIS
System analysis helps identify the needs of users, address technical requirements, and
the app aligns with the overall goals of the project. It includes assessing user requirements,
selecting appropriate technologies, and analyzing potential challenges. The goal is to create
system that is both functional and efficient, while considering future scalability and
performance.

1. User and Functional Requirements

Understanding the target audience is the first step in system analysis. Every app is designed with
a specific user in mind, whether they r students, professionals, or general onsumers For
example, app built for students may require features like quick to study materials and
easy navigation, while fitness app might focus on tracking workouts and providing
motivational notifications. In defining functionalities, the system must deliver what
expect, such fetching weather data, providing real-time updates, showing relevant
information. Ensuring the app meets these functional requirements guarantees user satisfaction.
Furthermore, experience (UX) goals play key role in defining how the app interacts with
users A good app nsure that the interface is intuitive, visually engaging, and easily navigable.
For example, clear fonts, simplified menus, and smooth flow from ne screen to another make
the app user-friendly. User preferences, such accessibility options like larger text voice
commands, must also be considered to ensure inclusivity. Thus, user and functional requirements
are essential to determine how the app will perform and meet users' needs.

2. Technical Considerations
In developing any app, choosing the right technology stack is crucial. Android Studio, the
official IDE for Android development, provides all the tools required to build, test, and debug n
app Kotlin, modern programming language for Android, is preferred due to its simplicity and
full compatibility with Android’s development environment. Libraries like Retrofit r Volley re
commonly used to handle network operations such a fetching data from REST APIs, while
Room be used for local data storage. These technologies the app is efficient and
supports all necessary features like network communication, data persistence, and UI updates.
Another important consideration is ensuring the app works smoothly different devices and
screen sizes. Android’s fragmented ecosystem requires developers to account for various
versions of Android OS, from the latest releases to older nes The app should be optimized for
different sizes, ensuring that it looks good range of devices, from large tablets to
small smartphones. Compatibility testing is essential to catch issues like UI distortion or
unresponsive features specific devices. Efficient handling of various densities and
resolutions ensures a consistent user experience across the Android ecosystem.

7
2.3 Potential Challenges and Solutions
Every app development project faces its et of challenges, and understanding these challenges
early in the process can help address them before they become major roadblocks. One common
challenge when building apps that rely APIs is handling network and connectivity issues.
Users might experience slow internet speeds r no internet connection at all. To mitigate this,
developers can implement caching mechanisms r design the app to function offline in certain
situations, ensuring that still have to basic features without stable internet
connection.
Security and data privacy also critical in modern app development. Storing data securely
is paramount, especially when dealing with sensitive information such a login credentials,
payment details, r personal preferences. Developers should use encryption techniques and
storage options like Android’s Keystore to protect data both at rest and in transit. Proper
handling of sensitive data not only nsures user trust but also helps meet regulatory requirements
such as GDPR
Another challenge is optimizing the app to work efficiently on all devices, considering
limitations like battery life and memory. Mobile devices have limited resource compared to
desktops, apps must be designed to be resource-efficient. Using background services
sparingly, optimizing image sizes, and minimizing memory usage can help prevent performance
issues Additionally, testing the app lower-end devices that it remains functional
with limited hardware capabilities. By addressing these challenges, developers an create more
robust and user-friendly app.

2.4 Future Growth and Scalability

When developing system, it’s essential to consider future growth and scalability. While the
initial version of the app may meet current user requirements, it is important to plan for future
updates and potential feature expansions. For example, if the app starts with limited set of
features, developers should design the system architecture to be flexible, making it easier to add
new functionalities without overhauling the entire codebase. Scalability is especially important
for apps that may experience growth in numbers data volume, such social media
e-commerce apps. Using cloud services for backend support and considering load balancing
techniques ensures that the app can handle increasing traffic and data demands.
Moreover, developers should keep n eye on emerging technologies and trends. For instance,
integrating AI for personalized recommendations or using AR (Augmented Reality) for
enhanced experiences could be potential future features for app. Keeping the app
architecture modular allows developers to adopt new technologies and tools s they become
available, ensuring that the app remains competitive in the fast-evolving mobile market. Planning
for scalability not only improves the user experience but also provides roadmap for future
growth and innovation.

8
3. SYSTEM DESIGN
System design in Android app development is the process of outlining the app's architecture,
ensuring it meets both functional and non-functional requirements. It involves determining how
different components of the system interact with each other, the structure of data storage, and
how the app communicates with external services. A well-designed system nsures scalability,
maintainability, and the overall user experience
.The first aspect of system design is determining the architecture of the app Android
applications generally follow a Model-View-ViewModel (MVVM) or Model-View-
Presenter (MVP) architecture. MVVM allows for the separation of by
decoupling the interface from the business logic,
making the code easier to manage and test The view is responsible for displaying the user
interface, while the model handles data operations. The ViewModel erves a a middle layer,
managing UI-related data.
Database design plays a key role in system design, especially when the app needs to store and
retrieve data. For persistent storage, apps local databases like SQLite cloud-based
databases like Firebase. SQLite is ideal for storing structured data, while Firebase is mor
suitable for real-time data syncing and cloud storage. The design of the database should align
with the app's data requirements, considering factors like data volume, query complexity, and
offline functionality.Another essential element of system design is how data flows through the
app When designing data flow, developers must consider how the app handles requests and
responses The app may interact with remote ervers r APIs to fetch data, and this data must be
displayed in the user interface in a meaningful way. Data should be efficiently managed, with
proper handling and fallback mechanisms to that the app remains responsive,
under poor network conditions.
User Interface (UI) design is fundamental aspect of system design that directly impacts the
experience. UI design focuses on creating smooth, intuitive, and visually appealing
experience for the user It involves deciding the layout, navigation structure, and interactive
components. To maintain consistency and usability different devices,
developers implement Material Design principles, which provide a unified design
language for Android apps.To ensure the app performs well various devices
and sizes, the system design must account for responsiveness.
Android supports variety of creen sizes, resolutions, and orientations, s the app’s UI
should be adaptive. Using techniques like ConstraintLayout and supporting multiple screen
densities ensures that the app looks great on phones, tablets, and even foldable devices.
Finally, security and privacy considerations are integral to system design. Developers must
that sensitive data is securely stored and transmitted. This involves encrypting sensitive
data, implementing ecur communication protocols like HTTPS, and handling user
authentication securely. Following security best practices nsures that user data remains safe and
builds trust in the app.

9
4. SYSTEM IMPLEMENTATION
In this section, we will explore the implementation of key features for building a fully
functional Android app.

1. Interactive UI Components and Material Design

Material Design is a design language developed by Google to help developers create visually
consistent and user-friendly interfaces. It focuses simplicity, interactivity, and responsiveness,
ensuring that apps not only look modern but also function seamlessly different devices.
By adopting Material Design principles, developers an craft apps that are both aesthetically
pleasing and highly usable.
Interactive UI components re at the heart of Material Design. These components enhance user
engagement by providing intuitive and responsive elements. For instance, Buttons (like raised,
flat, toggle buttons) used to perform actions, while Text Fields make it easy for to
input data. The Floating Action Button (FAB) a prominent circular button, often highlights the
app's primary action. Similarly, CardViews perfect for displaying content in organized
and visually appealing way, especially in lists r grids. Navigation Drawers simplify app
navigation by offering sliding menu and Snackbars provide users with brief messages or
action options at the bottom of the screen.
To implement Material Design, Android offers a comprehensive set of tools and libraries.
Developers apply predefined themes and styles to consistent typography, color
schemes, and layouts the app Components like MaterialButton and
TextInputLayout come prebuilt, making development faster and easier. Additionally,
subtle animations can be added to transitions and user interactions, providing a polished and
professional touch.
Material Design not only improves the app's visual appeal but also enhances the user experience
by making the app intuitive and easy to navigate. By adopting this design language, developers
their apps remain modern, engaging, and consistent different platforms, ultimately
delivering greater satisfaction to users.

1
4.2 Fetching Data Using REST APIs
Fetching data from the internet is fundamental feature of many modern mobile applications.
REST (Representational State Transfer) APIs enable communication between the app and
remote to retrieve send data. They allow developers to and integrate
live, dynamic data
into their apps, making them more interactive and functional.
To fetch data, apps send HTTP requests (GET, POST, PUT, DELETE) to the erver A GET
request is commonly used to retrieve data, such profiles, articles, product
information. Servers respond with structured data, usually in JSON (JavaScript Object
Notation) or XML format, which the app processes and displays.
Libraries like Retrofit r Volley are widely used to handle network operations in Android apps.
Retrofit simplifies making API calls by converting JSON data directly into Kotlin r Java objects
using data models. It also supports authentication, handling, and efficient network usage.
Volley, on the other hand, provides features for managing multiple requests, caching, and image
loading, making it suitable for smaller apps.
Error handling is critical aspect of fetching data. Internet connectivity issues, server downtime,
or malformed requests can result in errors Proper implementation nsure the app gracefully
informs users when something goes wrong and retries operations if necessary.
Incorporating REST APIs in your app allows for dynamic content updates, enabling features
like real-time feeds, weather updates, and social media interactions. As result, get
more engaging experience with up-to-date information tailored to their needs.
Some APIs require authentication for secure ccess Methods like API keys OAuth tokens or
Bearer tokens often used. For example, social media apps might OAuth to fetch
data securely from platforms like Facebook or Google.

1
4.3 Data Persistence with SQLite and Shared Preferences
Data persistence is essential in app development to that important information is retained,
even when the app is closed or the device is restarted. Android provides two primary tools for
local data storage: SQLite and Shared Preferences.

SQLite
SQLite is lightweight, built-in database engine for Android. It allows developers to store
structured data in tables and perform operations like inserting, updating, and querying data using
SQL commands. For example, a contacts app an use SQLite to store names, phone numbers,
and email addresses in database. SQLite is ideal for managing relational data, making it perfect
for apps that require complex data handling.
Android also offers libraries like Room, n abstraction layer over SQLite, to make database
operations simpler and safer. Room reduces boilerplate code and provides compile-time checks
for SQL queries.
Shared Preferences
Shared Preferences is simpler storage solution for saving small amounts of data, such a user
settings or app preferences. It stores data s key-value pairs. For instance, a music app can use
Shared Preferences to the user's preferred theme (dark light mode) the last played
song
Shared Preferences is lightweight and easy to use but it’s not designed for complex
large-scale data storage. It’s best suited for storing settings, flags, or small data points.

Why Data Persistence Matters

By implementing SQLite
example: Shared Preferences, your app enhance experience. For

SQLite that structured data, like to-do

lists easily retrievable. profiles, is securely stored and
Shared Preferences allows your app to remember user settings, offering a personalized
experience.
These tools ensure that your app functions seamlessly and retains critical information across
sessions.

1
5. OUTPUT SCREENS

Step 1:
Create New Android Project Open Android Studio and create new project. Choose an
empty activity template and set the project name to “WeatherApp”. Click “Finish” to create the
project.

Step 2:
Set Up UI Layout In the res/layout/activity_main.xml file, design a simple layout
with TextViews and ImageView to display weather information. For example:

Figure 5.1

1
Step 3:
To get the API key simply sign-in on Open Weather

Figure 5.2

After signing in, you can find your API key.

Figure 5.3

1
Step 4:
Create Weather Data Model Create data class for holding the weather information In the
MainActivity.kt file:

Figure 5.4

Step 5:
Implement Retrofit Service Create Retrofit service interface to define the API calls. In the
WeatherService.kt file:

Figure 5.5
1
Step 6:
Fetch Data in MainActivity In the MainActivity.kt file, implement the logic to fetch
weather data

Step 7:
Run the App Replace “YOUR_OPENWEATHERMAP_API_KEY” with your actual API key.
Build and run the app on an emulator or a physical device.

Figure 5.6

1
 6. INTERNSHIP FEEDBACK

1. Challenges Faced
During the internship, We encountered several challenges that tested my problem-solving skills
and ability to adapt to new technologies. One of the key difficulties was managing time
effectively while performing the lab activities While the guided labs provided structured
learning path, balancing the lab activities with my other commitments required careful planning
and focus. Despite the time constraints, We was able to stay on track and complete each task
successfully.

Another challenge We faced was the steep learning curve when using s o m e of the more
advanced Android development tools. While the initial labs were manageable, We found myself
struggling with s o m e of the more complex tasks that required integrating multiple components
or troubleshooting However, these challenges pushed to dig deeper into the documentation and
seek help from peers and mentors, which helped build stronger understanding of the concepts.

Finally, performing the compact and challenging labs required attention to detail and deeper
understanding of Android development concepts. W e found that om tasks were more
time-consuming than We initially anticipated, especially when working with APIs and
integrating external libraries. Nonetheless, these challenges were valuable learning experiences

that helped enhance my skills and gain confidence in my ability to work with Android
development tools.

1
7. CONCLUSION AND FUTURE SCOPE
The Android app development process involves multiple stages, from setting up the development
environment to building user interfaces, fetching data from the internet, and ensuring data
persistence. By learning and implementing concepts like Material Design REST APIs and
local storage with SQLite and Shared Preferences developers can create interactive, efficient,
and user-friendly apps. Throughout this journey, key skills such working with UI
components handling background tasks and ensuring the app works well on multiple devices
are crucial. The knowledge gained during the development process an be applied to create
wide range of apps, from simple utilities to more complex, feature-rich applications.

Future Scope:
The future of Android development is vast, with continuous updates and advancements in the
platform. Some potential directions for future development include:
Integration of AI and Machine Learning Android apps be enhanced with artificial
intelligence and machine learning, enabling features like image recognition, personalized
recommendations, and voice assistants.
IoT (Internet of Things) With the rise of connected devices, Android apps be
developed to interact with IoT devices, making everyday objects smarter.
Cross-Platform Development Tools like Flutter and React Native allow developers to
write code onc and deploy it n both Android and iOS, broadening the scope of app
development.
Improved User Experience with AR/VR As augmented reality (AR) and virtual reality
(VR) technologies evolve, Android apps will incorporate more immersive experiences.
By continuing to explore technologies and trends, Android developers stay ahead of
the curve and create even more powerful and innovative apps in the future.

1
8. CAPSTONE PROJECT
1. Introduction
The Weather App is Android application designed to fetch and display the current weather
for given city. This project utilizes Kotlin for development, and integrates the
OpenWeatherMap API to retrieve weather data. The app allows users to input a city name,
click a button, and see
the weather details such as temperature, humidity, and weather description in real-time.

2. Objectives
Learn how to integrate third-party APIs (OpenWeatherMap).
Gain practical experience in designing simple Android UIs with Material Design.
Implement basic Android concepts like networking, UI updates, and user input handling.
Practice working with JSON data and parsing it in Android.

3. Features
City Input: Users can enter the name of any city.
Weather Data: Upon clicking the "Get Weather" button, the app fetches and displays the
current weather for that city, including:
Temperature (in Celsius)
Weather description (e.g., "Clear", "Rain")
Humidity level
Atmospheric pressure
Real-Time Data: Fetches data in real-time from the OpenWeatherMap API.

4. Technology Stack
Kotlin: Main programming language used for Android development.
Android Studio: IDE for developing the Android app.
OpenWeatherMap API: Provides real-time weather data.
JSON: Data format used to exchange information between the app and the weather API.

5. Implementation Steps
1. Setting Up the Project:
Create a new Android project in Android Studio.
Add necessary dependencies like Retrofit for network operations in the
build.gradle file.
2. UI Design:
A simple user interface is created using XML for the layout:
1
 EditText: To take user input for the city name.
Button: To trigger the API call and fetch the weather.
TextView: To display the weather information.
3. Network Communication:
Retrofit is used to send HTTP requests to the OpenWeatherMap API.
The WeatherService interface is created to define the endpoint and query
parameters (city name and API key).
4. Parsing the Response:
The JSON response from the OpenWeatherMap API is mapped into data classes
in Kotlin.
The response includes the temperature, humidity, and description, which
displayed in the TextView after the data is retrieved.
5. Displaying the Data:
Once the weather data is fetched successfully, it is shown in the TextView the
main screen.
Error handling is implemented for situations where the city is invalid
there is no internet connection.

2
9. BIBLIOGRAPHY

1. Udacity’s Android Developer (by Google): A guided learning path

2. Medium Articles on Android Development: A collection of developer-written blogs
3. developer.android.com
4. kotlinlang.org
5. m3.material.io/
6. developer.android.com/jetpack
7. stackoverflow.com
8. codelabs.developers.google.com