INTERNSHIP PROGRAM ON

MOBILE APPLICATION DEVELOPMENT

(ANDROID)

INTERNSHIP REPORT

Submitted by

SHREE SHAINIHA JS
(113022205098)

in partial fulfillment for the award of the degree of

BACHELOR OF TECHNOLOGY

In
INFORMATION TECHNOLOGY

VEL TECH HIGH TECH

Dr RANGARAJAN Dr SAKUNTHALA ENGINEERING COLLEGE
An Autonomous Institution

APRIL 2025
 VEL TECH HIGH TECH
Dr RANGARAJAN Dr SAKUNTHALA ENGINEERING COLLEGE
An Autonomous Institution

BONAFIDE CERTIFICATE

Certified that this is the bonafide report of Internship (21EE04P) done by

SHREE SHAINIHA JS (113022205098) in “INTERNSHIP
PROGRAM MOBILE APPLICATION DEVELOPMENT
(ANDROID)” during the academic year of 2024-2025.

SIGNATURE SIGNATURE
Mrs. S. NITHYA, M.E., Dr. M. MALLESWARI, M.E, Ph.D.,
SUPERVISOR HEAD OF THE DEPARTMENT
ASSISTANT PROFESSOR PROFESSOR
Department of Information Technology Department of Information Technology
Vel Tech High Tech Dr. Rangarajan Vel Tech High Tech Dr. Rangarajan
Dr. Sakunthala Engineering College. Dr. Sakunthala Engineering College.

Submitted for the Even Semester Examination held on ……………………… at

VEL TECH HIGH TECH DR.RANGARAJAN DR.SAKUNTHALA
ENGINEERING COLLEGE, AVADI, CHENNAI-600062.

SIGNATURE OF INTERNAL EXAMINER

 TABLE OF CONTENTS

S.NO CHAPTER NAME PAGE.NO

ABOUT THE COMPANY 1

1 INTRODUCTION 5

2 WORKING PROCESS 19

3 APP DEVELOPMENT PROPERTIES 23

4 PROJECT 26

5 ACTIVITY LIFECYCLE & NAVIGATION 26

6 CONCLUSION 27
 ABOUT THE COMPANY

The National Small Industries Corporation (NSIC) is a Government of

India Enterprise established in 1955 under the Ministry of Micro, Small,
and Medium Enterprises (MSME). It aims to promote, aid, and foster the
growth of small and medium enterprises (SMEs) across the country. NSIC
provides a range of services, including financial assistance, technology
support, skill development, and marketing support, to empower businesses
and enhance their competitiveness. One of its key initiatives is offering
internships to engineering college students, providing hands-on training and
exposure to real-world industry practices. These internships are designed to
bridge the gap between academic learning and practical application,
helping students gain technical expertise and soft skills. By collaborating
with various industries and leveraging its extensive network, NSIC ensures
that interns work on meaningful projects that add value to their careers. The
program fosters innovation, entrepreneurship, and industry readiness
among students, making it a highly sought-after opportunity for aspiring
engineers.
 Fig 1 – Company Logo
CHAPTER 1
INTRODUCTION

1.1 ANDROID APP DEVELOPMENT:

Mobile app development for Android involves designing and
building software applications specifically for Android devices, such as
smartphones, tablets, and wearables. It utilizes programming languages like
Java and Kotlin, along with tools such as Android Studio, to create user-
friendly and functional apps. Android development offers extensive
customization, thanks to its open-source nature, enabling developers to tailor
apps for diverse needs. With over 2 billion active devices worldwide, the
Android platform provides immense opportunities to reach a broad audience.
The field combines creativity, technical expertise, and problem-solving
skills to deliver innovative and impactful mobile solutions.

1.2 CLASSIFICATION OF ANDROID APP DEVELOPMENT:

