An Internship Training Report

Submitted by

Nitish 220120101112

ON
Mobile App Development
(Flutter & Dart)

In Partial Fulfillment of the Requirements

for the Degree of
Bachelor of Technology

Computer Science

TULA’S INSTITUTE, DEHRADUN

(Affiliated to VMSB Uttarakhand Technical University, Dehradun)

(Duration of Training: 8 Weeks)

 TABLE OF CONTENTS

ACKNOWLEDGEMENT

INTERNSHIP CERTIFICATE

1.Overview of Flutter

2.Flutter’s Architecture: The Core Components

3.Setting Up the Development Environment

4.Introduction to the Dart Programming Language

5.Widgets and Flutter’s UI Paradigm

6.Practical Application: Building a Simple Flutter App

7.Widgets and Layout

8.State management and Forms

9.Networking and RESTful API Integration

10.Deployment and Publishing

11.Conclusion
 ACKNOWLEDGEMENT

I am grateful for the opportunity to complete my online internship training in Flutter and Dart
mobile app development. This experience has been instrumental in broadening my technical skills
and understanding of mobile app development.

Firstly, I would like to express my heartfelt gratitude to Mr. Saradh Pratap Singh, my internship
mentor, whose guidance and support were invaluable throughout this online training. Despite the
virtual format, their constant encouragement and constructive feedback made the learning process
both engaging and insightful.

I would also like to thank Udemy and NassCom Foundation for offering a flexible and well-
structured online internship program. The access to resources, online workshops, and virtual
collaboration tools facilitated a seamless learning experience, allowing me to gain practical skills
in a remote environment.

Additionally, I am thankful to my family and friends for their unwavering support during this
online internship for enabling me to undertake this valuable experience remotely.

Thank you all for contributing to my growth and learning during this journey.
Certificates
Certificates
Introduction to Flutter & Dart Basics

Overview

Flutter is Google’s open-source UI software development toolkit, which allows developers to build
natively compiled applications for mobile, web, and desktop from a single codebase.

Released in 2017, it has quickly become a favorite among developers due to its versatility, ease of
use, and performance. Unlike traditional frameworks that require separate codebases for different
platforms, Flutter offers a single codebase approach that can run on Android, iOS, web, and
desktop with minimal modifications.

This reduces development time and allows for a more cohesive user experience across platforms.
During my first week, I set out to understand Flutter's core architecture and learn about the Dart
programming language, which underpins Flutter development.

Flutter’s Architecture: The Core Components

Flutter’s architecture is composed of three main parts: the Framework, the Engine, and the
Embedder. Together, these elements enable Flutter to create applications that look and feel native,
regardless of the platform.

1. The Framework: This is the part where most Flutter developers spend their time. It’s an open-
source set of libraries that includes the foundational building blocks for building UIs, handling
interactions, and managing application state.

2. The Engine: Written in C++, the engine provides low-level rendering support using Google's
Skia graphics library. It’s responsible for translating the Dart code written by developers into
native code that runs on different platforms.

3. The Embedder: The embedder is platform-specific code that enables Flutter to run on different
operating systems, such as Android, iOS, Linux, macOS, Windows, and the web.
Setting Up the Development Environment

Before diving into coding, setting up the right development environment is essential. Flutter’s
toolkit is designed to be beginner-friendly, with a straightforward installation process. I followed
these steps to set up my environment:

1. Installing the Flutter SDK: The first step was downloading and installing the Flutter SDK
from Flutter’s official website. The SDK includes the Flutter framework, Dart SDK, and
command-line tools. Once downloaded, I added Flutter to the system path, allowing me to access
Flutter commands from any directory.

2. Choosing an IDE: Flutter supports multiple integrated development environments (IDEs),

