REALTIME WEATHER

PROJECT REPORT

Submitted By:
Manish Kumar
Roll No: 22RU311028
B.Tech CSE (3rd Year)

Submitted To:
Dr. Rajendra Singh Khatana

Date: 06 May 2025

CERTIFICATE
This is to certify that the project report entitled “REALTIME WEATHER” has been
carried out by Manish Kumar, Roll No: 22RU311028, B.Tech in Computer Science &
Engineering at Raffles University during the academic session 2024–2025, under my
supervision.

Dr. Rajendra Singh Khatana

Project Supervisor
Raffles University
DECLARATION
I hereby declare that the project work entitled “REALTIME WEATHER” submitted to
Raffles University is a record of an original work done by me under the guidance of Dr.
Rajendra Singh Khatana and this project work has not been submitted elsewhere for any
other degree or diploma.

Manish Kumar
22RU311028
ACKNOWLEDGMENT
I take this opportunity to express my deep sense of gratitude to my project guide Dr.
Rajendra Singh Khatana for his invaluable guidance, continuous encouragement, and
support throughout the course of this project.

I would also like to thank the faculty members of the Department of Computer Science &
Engineering at Raffles University for their cooperation and support.

Manish Kumar
ABSTRACT
The RealTimeWeather Android application provides users with current weather
information based on their location. It retrieves real-time data using the
OpenWeatherMap API and presents it in a user-friendly interface. Built using Kotlin and
the MVVM architecture, this project demonstrates effective use of networking,
permissions, and data binding in Android development.
Table of Contents

1. Introduction
1.1 Overview
1.2 Objectives
1.3 Scope of the Project

2. System Design
2.1 System Architecture
2.2 UML Diagrams
2.2.1 Use Case Diagram
2.2.2 Class Diagram
2.2.3 Activity Diagram

3. Technology Stack
3.1 Android Studio
3.2 Kotlin
3.3 RESTful APIs
3.4 OpenWeatherMap API

4. Implementation
4.1 Application Modules
4.2 Code Snippets
4.3 GitHub Repository Overview

5. User Interface Design

5.1 UI Screenshots
5.2 UI/UX Considerations

6. Testing
6.1 Testing Strategies
6.2 Test Cases
6.3 Results

7. Results and Discussion

7.1 App Performance
7.2 Limitations

8. Future Enhancements

9. Conclusion
1. INTRODUCTION

1.1 Overview

Discuss what the project is about. Explain the need for weather apps, their usage in daily
life, and how your app addresses this need.

1.2 Objectives

List the main goals of the project. Example:

• Display real-time weather data

• Fetch location-based forecasts

• Provide a clean and responsive user interface

1.3 Scope of the Project

Clarify what your app can and cannot do.

Define the limitations, e.g., only current weather, no historical data, or support limited to
Android devices.
2. System Design

2.1 System Architecture

Describe the overall structure of your app. For example:

• The app fetches data from the OpenWeatherMap API

• Parses the JSON response

• Displays results in UI components

• May use MVVM or MVP architecture for code separation

2.2 UML Diagrams

• 2.2.1 Use Case Diagram: Shows the interaction between the user and the app—
like entering a city name, fetching weather, displaying data.

• 2.2.2 Class Diagram: Represents the different classes used (e.g., MainActivity,
WeatherService, WeatherDataModel) and their relationships.

• 2.2.3 Activity Diagram: Illustrates the flow of activities—app launch, location

permission, data request, and UI update.
3. Technology Stack

3.1 Android Studio

The development environment used to build, test, and deploy the Android application.

3.2 Kotlin

The primary language for development. Briefly mention benefits like null safety, concise
syntax, and full Android support.

3.3 RESTful APIs

Explain how REST is used to send requests and receive JSON weather data. Cover HTTP
methods (like GET) and endpoints.

3.4 OpenWeatherMap API

A third-party API used to retrieve weather data based on city name or GPS coordinates.
Mention API key usage and sample endpoints.
4. Implementation

4.1 Application Modules

In this subsection, you explain how your app is organized into different logical
components or layers.

a) UI Layer

Handles the user interface and interaction logic. Includes:

• MainActivity.kt or WeatherActivity.kt

This is the main Kotlin file responsible for:

• Launching the app

• Initializing the UI
• Capturing user input (like typing a city)
• Handling button clicks (e.g., "Search" or "Get Weather")
• Triggering data fetch from the API
• Updating UI elements (temperature, humidity, weather icons)
 • XML layout files (activity_main.xml, weather_card.xml)

