A Summer Industry Internship – II Report

On

GOOGLE ANDROID DEVELOPER

during
IV 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
G. SAI SHASHI VARAN 22311A1299
G. M. ROHAN GOUD 22311A1287
S. VINAY KARTHIK 22311A12A6

Sreenidhi Institute of Science and Technology

Yamnampet, Ghatkesar, R.R. District, Hyderabad - 501301
An Autonomous Institution

Affiliated to

Jawaharlal Nehru Technology University

Hyderabad - 500085
 Department of Information Technology

DEPARTMENT OF INFORMATION TECHNOLOGY

SREENIDHI INSTITUTE OF SCIENCE AND TECHNOLOGY
(An Autonomous Institution)
(Affiliated to JNT University; ISO Certified 9001:2000)
Yamnampet, Ghatkesar, Hyderabad-501301
Ph.Nos : 08415-200597, 08415-325444, 9395533303

CERTIFICATE
This is to certify that the Dissertation entitled “GOOGLE ANDROID DEVELOPER” is
bonafide workdone and submitted by G. Sai Shashi Varan (22311A1299), G. M. Rohan
Goud (22311A1287), S. Vinay Karthik (22311A12A6) , in partial fulfillment of the requirement
for the award of Degree of Bachelor of Technology in Information Technology, SREENIDHI
INSTITUTE OF SCIENCE AND TECHNOLOGY, Affiliated to Jawaharlal Nehru
Technological University, Hyderabad is a record of bonafide work carried out by us under the
guidance and supervision.

The results presented in this dissertation have been verified and are found to be satisfactory. The
results embodied in this dissertation have not been submitted to any other university for the award
of any other degree or diploma.

Internship Internal Guide Internship Coordinator Head of the Department

Mrs. C. Sarika Dr. P. N. Siva Jyothi Dr. SUNIL BHUTADA
Associate professor Associate Professor Professor

External Examiner
Date:-
 DECLARATION

We, G. Sai Shashi Varan (22311A1299), G. M. Rohan Goud (22311A1287), S. Vinay Karthik
(22311A12A6), students of SREENIDHI INSTITUTE OF SCIENCE AND
TECHNOLOGY, YAMNAMPET, GHATKESAR, studying IV year I semester,
INFORMATION TECHNOLOGY solemnly declare that the Summer Industry Internship-II
Report, titled “GOOGLE ANDROID DEVELOPER” 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 our knowledge that the work reported does not form part of
any dissertation submitted to any other University or Institute for award of any degree.

G. Sai Shashi Varan(22311A1299)

G. M. Rohan Goud(22311A1287)

S. Vinay Karthik (22311A12A6)

 ACKNOWLEDGEMENT

I would like to express my gratitude to all the people behind the screen who helped me to
transform an idea into a real application. I would like to thank my Internship coordinator Dr. P.
N. Siva Jyothi mam, for their technical guidance, constant encouragement and support in
carrying out my project at college.

I profoundly thank Dr. Sunil Bhutada sir, Head of the Department of Information Technology
who has been an excellent guide and also a great source of inspiration to my work.

I 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. I am grateful to our principal, Dr. T. Ch.
Siva Reddy, who most ably run the institution and has had the major hand in enabling me 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 crowns all the efforts with success. In this context, I would like
thank all the other staff members, both teaching and non-teaching, who have extended their
timely help and eased my task.

G. Sai Shashi Varan(22311A1299)

G. M. Rohan Goud(22311A1287)

S. Vinay Karthik (22311A12A6)

 GOOGLE ANDROID DEVELOPER

ABSTRACT

The Google Android Developer Course project is designed to equip learners with the
essential skills required to build, deploy, and maintain robust Android applications.
This project-based learning experience focuses on hands-on development, enabling
participants to apply theoretical concepts in real-world scenarios. The course
emphasizes core Android development principles such as user interface (UI) design,
data management, activity lifecycle, and integration of third-party APIs.

Throughout the project, learners develop a fully functional Android app that
showcases their understanding of Java or Kotlin programming languages, Android
Studio IDE, and modern Android development tools. The project involves
implementing responsive UIs, integrating cloud-based services, and ensuring app
security and performance optimization. Advanced modules cover topics like
Material Design, Room Database, Firebase integration, and Jetpack libraries.

By the end of the project, participants will have a portfolio-worthy application

demonstrating their proficiency in Android development and preparation for the
Google Associate Android Developer certification. This course serves as a
comprehensive foundation for aspiring Android developers, enhancing their career
prospects in the fast-evolving mobile application development industry.
 GOOGLE ANDROID DEVELOPER

Preface

TABLE OF CONTENTS

1. Executive Summary
1.1 Learning Objectives
1.2 Outcomes

2. Introduction
2.1 Introduction To Google Android Developer
2.2 Benefits Of Google Android Developer
2.3 Google Android Developer Framework
2.4 Understanding Android Development

3. Overview Of The Organisation

3.1 Learning Resources
3.2 Development Tools
3.3 Documentation And Updates
3.4 Additional Resources

4. Weekly Reports

5. Outcomes
5.1 Technical Skills Acquired As Android Developer Intern
5.2 Code

6. Output Screens

7. Internship Feedback
7.1 Challenges faced

8. Conclusion and Future Scope

9. References
 CHAPTER 1: EXECUTIVE SUMMARY

About google android developers:-

An Android Developer is a Software Developer who specializes in designing