including Visual Studio Code (VS Code), Android Studio, and IntelliJ IDEA. I opted for VS Code
due to its lightweight design and extensive extensions marketplace. To enhance the development
experience, I installed the Flutter and Dart extensions for VS Code, which provide tools like syntax
highlighting, code completion, and debugging capabilities.
3.Setting Up Android Studio: Although VS Code was my primary IDE, I also installed Android
Studio for its built-in Android emulator, which is essential for testing apps on different devices.
Android Studio’s installation process includes setting up the Android SDK, which provides the
necessary tools for running and debugging Android applications. Flutter’s versatility was evident
here, as it seamlessly integrates with both lightweight and full-fledged IDEs.

4. Running the Flutter Doctor Command: Flutter Doctor is a handy command-line tool that
checks for any missing dependencies or configuration issues in the Flutter environment. Running
this command helps ensure that the SDK, IDE, and device emulator are properly configured. After
resolving a few minor issues highlighted by Flutter Doctor, my environment was ready for
development.
Introduction to Dart and its Importance

Introduction

Flutter uses Dart as its primary programming language. Dart was created by Google as an object-
oriented, class-defined language designed for client-side development. Although not as widely
known as languages like JavaScript or Python, Dart is known for its speed and efficiency, making
it ideal for Flutter’s needs.

1. Why Dart?

Google chose Dart for Flutter because of its fast compilation time, which is crucial for mobile
development. Dart’s Just-In-Time (JIT) compilation supports fast development cycles by
allowing hot reloads. This feature quickly reflects code changes in the running app without
requiring a full restart. For production builds, Dart uses Ahead-Of-Time (AOT) compilation,
which produces highly optimized machine code, resulting in faster and more performant apps.

2. Dart Syntax

Dart’s syntax is straightforward, especially for those familiar with languages like JavaScript, Java,
or C#. It’s an object-oriented language with support for classes, inheritance, and polymorphism.
During my first week, I focused on Dart basics, such as declaring variables, understanding data
types, and working with control structures. Dart offers both strong typing and type inference,
which provides flexibility and readability. For example:

var name = 'Flutter'; // type inferred as String

int age = 10; // explicitly typed as an integer

 3. Control Structures: Dart supports typical control structures like `if-else`, `for`, `while`,
and `switch` statements, making it easy to implement logic within Flutter apps. The syntax
is similar to other languages, which made it easier for me to pick up.

For example:

if (age > 5) {

print('You are old enough to use Flutter!');

} else {

print('Flutter is suitable for all ages!');

}
Widgets and Flutter’s UI Paradigm

Widgets are the core building blocks of a Flutter application. Unlike traditional mobile
development frameworks that use views or layouts, Flutter uses widgets to create everything,
including buttons, text, and even the entire app itself.

1. Stateless vs. Stateful Widgets:

In Flutter, widgets can either be Stateless or Stateful. Stateless widgets are immutable,
meaning they cannot change once created. These are ideal for static elements like text or
icons. Stateful widgets, on the other hand, are mutable and can change over time, such as
when interacting with user input.
Understanding this distinction is crucial for developing interactive apps. I practiced
creating simple Stateless and Stateful widgets to understand how Flutter handles state and
rebuilding.

2. Widget Composition:
Flutter embraces a composition approach, where complex UIs are built by combining
simpler widgets. For instance, a basic app might consist of a Scaffold widget (which
provides the basic structure), an AppBar widget (for the top bar), and a Body (which can
be a Column or ListView of widgets).
This modular approach makes it easy to build complex layouts by reusing and nesting
widgets.
3. Layout Widgets:
Flutter offers a range of layout widgets, such as Container, Row, Column, and Stack. These
widgets enable developers to control how UI elements are displayed. I explored each of
these widgets in-depth:

- Container: A versatile widget that can contain other widgets, style them with
padding, margins, borders, and more.

- Row & Column: These are used to arrange widgets horizontally and vertically,
respectively. They offer flexibility in aligning and distributing widgets along the
main and cross axes.

- Stack: This widget allows for overlapping widgets, enabling complex layouts like
card-based UIs or layered designs.

4. Material and Cupertino Design:

Flutter provides built-in support for both Material Design (Android) and Cupertino (iOS)
widgets, which ensures that apps look and feel native on both platforms.

I experimented with various Material widgets, such as RaisedButton, TextField, and