In Android Studio, app development can be classified based on the
type of application and development approach. Native apps are built
specifically for Android using languages like Java or Kotlin within Android
Studio, providing seamless performance and full access to device features.
Web-based apps can be integrated into Android projects using WebView,
allowing developers to use HTML, CSS, and JavaScript to create browser-
based applications. Hybrid apps are developed using cross-platform
frameworks like Flutter or React Native, which can be integrated into
Android Studio for debugging and deployment. Apps can also be
categorized by purpose, such as productivity apps (e.g., to-do lists),
entertainment apps (e.g., games, streaming), or utility apps (e.g., file
managers). Android Studio's comprehensive tools, including the Emulator,
Gradle build system, and visual layout editor, make it an ideal platform for
creating, testing, and deploying various types of Android applications
efficiently.

1.3 FRONT END DEVELOPMENT:

Frontend development in Android Studio involves designing the
user interface (UI) and ensuring a smooth user experience (UX).
Developers use XML to create layouts such as Linear Layout, Constraint
Layout, or Relative Layout for arranging UI elements like buttons, text
views, image views, and forms. The Layout Editor in Android Studio
allows for visual design through drag-and-drop functionality. Frontend
development also includes styling the app with themes, colors, and fonts to
match the desired look and feel. This process ensures that the app is
responsive, visually appealing, and provides seamless navigation across
different device sizes.

1.4 BACKEND DEVELOPMENT:

Backend development in Android Studio focuses on implementing
the app's logic, data management, and server communication. It involves
writing the core functionality using Java or Kotlin, handling user
interactions, and managing app workflows. Developers integrate local
databases like SQLite or Room for storing data, and they use Firebase for
cloud-based storage and real-time databases. Backend also includes setting
up APIs and network communication through Retrofit or Volley to fetch or
send data to a server. Additionally, backend development manages user
authentication, push notifications, and background tasks like sync and
updates, ensuring the app works efficiently and seamlessly. Its concise
syntax and features like coroutines for asynchronous tasks make it ideal for
performing network requests, database operations, and background tasks
efficiently. Both languages facilitate seamless integration with cloud
services such as Firebase and third-party APIs, enabling Android apps to
handle real-time data, user authentication, and notifications. These backend
languages allow developers to ensure the app's functionality is robust,
scalable, and responsive to user interactions.

1.5 SKILLS REQUIRED FOR ANDROID APP DEVELOPMENT:

1.5.1 XML (Extensible Markup Language):

XML is the foundational language for designing the user interface in

Android applications. It allows developers to define layouts, structure UI
elements, and manage views such as buttons, text fields, and images. XML
provides a clear and declarative way to separate the UI design from the
application logic. It also enables the definition of styles, themes, and resource
management, which ensures consistency across different screens and devices.
By using XML, developers can create flexible, scalable layouts that adapt to
various screen sizes and orientations. XML in Android Studio is a key tool
for achieving responsive and visually appealing app designs.

1.5.2 Java:

Java is a traditional and widely-used programming language in Android

development, especially for backend and logic implementation. It allows
developers to manage application flow, handle user input, and interact with
Android APIs to perform tasks such as data storage, network communication,
and UI updates. Java is known for its stability, object-oriented principles, and
robust ecosystem of libraries and frameworks, which makes it a go-to choice
for developing scalable Android applications. Although Android has shifted
towards Kotlin, Java remains critical for legacy apps and is extensively
supported by Android’s development tools and community. Its platform
independence and performance make it reliable for large-scale app
development. It provides a strong foundation for object-oriented
programming principles, enabling developers to create modular, reusable, and
maintainable code. Additionally, Java’s extensive libraries and community
support make it a valuable tool for building robust, cross-platform
applications.

1.5.3 Kotlin:

Kotlin is a modern, expressive, and concise programming language

officially supported by Google for Android development. It interoperates
fully with Java, allowing developers to use both languages in the same
project. Kotlin simplifies Android development by offering cleaner syntax,
reducing boilerplate code, and enhancing productivity. It offers advanced
features such as null safety, coroutines for asynchronous programming, and
extension functions, which streamline development and improve app
performance. Kotlin has quickly become the preferred language for Android
app development due to its safety, ease of use, and seamless integration with
Android Studio, making it ideal for both frontend and backend development.