applications for the Android marketplace. The Android marketplace is the direct
competitor to Apple's app store. This means most of an Android Developer's job
revolves around creating the apps we use on our smartphones and tablets.
1.1 Learning Objectives:
Android Programming Course Objectives . In this course, you will learn about:
• Creating robust mobile applications and learn how to integrate them
with other services
• Creating intuitive, reliable mobile apps using the android services and
components.
• Create a seamless user interface that works with different mobile screens.

1.2
Outcomes:
Posted by Erica Hanson, Global Program Manager, Google Developer Student
Clubs Google Developer Student Clubs, a program of university based
community groups for students interested in Google developer technologies,
recently started hosting study groups called Android Study Jams. The goal is to
Learn Android app development through hands- on codelabs in an online
curriculum provided by Google. There are two tracks: one for students who
are new to programming, and one for those who already have experience.
Interested in participating? Facilitator materials are available for anyone to host
Android Study Jams in their community - take a look and start building apps.

Google Developer Student Clubs are dedicated to helping students learn

programming together, in a fun and interactive setting. While over 50 thousand
students from all over the world have participated in these Android workshops,
we wanted to highlight the exciting work from groups in Indonesia, Turkey, and
Nigeria. From programming in Kotlin to building a series of apps, these students
have put their minds to work.
 CHAPTER 2 : INTRODUCTION

2.1 Introduction to Google Android Development

Google Development is a treasure trove for programmers seeking to build

innovative applications. Offered by the tech giant itself, it provides a
comprehensive suite of tools, resources,and platforms to empower developers.
Whether you're a seasoned coder or a curious beginner, Google Developers
caters to all skill levels. Explore cutting-edge technologies like Artificial
Intelligence and Machine Learning, or delve into familiar territories like web
and mobile app development. They offer APIs (Application Programming
Interfaces) for seamless integration with popular Google products like Maps and
YouTube, allowing you to craft unique functionalities. Join vibrant developer
communities like Google Developer Groups (GDGs) to connect, collaborate, and
learn from fellow programmers. Google Developers is your one-stop shop to
transform your app ideas into reality.

2.2 Benefits of Google Android Development

There are several advantages to pursuing Google Android Development:

• Large Market Reach: Android boasts the biggest market share in the mobile
operating system landscape. Developing for Android allows you to reach a wider
audience compared to other platforms.
• Open-Source Platform: The open-source nature of Android grants
developers greater flexibility and customization options when building
apps.
• Rich Development Tools: Google offers a robust suite of tools like
Android Studio, an IDE specifically designed for Android app
development, to enhance development efficiency.
• Vibrant Developer Community: A vast and active community of
Android developers exists, providing extensive support, learning
resources, and collaboration opportunities.

2.3 Google Android Development Framework

The Android development framework provides the foundation for building Android
applications. It offers a collection of pre-built components and functionalities to
streamline development. Here's a quick overview:

• Core Components: These include Activity Manager (app lifecycle), View

System (UI elements), Resource System (app resources), and Services
(background tasks).
 • APIs: Android APIs grant access to device features (camera,
sensors), network functionalities, and integration with Google services
(Maps, YouTube).
• Open-Source: Developers benefit from flexibility and customization due
to the open- source nature of the framework.
• Development Tools: Google offers tools like Android Studio (IDE) to
simplify the development process.
• Learning Resources: A vast developer community and extensive
documentation from Google provide ongoing support and learning
opportunities.
• Mastering this framework empowers developers to build feature-rich
and user-friendly applications for the widely used Android platform.

2.4 Understanding Android Development

Android powers a vast majority of smartphones, making it a prime target for app
developers. Here's a glimpse into what it takes to build Android apps:
• Languages: Master Kotlin (preferred) or Java, the primary languages
for Android development.
• Core Concepts: Grasp the building blocks: Activities (app screens),
Views (UI elements),Services (background tasks), and Broadcast
Receivers (event listeners).
• Architecture: Android apps follow a structured approach. Learn about
Activity lifecycles andhow components interact.
• UI/UX: Design user interfaces that are intuitive and follow Android's
design guidelines for aseamless user experience.
• Resources: Leverage Google's Android Developer resources including
tutorials, documentation, and code samples to kickstart your learning.
• Community: The vibrant Android developer community offers
invaluable support, fromtroubleshooting to collaboration.
• With dedication and these fundamentals, you'll be well on your way to
conquering the world of Android development!

CHAPTER 3: OVERVIEW OF THE ORGANISATION

Google Android Developer:
Our One-Stop Shop for Android App Development.Google Android Developer
has developer.android.com as the official Android developer website, is a
comprehensive resource for anyone interested in building apps for the Android
platform. It caters to developers of all skill levels, from complete beginners to
seasoned professionals.

Here's an overview of what you can find on developer.android.com:

3.1 Learning Resources:
• Get Started: This section guides you through the initial steps of setting
up your development environment with Android Studio and building your
first basic app.
• Training: Explore a wide range of educational resources, including video
courses, codelabs (step-by-step tutorials), and documentation, covering
various aspects of Android development.
• Android Basics in Kotlin: A structured curriculum designed to introduce
you to Android app development using Kotlin, the preferred language for
Android development.
• API Reference: Find detailed documentation on all the APIs (Application
Programming Interfaces) available in the Android framework, providing a
comprehensive reference for building app functionalities.
• Samples: Access a vast collection of ready-made code samples that
showcase specific functionalities and best practices, allowing you to learn
by example.

3.2 Development Tools:

• Android Studio: Download and install the official Integrated

Development Environment (IDE) specifically designed for Android app
development. It offers features like code completion, debugging tools, and
app building functionalities.
• Command-line Tools: Learn about the command-line tools available for
advanced development tasks and working with the Android SDK
(Software Development Kit) directly.
• Testing Tools: Discover tools for writing unit tests, UI tests, and
performance tests to ensure the quality and stability of your apps.
• Libraries: Explore libraries provided by Google and the developer
community that offer additional functionalities and simplify app
development.
3.3 Documentation and Updates:

• About: Learn about the latest Android platform version, explore the
Android developer ecosystem, and discover training resources.
• Develop for Android: This comprehensive section covers all aspects of
Android development, from user interface design to device compatibility
and integrating AI features.
• Guides: Find in-depth guides on specific functionalities like user interface
design, data storage, security, and background processing.
• Blog: Stay updated on the latest announcements, platform updates, new
features, and best practices from the Android developer team.

3.4 Additional Resources:

• Developer Centers: Explore resources specific to different app categories

like media apps, games, and wearable apps.
• Android for Cars, Android TV, ChromeOS: Find dedicated resources
for extending your apps to other platforms powered by Android.
• Community: Connect with other developers, share knowledge, and seek
help through forums and online communities.
• Overall, Google provide’s developer.android.com as an invaluable
resource for anyone lookingto build apps for the Android platform. It
provides everything you need to get started, learn the ropes, and stay up-to-
date with the latest advancements in Android development.
WEEKLY REPORT WEEK-1

WEEK-1

Objective of the Activity Done: Starting with Kotlin and Android Studion

Detailed Report:

Your first program in Kotlin

• A Kotlin program requires a main function as the entry point of the

program.
• To define a function in Kotlin, use the fun keyword, followed by the name
of the function ,any inputs enclosed in parentheses, followed by the
function body enclosed in curly braces.
• The name of a function should follow camel case convention and start with
a lowercase letter.
• Use the println() function call to print some text to the output.
• Refer to the Kotlin style guide for formatting and code conventions to
follow when coding in Kotlin.
• Troubleshooting is the process of resolving errors in your code.

Create and use variables in Kotlin

• A variable is a container for a single piece of data.

• You must declare a variable first before you use it.
• Use the val keyword to define a variable that is read-only where the value
cannot change once it's been assigned.
• Use the var keyword to define a variable that is mutable or changeable.
• In Kotlin, it's preferred to use val over var when possible.
• To declare a variable, start with the val or var keyword. Then specify the
variable name, data type, and initial value. For example: val count: Int = 2.
• With type inference, omit the data type in the variable declaration if an
initial value is provided.
• Some common basic Kotlin data types include: Int, String, Boolean, Float,
and Double.
 • Use the assignment operator (=) to assign a value to a variable either
during declaration of the variable or updating the variable.
• You can only update a variable that has been declared as a mutable
variable (with var).

• Use the increment operator (++) or decrement operator (--) to increase

or decrease the value of an integer variable by 1, respectively.
• Use the + symbol to concatenate strings together. You can also
concatenate variables of other data types like Int and Boolean to Strings.

Create and use functions in kotlin

• Functions are defined with the fun keyword and contain reusable pieces of
code.
• Functions help make larger programs easier to maintain and prevent
the unnecessary repetition of code.
• Functions can return a value that you can store in a variable for later use.
• Functions can take parameters, which are variables available inside a
function body.
• Arguments are the values that you pass in when you call a function.
• You can name arguments when you call a function. When you use named
arguments, you can reorder the arguments without affecting the output.
• You can specify a default argument that lets you omit the argument
when you call a function.

Download and install Android Studio

• An Integrated Development Environment, or IDE, is a collection of tools

for developing software.
• Android Studio is the IDE based on IntelliJ IDEA used for Android
development.

Create your first Android app

• To create a new project: open Android Studio, click New Project > Empty
Activity > Next, enter a name for your project and then configure its
settings.
• To see how your app looks, use the Preview pane.
• Composable functions are like regular functions with a few differences:
functions names
 • are capitalized, you add the @Composable annotation before the function,
@Composable functions can't return anything.

Run your first app on the android Emulator

• To create an AVD, open your project, click Tools > Device Manager, and
use the Device Manager to select a hardware device and system image.
• To run your app on a virtual device, ensure that you created a device,
select the device from the toolbar menu, and click .

How to connect your Android device

• You can run Android apps on your physical device through a cord or
through Wi-Fi.
• Windows users need to install a USB debugging driver to run apps on their
physical device.
• If you are running your app through Wi-Fi, you can pair using a QR code or
a 6 digit code.

Build a simple app with text composables

• Jetpack Compose is a modern toolkit for building Android UI. Jetpack

Compose simplifies and accelerates UI development on Android with less
code, powerful tools, and intuitive Kotlin APIs.
• The user interface (UI) of an app is what you see on the screen: text,
images, buttons, and many other types of elements.
• Composable functions are the basic building block of Compose. A
composable function is a function that describes some part of your UI.
• The Composable function is annotated with the @Composable annotation;
this annotation informs the Compose compiler that this function is
intended to convert data into UI.
• The three basic standard layout elements in Compose are Column, Row,
and Box. They are Composable functions that take Composable content,
so you can place items inside. For example, each child within a Row will
be placed horizontally next to each other.

Add images to your android app

• The Resource Manager tab in Android Studio helps you add and organize
your images and other resources.
• An Image composable is a UI element that displays images in your app.
WEEKLY REPORT WEEK-2

WEEK-2

Objective of the Activity Done: Starting with Kotlin Fundamentals

Detailed Report:

Conditions In Kotlin:

Conditions are commands in programming that make decisions, allowing code to

behave differently based on different conditions. Decision-making in
programming involves writing instructions for how a program should act in
different situations. In Kotlin, we use an if/else statement to perform different
actions based on a condition.