AppBar, to create a simple UI that adheres to Google’s Material Design principles.
Practical Application: Building a Simple Flutter App

As a practical exercise, I created a basic Flutter app that displays a greeting message. This involved
combining various widgets to create a structured layout.

I used the Scaffold widget for the basic app structure, an AppBar widget for the title, and a Center
widget to display a text message. Here’s a simplified version of the code I wrote:

Through this exercise, I gained hands-on experience with basic widgets and layout management.
I also explored hot reload, which allowed me to see changes instantly as I updated the code. This
feature is invaluable during the development process, as it speeds up testing and iteration.
Widgets and Layout

After that I focused on Flutter’s widgets and layouts, which are the core building blocks of any
Flutter app.

I learned that widgets are either Stateless or Stateful. Stateless widgets remain constant once
created, while Stateful widgets can change over time.

This distinction is important for creating interactive and dynamic interfaces. I then explored basic
layout widgets like Container, Row, Column, and Stack. These widgets help arrange other widgets
in various ways, allowing for flexible UI designs.

In addition, I learned about navigation, which is essential for moving between screens in an app.
Using Flutter’s Navigator widget, I was able to create routes and implement transitions between
screens.

By the end of the week, I was comfortable creating interactive UIs and understood common layout
techniques, which are crucial for building well-structured apps.
State Management and Forms

Then introduced state management, a key concept in Flutter that enables apps to respond
dynamically to user interactions. I learned about managing state using the setState method, which
is used to update the state of a widget and trigger a re-render.

Additionally, I was introduced to Inherited Widgets, which allow state to be shared across multiple
widgets, making it easier to manage complex state in larger applications. This week also covered
forms, which are essential for gathering user input.

I learned how to create and validate form inputs, ensuring that the data entered by users meets
specific requirements before processing it.

By the end of the week, I had gained the skills to manage state efficiently and handle user inputs
through forms, both of which are important for building interactive apps.
Networking and integrating RESTful APIs

Next was all about networking and integrating RESTful APIs into Flutter apps.

I learned how to make HTTP requests using the http package, which allows apps to communicate with
web servers. By consuming APIs, I could retrieve data from external sources, such as fetching user
information from a database or getting weather data from a public API.

I also learned about asynchronous programming with Dart’s Future and async/await keywords, which are
used to handle operations that take time, like network requests.

By the end of the week, I was capable of integrating APIs and retrieving data, which enables apps to
interact with online resources and provide real-time information to users.

This is what I created using API integration and UI Framework

Deployment and Publishing

The final week was focused on preparing an app for deployment and publishing it on the Google
Play Store.

I learned about debugging and optimizing the app to ensure it performs well in a production
environment.

This involved testing for errors, reducing file sizes, and improving app speed. I then explored the
process of building an APK (Android Package) and followed the steps required to publish it on
the Play Store.

Understanding app store submission guidelines and managing updates is crucial for maintaining
a successful app. By the end of the week, I had gained the skills to prepare and release a Flutter
app, making it available to users around the world.

Here is the project that I created using flutter and dart all concept using the api’s and firebase to
store and authentication of the application
CONCLUSIONS

Over the course of eight weeks, I gained a comprehensive understanding of Flutter and Dart,
progressing from foundational concepts to advanced development skills.

I began by exploring Flutter’s architecture and learning the basics of Dart, which set the
groundwork for building Flutter applications. I then delved into widgets, layouts, and navigation,
gaining the skills to create interactive and responsive UIs.

As I progressed, I learned essential topics like state management, handling user input, and
integrating RESTful APIs for data retrieval.

This was followed by implementing local data persistence and Firebase, which provided insights
into both local and cloud-based storage solutions. I also explored animations, enhancing the user
experience with dynamic and engaging UI elements.

Finally, I learned how to prepare and publish a Flutter app, covering optimization and
deployment on the Google Play Store.

Overall, these eight weeks transformed my understanding of Flutter development, equipping me

with the skills to build and deploy robust, cross-platform mobile applications.