1.6 WORKING OF ANDROID APPS:

The working of an Android application involves a dynamic

interaction between the frontend and backend components to deliver a
functional and responsive user experience. The process starts with the user
interface (UI), which is created using XML for layout design, where elements
such as buttons, text fields, and images are defined, and Kotlin or Java is used
to handle user interactions. When the user interacts with the app by clicking a
button, entering text, or making a selection, these actions trigger event
listeners that execute corresponding logic in the app’s backend. The backend
code, written in Kotlin or Java, processes these events, such as validating
input, updating the UI, or performing calculations. If the app requires data
storage or retrieval, it interacts with a local database like SQLite or Room to
store user preferences or app data. For cloud-based applications, the backend
communicates with Firebase or other cloud services to sync data in real-time,
handle user authentication, and push notifications. API calls are made for
network communication to fetch or send data from external servers. The
backend ensures that data is processed asynchronously using coroutines (in
Kotlin) or background threads to maintain smooth performance. This
collaboration between the frontend and backend allows the Android app to
function efficiently, providing a seamless and interactive experience for the
user.

In addition to the basic flow of user interaction and backend

processing, an Android app also relies on multiple supporting components for
its functionality. Once the backend processes data or performs calculations,
the app may need to update the UI dynamically to reflect changes, such as
showing new content, notifications, or error messages. This is where
LiveData or ViewModel in Android come into play, allowing the UI to
observe changes in the data and update accordingly without requiring manual
refreshes. Furthermore, Android apps often rely on background services to
perform long-running tasks like downloading files, syncing data, or handling
push notifications without interrupting the user’s interaction with the app.
The app also uses Intents to communicate between different components,
such as starting a new activity, sending data, or invoking services.
Additionally, Android apps implement permissions to access system
resources like camera, location, or contacts, ensuring that users have control
over the app’s access to their data. The combination of these elements enables
Android apps to function as dynamic, resource-efficient applications,
providing users with a smooth and engaging experience. Furthermore,
Android apps often rely on background services to perform long-running
tasks like downloading files, syncing data, or handling push notifications
without interrupting the user’s interaction with the app.

CHAPTER 2

WORKING PROCESS

The working process of Android app development at NSIC (National Small

Industries Corporation) involves a structured and collaborative approach to
creating, testing, and deploying mobile applications, especially for
engineering college students and startups. It begins with the identification of
project requirements, where the team collaborates with stakeholders to
understand the app's intended functionality and design. Once the project goals
are clear, the development process starts with creating the user interface (UI),
which is designed using XML to create layouts and visual elements, ensuring
the app is intuitive and easy to use.
 Fig 2.1 – Android App Development

The frontend is then coded using Kotlin or Java to manage user interactions,
linking UI elements to backend logic such as event handling, data validation,
and asynchronous tasks. During this phase, the app may need to integrate
local databases (like SQLite or Room) for data storage or cloud-based
services (such as Firebase) for real-time data synchronization and user
authentication. Parallelly, the backend logic is developed to handle API calls,
process data, and manage interactions with external servers or cloud
platforms. Once both the frontend and backend are functional, the app
undergoes rigorous testing to ensure its usability, performance, and security.
Unit testing, UI testing, and integration testing are performed to identify and
resolve any bugs or issues. After successful testing, the app is prepared for
deployment on the Google Play Store or other distribution platforms.
Throughout the process, developers at NSIC follow an iterative and agile
development model, constantly refining the app based on feedback and
emerging requirements, ensuring that the final product meets industry
standards and is fully functional.
 Fig 2.2 – Mobile App Development Process

Additionally, the development process at NSIC emphasizes continuous

collaboration with mentors and industry experts to ensure the app meets real-
world requirements and is aligned with current technological trends. After
deployment, the application mainly it undergoes ongoing maintenance and
updates, incorporating user feedback and fixing any issues to improve
performance and add new features.