IF Condition: An if condition in programming executes code based on whether

a given condition is true or false.

ELSE Branch: The “else” keyword in programming provides an alternative

action when the “if” condition is not met.

ELSE IF Condition: An `else if` statement in programming allows for

additional conditions to be checked if the initial `if` condition is false.

WHEN Statement: The `when` expression in Kotlin is used for handling

multiple conditions, similar to a switch statement in other languages.
• Use a comma(,) for multiple conditions
• Use 'in' keyword for a range of conditions
• Use ‘is’ keyword to check data type
• Use if/else and when as expressions

Use Nullability In Kotlin:

Nullability in KOTLIN improves code reliability by differencing between

Nullable and Non- Nullable types, marked with “?” for Nullable types.

• Use nullable variables

• Handle nullable variables
• Use “?” Safe call operator
• Use “!!” Not-null assertion operator
• Use if/else conditions
• Use if/else expressions
• Use “?:” elvis operator
WEEKLY REPORT WEEK-3

WEEK-3

Objective of the Activity Done: Interacting with UI and State, Kotlin

Fundamentals

Detailed Report:

Creating an Interactive Dice Roller App in Android Development

Introduction:

A dice roller app is a basic yet engaging application that simulates the rolling of
a dice. It's a popular choice for beginners to learn Android development due to
its simplicity and the opportunity to explore fundamental concepts. This report
outlines the core components and steps involved in building a dice roller app.

Core Components

UI (User Interface):
o An image view to display the dice face.
o A button to trigger the dice roll.

Logic:

o Random number generation to simulate dice rolls.

o Image resource management to display different dice faces based on
the random number.

Development Steps:

1) Project Setup
2) UI Design
3) Image Resources
4) Dice Rolling Logic
5) Button Click Handler
Understanding UI and State

• UI (User Interface): The visual elements users interact with, such as

buttons, text fields, and images.
• State: Data that can change over time and affects the UI's appearance,
such as user input, application data, and network responses.

Core Concepts

• Views: Building blocks of the UI. They represent visual elements on the
screen and handle user interactions.
• Layouts: Organize views into hierarchies to define the UI structure.
• View Groups: Containers that hold other views, such as LinearLayout,
RelativeLayout, and ConstraintLayout.
• State Management: Techniques for storing and managing application
data that affect the UI’s Managing State
• Instance State: Save and restore UI state when an activity or fragment is
destroyed and recreated.
• Shared Preferences: Store simple key-value pairs for persistent data.
• SQLite Database: For structured data storage.
• LiveData: Observe data changes and update the UI automatically.
• ViewModel: Store and manage UI-related data that survives configuration
changes.
• StateFlow and SharedFlow: For reactive state management with Kotlin
Flow.

Best Practices

• Separation of Concerns: Keep UI and logic separate for maintainability.

• Data Binding: Bind UI elements to data sources for efficient updates.

• State Management Architecture: Choose the appropriate state
management solution based on app complexity and requirements.
• Testing: Write unit and UI tests to ensure correct behavior.
WEEKLY REPORT WEEK-4

WEEK-4

Objective of the Activity Done: Built Scrollable lists and Beautiful apps

Detailed Report:

Kotlin is a versatile and modern programming language that combines concise

syntax with powerful features for both object-oriented and functional
programming paradigms. Its interoperability with Java makes it suitable for a
wide range of applications, from Android development to backend services and
web applications. By understanding these fundamentals, developers can leverage
Kotlin's strengths to write efficient, maintainable, and scalable code across
various platforms

Creating scrollable lists is a fundamental aspect of developing user interfaces in

Android applications. Scrollable lists allow users to navigate through large
datasets efficiently, presenting information in a clean, organized manner. Jetpack
Compose, a modern toolkit for building native UI, provides a simplified
approach to creating these lists with components like ‘LazyColumn’ . This guide
explains how to build a scrollable list in Jetpack Compose by using data classes,
composable functions, and other essential concepts.

In this guide, you will learn how to build an Affirmations app using Jetpack
Compose. Theapp will display a list of encouraging messages (or quotes!) paired
with beautiful images, designed to bring positivity to your day. By leveraging
Jetpack Compose, you can create a smooth, scrollable list that presents this
uplifting content in an engaging manner. The key concepts includedata classes,
composable functions, and efficient list management with ‘LazyColumn’

Creating scrollable lists in Jetpack Compose involves defining a data model,

crafting individual item components using ‘Card’ composables, and organizing
these items within a ‘LazyColumn’ for efficient scrolling. Utilizing modifiers
and surface composables ensures that the UI is well-styled and responsive. The
declarative nature of Compose simplifies the process, allowing developers to
build dynamic and interactive lists with ease.
WEEKLY REPORT WEEK-5

WEEK-5

Objective of the Activity Done: Architecture Components

Detailed Report:

Material Design, created by Google, offers guidelines for building high-quality

digital experiences for Android and other platforms. This module focuses on
Material Theming, which lets you customize your app's colors, typography, and
shapes. You'll also learn to add a top app bar with the app's name and icon.
Prerequisites include familiarity with Kotlin, building layouts and simple lists
in Compose. You'll learn to apply Material Theming, add custom colors, fonts,
and shapes, and create a top app bar. You'll need the latest version of Android
Studio and an internet connection to download starter code and fonts.

At last I created a Material app by customizing color palettes for light and dark
themes, defining component shapes, downloading and integrating custom
fonts, and designing a top bar for branding. Through this codelab, you learned
how to use Material Theming to personalize colors, typography, and shapes.
Key files include Theme.kt for theme settings, Color.kt for color definitions,
Shape.kt for shapes, and Type.kt for typography. These skills enable you to
craft unique and cohesive app designs.