activity_main.xml
This file defines the structure of your main screen using views like:

• EditText for city input

• Button to trigger weather fetch

• TextView to show weather data

• ImageView to show weather icons

• Handles click listeners, input fields (e.g., for city name), and updates views with
weather info

The activity file (MainActivity.kt) links to the layout file and uses either:

• findViewById() (basic way)

• or View Binding (modern, safer way) to reference UI components

b) Network Layer

Manages all API-related functionality. You likely use:

• Retrofit or Volley library to send HTTP requests

• A service interface like WeatherApiService.kt defining endpoints

• A repository class to manage the data flow between network and UI

c) Data Layer (Models)

Contains data classes that map to the JSON response from the API.
4.2 Code Snippets

This subsection gives a walkthrough of the key functional code with explanations.
Include only relevant and concise code blocks. For example:

a) API Call Setup using Retrofit

b) Fetching Weather Data

Dependencies Used

Ensure these are in app/build.gradle:

Retrofit API Service

WeatherApiService.kt:
5. User Interface Design

5.1 UI Screenshots

a) Home Screen / Weather Search Screen

Screenshot: Show the screen where users enter a city name.

Description:

• A simple text field for user input

• A "Search" button to trigger weather fetching

 • May include a loading animation or message if the network request is ongoing

b) Weather Result Screen

Description:

• Shows weather condition (e.g., "Cloudy", "Sunny")

• Temperature (in Celsius or Fahrenheit)

• Additional details like humidity, wind speed, etc.

• Icons or background colour that change with weather condition (optional)

c) Error Screen or Toast Messages

Description:

• Error messages for invalid city names

• “No Internet Connection” alerts

• Toasts or Snackbars providing user feedback

6. Testing

Testing is crucial to ensure your app works reliably in real-world scenarios. It includes
planned test cases, user behavior simulation, and error handling.

6.1 Testing Strategies

You likely used manual testing, which means running the app on an emulator or real
device to verify different user actions like:

• Entering valid/invalid city names

• Using the app with and without internet

• Testing behavior when location permissions are denied

6.2 Test Cases

Document several test scenarios. For each:

• Define the test case ID

• Describe the input

• State the expected output

• Note the actual result

• Mark it Pass/Fail
6.3 Results

Summarize overall testing:

• App functioned well under different network and user input conditions.

• Minor bugs (if any) were resolved.

• Weather updates were fast and accurate.

• UI was responsive and consistent on different screen sizes.

7. Results and Discussion

This section presents how well your app performed and what can be inferred from the
testing phase.

7.1 App Performance

• Speed: Data fetching from OpenWeatherMap API was fast (within 2–3 seconds).

• Accuracy: The weather information matched real-world data from other sources.

• Responsiveness: UI elements updated quickly and smoothly.

• Compatibility: The app worked well on various Android devices and screen
sizes.
7.2 Limitations

Even though the app works well, every project has its limits:

• No offline access: Weather data requires a live internet connection.

• Single-city forecast: Doesn’t support weekly or hourly forecasts.

• Limited error messages: Could be improved with detailed explanations.

• No notification or alert system: Weather alerts not integrated yet.

• Dependence on third-party API: Limited by OpenWeatherMap's free tier (call

limits, data resolution).
8. Future Enhancements

These are features or improvements you plan or suggest to add in future versions of the
app:

• Weather Alerts/Notifications
Push alerts for extreme weather conditions using background services.

• Voice Search
Let users speak the city name instead of typing.

• Themes (Dark Mode/Light Mode)

Support for light and dark themes for better user experience.

• Multiple City Support

Allow tracking of weather in multiple locations.

• Widget Support
Add a home screen widget to show current temperature.
• Weekly or Hourly Forecasts
Add support for upcoming weather trends using extended API features.

• Offline Mode
Cache the last successful weather response for offline display.

• Multi-Language Support
9.Conclusion

Summarize what was accomplished and your personal or team learnings:

• The project successfully delivered a fully functional weather app using Kotlin
and OpenWeatherMap API.

• It met its key goals: fetching real-time weather, displaying it in a clean UI, and
handling basic user interactions.

• The development process improved your understanding of:

o API integration in Android

o UI/UX design

o Working with permissions and network operations

• While there are still areas to enhance, the app serves as a solid foundation for
future weather-based features.