CHAPTER 3

APP DEVELOPMENT PROPERTIES

3.1. Platform Independence:

Android app development is platform-independent, meaning that apps

developed for Android can run on a variety of devices, including
smartphones, tablets, wearables, and even smart TVs. The Android operating
system is based on open-source software, which allows developers to create
apps that are compatible across multiple manufacturers and hardware
configurations. By leveraging tools like Android Studio, developers can
ensure that their apps are optimized to work efficiently on different devices,
making it easier to target a broad audience. This platform independence
ensures flexibility, as developers can develop and test their applications
without worrying about hardware limitations, as long as the device runs on a
compatible version of Android.

3.2. Open Source:

Android is an open-source operating system, which means that developers

have access to its source code. This openness promotes a collaborative
environment where developers can contribute improvements, fix bugs, and
create custom versions of Android tailored to their specific needs. The open-
source nature of Android offers flexibility in development, allowing
developers to customize applications more freely compared to closed-source
ecosystems. Developers can use Android SDK and other open-source
libraries to build robust and feature-rich apps. Furthermore, developers can
build their own custom ROMs or make use of third-party frameworks and
tools to enhance app functionality and design.

3.3. Rich Application Framework:

Android provides a rich application framework, allowing developers to create

feature-rich applications with various functionalities like multimedia, sensors,
and connectivity. It includes Java APIs, which enable developers to access
hardware components, such as cameras, GPS, accelerometers, and more.
Android’s UI toolkit is designed to help create intuitive, dynamic user
interfaces, and its media framework supports audio, video, and graphics,
making it ideal for entertainment or gaming applications. Additionally,
Android apps can interact with cloud services, such as Firebase, for real-time
databases, messaging, and authentication, extending the app’s capabilities
beyond local resources.

3.4. Robust Security Features:

Android offers several built-in security features to protect users and their
data. These include app sandboxing, where each app operates in its own
isolated environment, preventing it from accessing data from other apps.
Android also supports data encryption, ensuring that sensitive information
stored on devices is kept secure. Permissions are another key security feature
—users must grant explicit permission for apps to access system resources,
such as location, camera, or contacts. Additionally, Google Play Protect scans
apps for malware, helping prevent malicious apps from reaching the devices.
These security measures make Android a secure platform for both users and
developers.

3.5. Easy Integration with Google Services:

Android app development benefits from seamless integration with a wide

range of Google services, such as Google Maps, Google Drive, Google
Analytics, and Google Play Store. Google’s API libraries make it easy to add
features like location tracking, cloud storage, user authentication, and data
analytics into Android apps. For example, Firebase enables real-time data
syncing and user management, while Google Fit can integrate health tracking
features. The integration with the Google Play Store also allows developers to
distribute apps efficiently, monetize them through ads or in-app purchases,
and track app performance with built-in analytics tools.

3.6. Multi-threading and Performance Optimization:

Android provides support for multi-threading, which is essential for building

apps that remain responsive under heavy loads. Using asynchronous
programming techniques like AsyncTask, Coroutines, or HandlerThreads,
developers can perform background tasks (such as network requests or
database operations) without blocking the user interface. Android also offers
performance optimization tools, such as the Android Profiler in Android
Studio, to analyze CPU, memory, and network usage, helping developers
identify bottlenecks and optimize the app’s performance. By utilizing multi-
threading and optimizing performance, Android apps can handle intensive
operations while maintaining a smooth, responsive user experience.
3.7. Extensive Developer Community and Resources:

Android app development benefits from a vast, active developer community

and a wealth of resources available for learning and troubleshooting. With
millions of developers around the world contributing to forums, open-source
projects, and tutorials, developers have access to a wide range of knowledge
and solutions to common challenges. This strong community and resource
availability make it easier for both beginners and experienced developers to
build high-quality Android applications.

CHAPTER 4

PROJECT

4.1 PROBLEM STATEMENT:

Develop an image viewing and switching feature in Android Studio