In Android, an activity is referred to as one screen in an application. It is very

similar to a single window of any desktop application. An Android app
consists of one or more screens or activities.

Activity Lifecycle in Android

1. onCreate 5. onPause
2. onStart 6. onStop
3. onRestart 7. onDestroy
4. onResume
A typical Android app contains multiple app components, including activities,
fragments, services, content providers, and broadcast receivers. You declare
most of these app components in your app manifest. The Android OS then uses
this file to decide how to integrate your app intothe device's overall user
experience.

Architecting your Compose UI:

In Compose, the only way to update the UI is by changing the state of the app.
What you can control is your UI state. Every time the state of the UI changes,
Compose recreates the parts of the UI tree that changed. Composables can
accept state and expose events.

Unidirectional data flow: A unidirectional data flow (UDF) is a design pattern in

which stateflows down and events flow up. By following unidirectional data
flow, you can decouple composables that display state in the UI from the parts of
your app that store and change state.
The UI update loop for an app using unidirectional data flow looks like the
following:
• Event: Part of the UI generates an event and passes it upward—such as a
button click passed to the ViewModel to handle—or an event that is
passed from other layers of your app, such as an indication that the user
session has expired.
• Update state: An event handler might change the state.
• Display state: The state holder passes down the state, and the UI displays
it.

The use of the UDF pattern for app architecture has the following implications:

• The ViewModel holds and exposes the state the UI consumes.

• The UI state is application data transformed by the ViewModel.

• The UI notifies the ViewModel of user events.

WEEKLY REPORT WEEK-6

WEEK-6
Objective of the Activity Done: Navigation in Jetpack, Adapt for different Screen
Sizes
Detailed Report:

Purpose and Benefits

Jetpack Navigation addresses common challenges in Android app development

related to navigating between different screens and passing data between them. Its
primary benefits include:
• Single Source of Truth: Navigation graphs provide a centralized
representation of the app's navigation structure, making it easier to visualize
and manage.
• Type Safety: Navigation in Jetpack is type-safe, meaning you can
navigate between destinations using actions defined in the navigation graph,
reducing runtime errors.
• Back Stack Management: Jetpack Navigation manages the back stack
automatically, ensuring a consistent back navigation experience for users.
• Deep Linking: It supports deep linking, allowing users to navigate directly
to specific destinations within the app from external sources like URLs.
• Core Components of Jetpack Navigation

Navigation Graph

A navigation graph is an XML resource file that defines all possible destinations
and the actions that can be taken to navigate between them. It acts as a visual
representation of the app's navigation hierarchy.

NavHostFragment

The NavHostFragment is a container within your layout that hosts the

navigation graph. It dynamically swaps out fragments defined in the navigation
graph as the user navigates through the app.
NavController

The NavController is responsible for managing navigation within the NavHost

Fragment. It is obtained using Navigation. Find NavController() and allows you
to navigate between destinations and observe changes in the navigation state.
Adapt for different screen sizes

One of the great advantages of developing our app in the Android platform is the
vast opportunity to reach users in different kinds of form factors, such as
wearables, foldables, tablets,desktop, and even TV. When using an app, your
users may want to use the same app on large screen devices to take advantage of
the increased real estate. Increasingly, Android users use theirapps on multiple
devices of varying screen sizes, and expect a high-quality user experience
acrossall devices.
So far, I learned to make apps primarily for mobile devices. In this, I’ve learned
how to transform my apps to make them adaptive to other screen sizes. I'll use
adaptive navigation layoutpatterns that are beautiful and usable for both mobile
and large screen devices, such as foldables,tablets, and desktop.
WEEKLY REPORT WEEK-7

WEEK-7
Objective of the Activity Done: Get Data From the Internet, Load and Display
images from the internet
Detailed Report:

Get data from the internet

In this unit, I have learnt on how to build an Android app that can retrieve data
from the internet. The key concepts covered include Kotlin coroutines for
asynchronous programming andRetrofit for consuming RESTful web services.

Introduction to Coroutines

Kotlin coroutines allow us to write asynchronous code in a sequential style,

making it easier to handle background tasks. Coroutines help manage long-
running tasks like network operations, which would otherwise block the main
thread and lead to an unresponsive app. Key coroutine builders include:
• launch: Starts a new coroutine without blocking the current thread.
• async: Starts a coroutine and returns a Deferred, which represents a future
result.
• runBlocking: Blocks the current thread until its scope completes, useful in
main functions or tests.

HTTP and REST

HTTP (Hypertext Transfer Protocol) is the foundation of any data exchange on

the Web. REST (Representational State Transfer) is an architectural style that uses
HTTP methods to create, read, update, and delete data. RESTful services use
standard HTTP methods:
• GET: Retrieve data from the server.
• POST: Send data to the server.
 • PUT: Update existing data on the server.
• DELETE: Remove data from the server.
APIs (Application Programming Interfaces) based on REST principles are called
RESTful APIs

Architecture: The Data Layer:

In this we may learn about the data layer and its two basic components:
repositories and the datasource. We will also cover data immutability, error
handling, threading, testing in this concept.

Add respository and manual dependency injection:

• Separate the UI layer and the Data layer

• Create Datalayer
• Dependency injection
• Attach application container to the app
• Add repository to view model
• Get setup for local tests
• Create fake data and dependencies for tests
• Write a repository test
• Write a viewmodel test
• Get the solution code

Load and display images from the internet:

• App overview
• Display a downloaded image
• Display a grid of images with a lazy vertical grid
• Add retry action