that allows users to display image, zoom, and then swipe through images
seamlessly. Ensure smooth performance, responsive design, and compatibility
across Android devices. This feature will enhance user interaction in gallery,
product showcase, or media apps.

4.2 SOURCE CODE

4.2.1. XML CODE

4.2.2 JAVA CODE
 OUTPUT:

Fig 4.1 – Image view

The output will display an image viewer interface where users can view images,
zoom in/out, and swipe between them seamlessly. It ensures a smooth,
responsive experience with optional captions and action buttons for enhanced
interactivity.
 Fig 4.2 – Image view with left right switching option

4. 4 DESCRIPTION:

Header: Displays the app's name or section title (e.g., "Gallery Viewer") for
clear identification.

Title: Shows a brief description or name of the current image being displayed.

Swipe: Allows users to switch between images by swiping left or right.

Zoom: Enables pinch-to-zoom functionality for a closer view of the image.

Image Display: Displays the image in a responsive, full-screen format with

adjustable scaling options.

Navigation Buttons: Provides "Next" and "Previous" buttons for manual

navigation.

Loading Indicator: Shows a Progress Bar while images are being loaded from a
server or storage.
The Image View and switch interface includes features like a header and title
for identification, swipe gestures for navigating between images, and pinch-to-
zoom for enhanced viewing. It displays images in a responsive format with
optional captions for context.

4.5 OTHER APPS DEVELOPED:

 Calculator App: A utility app for performing basic arithmetic operations

like addition, subtraction, multiplication, and division
 Calendar App: Allows users to schedule events, set reminders, and view
dates interactively.
 Spinner App: Implements dropdown menus for easy selection of options
in a clean interface.
 Checkbox App: Enables users to select multiple options in a form or
task-based app.
 Autocomplete App: Provides predictive text suggestions as the user
types, enhancing input speed and accuracy.
 Tic Tac Toe Game App: A simple two-player game with an interactive
grid for entertainment and strategy.
 Music App: Plays audio tracks, manages playlists, and provides user
controls for playback.
 SMS App: Facilitates sending and receiving messages within a structured
app interface.
 Web View App: Integrates web content into the app, allowing in-app
browsing.

CHAPTER 5

ACTIVITY LIFE CYCLE & NAVIGATION

The Activity Lifecycle in Android is crucial for managing the states of an app as
it runs, ensuring efficient resource use and smooth user experiences. Each
Activity in an Android app represents a single screen, and understanding its
lifecycle is essential for managing tasks like saving data, releasing resources,
and controlling the UI. The key lifecycle methods include onCreate(), where
initial setup occurs; onStart(), when the activity becomes visible to the user;
onResume(), when the activity starts interacting with the user; onPause() and
onStop(), for releasing resources and pausing tasks when the activity is no
longer in the foreground; and onDestroy(), for final cleanup. Navigation
between activities is typically handled through Intents, which are messages used
to start new activities or communicate between components. Explicit intents
specify the target activity, while implicit intents allow Android to decide which
component to use based on the action. Using Intents, developers can pass data
between activities, manage different screen flows, and create dynamic, user-
driven app navigation, ensuring smooth transitions between app screens.
Mastery of both the lifecycle and navigation principles is essential for building
responsive and well-structured Android applications.

5.1LIFECYCLE:
The Activity Lifecycle in Android refers to the various states an activity goes
through, from its creation to its destruction. Each activity follows a well-defined
lifecycle with methods such as onCreate(), onStart(), onResume(), onPause(),
onStop(), and onDestroy(), allowing developers to manage resources and handle
user interactions effectively. Understanding these methods ensures proper
resource management, such as saving data when an activity is paused or
releasing resources when it is stopped, ultimately providing a seamless
experience for the user.

5.2STATES:
Managing the state of an activity through lifecycle methods is critical for
maintaining a consistent user experience, especially when activities are paused
or destroyed due to system resource constraints or user navigation. Methods like
onSaveInstanceState() and onRestoreInstanceState() allow developers to save
and restore data across configuration changes, such as screen rotations. Properly
handling state ensures that user data is not lost, and the app continues from
where the user left off, providing a smooth, uninterrupted experience.

5.3INTENTS
Intents are essential for navigating between activities in an Android app. An
explicit intent directly specifies the target activity, while an implicit intent
allows Android to choose the appropriate activity based on the desired action.
By passing data through intents using methods like putExtra() and retrieving it
with getIntent(), developers can seamlessly transfer data between activities.
This facilitates easy and dynamic navigation, such as moving from one screen
to another and handling user-driven interactions.

FRAGMENTS:
Fragments in Android provide modular and reusable components for managing
UI. Each fragment has its own lifecycle, closely linked to the activity that hosts
it. Key fragment lifecycle methods, such as onCreateView(), onStart(), and
onDestroyView(), ensure that developers can manage UI elements and
resources effectively as the fragment enters or exits the foreground. Fragment
navigation is typically handled using FragmentTransaction, which allows
dynamic changes to the UI, such as adding, removing, or replacing fragments
based on user interactions, enabling flexible and responsive UI designs.

BACKSTACK:
The back stack is a key feature in Android that keeps track of activities and
fragments in reverse order as the user navigates through them. The system
automatically manages the back stack when the user presses the back button,
popping the top activity or fragment. Developers can modify the back stack
behavior using FragmentTransaction.addToBackStack() or by using specific
flags with Intents, allowing for more control over activity and fragment
navigation. Proper management of the back stack ensures that the app behaves
as expected when navigating through different screens and ensures smooth user
experiences.

PASSERS:
When navigating between activities, passing data is an essential part of app
functionality. Android provides Intents to send and receive data between
activities. By using methods like putExtra() to add data to an intent and
getStringExtra() or getIntExtra() to retrieve it, developers can easily share data
across activities. For complex data, developers can use Parcelable or
Serializable interfaces to serialize objects and pass them through intents.
Efficient data handling ensures that the necessary information is available in
each activity, enhancing app interactivity and functionality.

NAVIGATIONS:
In more complex applications, Fragments are often used instead of activities to
create flexible and modular UIs. The Navigation Component simplifies
navigation by managing fragment transactions, ensuring smooth transitions
between fragments, and handling the back stack automatically. Developers can
use a NavController to navigate between fragments, and Safe Args ensures
type-safe data passing. This component reduces boilerplate code and provides a
consistent navigation experience, streamlining app architecture and enhancing
maintainability while improving user interactions.

CHAPTER – 6

CONCLUSION
Throughout the internship at NSIC, the experience of developing Android
applications using Android Studio has been invaluable in understanding the
end-to-end process of mobile app development. From mastering the Activity
Lifecycle to managing Fragments and implementing intuitive navigation
systems using Intents, the internship provided a comprehensive understanding
of Android development. Working on a variety of apps, such as List Apps, Web
Views, Calendars, Games, and Music Apps, enabled the application of core
concepts like state management, back stack handling, and data passing between
components. The hands-on exposure to Fragments, Navigation Components,
and Back Stack Management helped in creating dynamic, flexible, and user-
friendly interfaces that adapt to different user interactions and device
configurations.

The internship also allowed for a deeper understanding of the Android API and
how to integrate various functionalities such as SMS, Autocomplete,
Checkboxes, and Tic-Tac-Toe games. Furthermore, the integration of UI
elements like Spinners, Buttons, and Text Views in different activities added
another layer of customization and complexity to the projects. Learning how to
handle different data types with Intents, Bundles, and Shared Preferences has
been crucial in enhancing app functionality, ensuring that data is managed
efficiently and passed across different components seamlessly. The use of
Android Studio as the primary development environment also helped sharpen
skills in debugging, testing, and optimizing apps. Overall, the internship has
been an enriching experience, combining theoretical learning with practical
exposure, which will undoubtedly aid in the development of more advanced and
efficient Android applications in the future.