• Update the viewmodel test

From this topic I had learnt about the load and display images from the internet by
using the above steps like add repository and manual dependency injection steps
and also load and display images from the internet steps finally I am concluding
that these are the steps I used
in downloading and display image from the internet and we may apply
architecture best practices tothe app and use coil to download and display images.

Objective of the Activity Done: Introduction to SQL, Use Room for Data
Persistence
Detailed Report:

Introduction

SQL (Structured Query Language) is a specialized programming language

essential for managing and manipulating data within relational database
management systems (RDBMS). Its primary purpose is to provide a standardized
method for interacting with databases, allowing usersto retrieve, manipulate, and
define data efficiently. SQL consists of several key components:
• Data Definition Language (DDL)
• Data Manipulation Language (DML)
• Data Control Language (DCL)

Importance of SQL:

SQL plays a crucial role in modern data management and is indispensable for
various reasons.
• Firstly, it provides a standardized language for interacting with relational
databases, ensuring consistency and compatibility across different
platforms and systems.
• Secondly, SQL enables efficient data retrieval through its robust querying
capabilities.
• Thirdly, SQL supports data integrity and security through mechanisms like
constraints (e.g., PRIMARY KEY, FOREIGN KEY) and permissions
management(e.g., GRANT, REVOKE).
• Fourthly, SQL facilitates data analysis and decision-making by enabling
complexqueries, aggregations, and transformations.

Use room for data persistance:

Room is a powerful library provided by Android that simplifies and streamlines

data persistence in SQLite databases. It serves as an abstraction layer over SQLite
and offers several benefits for Android developers:

Database Creation and Management: Room simplifies the creation and

management ofSQLite databases in Android applications. Developers define
database entities as annotated Java or Kotlin classes, and Room handles the
creation of corresponding SQLitetables.

1. SQLite Abstraction: Room abstracts away raw SQL queries and

operations, providing ahigher-level, object-oriented interface for interacting
with the database. This abstraction reduces the amount of boilerplate code
needed to perform database operations compared to traditional SQLite
Open Helper implementations.
2. Compile-time Verification: Room provides compile-time verification of
SQL queries embedded in annotated methods, reducing runtime errors
related to SQL syntax or table schema mismatches. This ensures that
queries are validated and errors are caught early in the development process.
3. Support for Live Data and Rx Java: Room integrates seamlessly with
Live Data (for reactive data streams) and Rx Java (for reactive
programming), allowing developers to observe database changes and
update the UI automatically when data changes occur.
4. Thread Safety: Room simplifies handling database operations on
background threads by providing built-in support for asynchronous queries
and transactions. This ensures that database operations do not block the
main UI thread, improving app performance and responsiveness.
5. Relationship Mapping: Room supports defining relationships between
database entities using annotations such as @Relation and @ForeignKey.
This simplifies complex database schema designs and facilitates efficient
data retrieval using joins.
6. Migration Support: Room provides built-in support for database schema
migrations. Developers can specify migration paths to handle database
schema changes between app versions, ensuring data persistence without
losing existing data.
7. Testing Support: Room facilitates easier testing of database-related code
by allowing developers to mock or provide in-memory implementations of
the database during unit tests. This promotes effective testing practices and
ensures robustness in database.
WEEKLY REPORT WEEK-8

WEEK-8

Objective of the Activity Done: Store and access data using Keys with
Datastore, Schedule tasks with WorkManager

Detailed Report:

INTRODUCTION TO DATA STORE AND PREFERENCES:

Data Store is a modern way to store data in Android, replacing Shared

Preferences. It offers two types: Preferences Data Store for simple key-value
pairs and Proto Data Store for structured data, allowing for easier and safer
data handling.

SAVE PREFERENCES LOCALLY WITH DATASTORE:

Datastore is a modern Android library for storing user preferences locally using
a key- value store or typed objects. It provides a more efficient and type-safe
alternative to Shared Preferences, using Kotlin Coroutines for asynchronous
data access. Datastore supports both preferences and proto formats, allowing
for flexible data storage solutions. This helps improve app performance and
maintainability.

5.OUTCOMES DESCRIPTION
5.1 Technical Skills Acquired as Android Developer Intern

Android development is a key area in mobile application development,

enabling the creation of applications for devices running the Android
operating system. This document aims to provide a comprehensive overview
of the outcomes associated with mastering Android development.

Comprehensive Understanding of Android Ecosystem:

• Overview of Android OS: A solid understanding of the Android

operating system, its architecture, and its various components.
• Android Versions and API Levels: Familiarity with different Android
versions, API levels, and their features.
• Development Tools: Proficiency in using Android Studio, the official
IDE for Android development, and other essential tools such as Gradle,
ADB, and the Android Emulator.
• Proficiency in Java and Kotlin Programming Languages
• Java Basics: Mastery of Java fundamentals, as it is the primary
language for Android development.
• Kotlin Integration: Understanding Kotlin, the modern, statically-typed
programming language that is fully interoperable with Java and now
officially supported by Google for Android development.
• Coding Standards: Adherence to best practices and coding standards
in both Java and Kotlin to write clean, efficient, and maintainable code.
• User Interface Design and Development
• UI/UX Principles: Knowledge of user interface (UI) and user
experience (UX) design principles specific to mobile applications.
• XML Layouts: Proficiency in designing responsive and dynamic UI
layouts using XML.
• Material Design: Implementation of Google's Material Design
guidelines to create visually appealing and user-friendly interfaces.
• Custom Views and Animations: Ability to create custom views,
animations, and transitions to enhance the user experience.
Efficient Data Management and Persistence:

• SQLite Database: Implementation of SQLite for local data storage and

management.
• Room Persistence Library: Use of Room, an abstraction layer over
SQLite, to simplify database operations.
• Shared Preferences: Utilization of Shared Preferences for simple data
storage.
• Content Providers: Integration of content providers to share data
between applications.

Network Communication and API Integration:

• HTTP Requests: Mastery of making network requests using libraries

such as Retrofit, OkHttp, and Volley.
• RESTful APIs: Understanding of REST principles and the ability to
consume RESTful APIs.
• JSON Parsing: Proficiency in parsing JSON responses to retrieve and
display data.
• WebSockets: Implementation of WebSockets for real-time data
communication.

Background Processing and Multithreading:

• Asynchronous Programming: Understanding asynchronous

programming techniques to perform tasks in the background.
• Services and WorkManager: Implementation of Android services and
WorkManager for background tasks.
• Threading: Knowledge of threading concepts, including the use of Async
Task, Handler, and Executors.

Integration of Third-Party Libraries and SDKs:

• Library Management: Ability to integrate and manage third-party

libraries and SDKs using Gradle.
• Popular Libraries: Familiarity with popular libraries such as Glide,
Picasso, Dagger, and Firebase.

Testing and Debugging

• Unit Testing: Writing unit tests using JUnit and Mockito to ensure code 32
reliability.
 • UI Testing: Implementation of UI tests using Espresso and UIAutomator.
• Debugging Tools: Proficiency in using Android Studio's debugging tools
to identify and fix issues.

App Deployment and Distribution:

• APK Generation: Understanding the process of generating signed APKs

for deployment.
• Google Play Store: Knowledge of the Google Play Store submission
process, including the creation of store listings, managing app versions,
and tracking app performance using the Google Play Console.
• Continuous Integration and Delivery: Implementation of CI/CD
pipelines to automate build, test, and deployment processes.

Ethical Considerations and Security Practices:

• Data Privacy: Ensuring user data privacy by following best practices and
regulations such as GDPR.
• Security Measures: Implementation of security measures to protect
sensitive data and prevent common vulnerabilities such as SQL injection,
XSS, and insecure data storage.
• Ethical Coding: Adherence to ethical standards in coding practices,
including accessibility and inclusivity considerations.

5.2 Code:

package com.example.diceroller

import android.os.Bundle
import android.widget.Button
import android.widget.ImageView
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity
import kotlin.random.Random

class MainActivity : AppCompatActivity() {

override fun onCreate(savedInstanceState: Bundle?) {

super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)

val diceResult: TextView = findViewById(R.id.diceResult)

val diceImage: ImageView = findViewById(R.id.diceImage)
val rollButton: Button = findViewById(R.id.rollButton) 33
 rollButton.setOnClickListener {

val diceRoll = Random.nextInt(1, 7)

diceResult.text = "You rolled: $diceRoll"

val diceImageResource = when (diceRoll) {

1 -> R.drawable.dice_1
2 -> R.drawable.dice_2
3 -> R.drawable.dice_3
4 -> R.drawable.dice_4
5 -> R.drawable.dice_5
else -> R.drawable.dice_6
}
diceImage.setImageResource(diceImageResource)
}
}
}

6.OUTPUT SCREENS

34
 7.INTERNSHIP FEEDBACK

The Google Android Developer Course offers a comprehensive curriculum,

covering both foundational and advanced Android development concepts. It
provides hands-on experience through real-world projects, helping learners
build practical skills. The inclusion of modern tools like Android Studio and
Kotlin ensures alignment with industry standards. It also prepares learners for
the Google Associate Android Developer certification, enhancing career
opportunities. Adding more examples, assignments, and deployment guidance
could further improve the learning experience.

7.1 CHALLENGES FACED

The Google Android Developer Course presents several challenges for learners.
Beginners often face a steep learning curve when understanding key concepts
like the activity lifecycle and threading. Developers transitioning from Java to
Kotlin may struggle with the differences in syntax and paradigms.

Debugging complex app errors, especially in advanced areas like

multithreading

35
and API integration, can be time-intensive. Designing responsive and visually
appealing UIs for various screen sizes adds another layer of complexity.
Ensuring app performance and battery efficiency across diverse devices can
also be demanding.

Additionally, integrating cloud services like Firebase requires a basic

understanding of backend development, which some learners may lack.
Limited guidance on testing, deploying, and maintaining apps on the Google
Play Store can further complicate the process. Time management is another
challenge due to the intensive nature of the course, and navigating the extensive
documentation may overwhelm learners. Finally, frequent Android updates can
make it difficult to keep up with the latest practices and tools.

8.CONCLUSION AND FUTURE SCOPE

Android Basics with Compose: A Strong Foundation for Modern Android

Development The "Android Basics with Compose" course on
developer.android.com offers a fantastic
introduction to building modern Android apps using Jetpack Compose, the
new UI toolkit for Android. Here's a summary of its key takeaways:

What I’ve learned:

• Fundamentals of Kotlin: Gain a solid understanding of the Kotlin

programming language, the preferred choice for Android development.
This includes core concepts like variables, data types, control flow,
functions, and classes.
• Building User Interfaces with Jetpack Compose: Discover the power of
Compose in creating declarative and composable UI elements. You'll learn
how to structure layouts, manage data binding, and handle user
interactions.
• Creating Interactive Apps: Build apps that respond to user input, such as
button clicks and user gestures. Understand how to handle state changes
and update the UI accordingly.
36
• Working with Data: Explore ways to manage data within your app,
 including displaying data lists and handling user input.
• Material Design Principles: Learn how to design apps that are visually
appealing and user-friendly by following the Material Design guidelines.

We can also implement the following:

• Incorporation of Emerging Technologies: Future iterations of the

course could include advanced topics such as AI, machine learning, and
augmented reality (AR/VR) integration, allowing developers to build
more innovative and cutting-edge applications.
• Focus on App Deployment and Maintenance: Expanding the course
to cover detailed app deployment processes, including optimization for
the Google Play Store, app analytics, and post-launch maintenance,
would provide a comprehensive end-to-end development experience.

9.REFERENCES

1. https://developer.android.com/courses/android-basics-compose/unit-1
2. https://developer.android.com/courses/android-basics-compose/unit-2
3. https://developer.android.com/courses/android-basics-compose/unit-3
4. https://developer.android.com/courses/android-basics-compose/unit-4
5. https://developer.android.com/courses/android-basics-compose/unit-5
6. https://developer.android.com/courses/android-basics-compose/unit-6
7. https://developer.android.com/courses/android-basics-compose/unit-7
8. https://developer.android.com/courses/android-basics-compose/unit-8

APPENDIX A

Sreenidhi Institute of Science and Technology

Department Of INFORMATION TECHNOLOGY

SUMMER INDUSTRY INTERNSHIP - II

37
Batch No:1
 Title
Roll No Name

22311A1299 G. SAI SHASHI

VARAN
GOOGLE ANDROID
22311A1287 G. M. ROHAN DEVELOPER
GOUD
22311A12A6 S. VINAY
KARTHIK

ABSTRACT
The Google Android Developer Course provides comprehensive training in
Android app development, covering key concepts like UI design, data
management, and app lifecycle. It focuses on hands-on learning, enabling
learners to build real-world applications using Kotlin and Android Studio. The
course prepares participants for the Google Associate Android Developer
certification, enhancing career prospects. Topics include Firebase integration,
performance optimization, and cloud services. By the end, learners gain practical
skills needed to create, test, and deploy Android apps successfully.

Student 1: G. Sai Shashi Varan Student 2: G. M. Rohan Goud Student 3: S. Vinay Karthik

Internship Internship HOD-IT

Coordinator Internal Guide
Dr. P. N. Siva Jyothi Mrs. C. Sarika Dr. SUNIL
BHUTADA
Associate Professor Associate Professor Professor

38
 APPENDIX B
CORRELATION BETWEEN THE GROUP
PROJECT AND THE PROGRAM
OUTCOMES (POS), PROGRAM SPECIFIC
OUTCOMES (PSOS)

Batch No: 1 Title

Roll No Name
22311A1299 G. SAI SHASHI
VARAN
GOOGLE ANDROID DEVELOPER
22311A1287 G. M. ROHAN GOUD

22311A12A6 S. VINAY KARTHIK

Table 1: Project/Internship correlation with appropriate POs/PSOs (Please

specify level of Correlation, H/M/L against POs/PSOs)

H High M Moderat L Low

e

SREENIDHI INSTITUTE OF SCIENCE AND TECHNOLOGY

DEPARTMENT OF INFORMATION TECHNOLOGY
Projects Correlation with POs/PSOs
PO1 PO2 PO3 PO4 PO5 PO6 PO7 PO8 PO9 PO10 PO11 PO12 PSO1 PSO2 PSO
3
M L L H H L M H M H H H H H M

Student 1: G. Sai Shashi Student 2: G.M. Rohan Goud Student 3: S. Vinay

Varan Karthik

Internship Internship Internal Guide HOD-IT

Coordinator
Dr. P. N. Siva Jyothi Mrs. C. Sarika Dr. SUNIL BHUTADA
Associate Professor Associate Professor Professor 39
 APPENDIX C

DOMAIN OF THE PROJECT AND NATURE OF THE PROJECT

Batch No: 1
Title
Roll No Name

22311A1299 G. SAI SHASHI

VARAN GOOGLE ANDROID DEVELOPER
G. M. ROHAN GOUD
22311A1287

22311A12A6 S. VINAY KARTHIK

Table 2: Nature of the Project/Internship work (Please tick √ Appropriate for your project)

Batch No. Title Nature of project

Product Application Research Others(specify)

GOOGLE
ANDROID
1
DEVELOP
ER

Student 1: G. Sai Shashi Varan Student 2: G. M. Rohan Goud Student 3: S. Vinay Karthik

Project Coordinator Internship HOD-IT

Internal Guide
Dr. P. N. Siva Jyothi Mrs. C. Sarika Dr. SUNIL BHUTADA
Associate Professor Associate Professor Professor

40
Table 3: Domain of the Project/ Internship work (Please tick √ Appropriate for your project)

Domain Of The Project

Bat Title ARTIFICIAL COMPUTE DATA CLOUD SOFTWA

ch INTELLIGE R WAREH COMPUTI RE
No NETWOR O N ENGIN
KS USING, EE

NCE, , DATA G, RING,

MACHINE INFORMATI MINING, INTERNET IMAGE
LEARNING ON AND BIG OF THINGS PROCESS
AND DEEP SECURITY, DATA ING
LEARNING CYBER ANALYTI
SECURITY CS

GOOGLE
ANDROID
1 DEVELOPER

Student 1: G. Sai Shashi Varan Student 2: G. M. Rohan Goud Student 3: S. Vinay Karthik

Internship Internship HOD-IT

Coordinator Internal Guide
Dr. P. N. Siva Jyothi Mrs. C. Sarika Dr. SUNIL
BHUTADA
Associate Professor Associate Professor Professor

41