This document provides an introduction to developing Android applications using Android Studio. It begins with a review of Android and Android Studio, then discusses setting up the Android Studio development environment. It describes the activity lifecycle and project structure in Android, including the java, manifest, res, and Gradle script folders. The document outlines different types of layouts that can be used to structure user interfaces and provides a guide to the res folder for storing app resources. It concludes by stating that the next steps will involve creating a simple app user interface.

1. Android: Designing starter

2. Contents
• What is Android and what is Android Studio?(Quick review)
• Setting up Android studio
• Activity and its life cycle.
• Android project Structure
• Layout and Types of Layout
• Guide to res Folder

3. Know this…
• There are no stupid questions!

5. What is Android?
• Open-source Linux-based operating
system
• Developed by Open Handset
Alliance(Business alliance of around 80
companies) lead by Google.
• Source code is called Android Open-Source
Project(AOSP)
• Launched in 2007 for the first time
(Android 1.0)
• Programming languages: Java, Kotlin,
XML,C++
• Current Android version is Android 11
• Development tool: Android Studio

6. What is Android studio?
• Official IDE for development of
Android applications
• Comes with gradle
• GitHub integration
• C++ and NDK(Native Development
Kit) support
• Built-in support for Google Cloud
Platform.

7. Setting Up Android Studio
• Download Android Studio From the link: https://developer.android.com/studio
Click this button

8. Setting up Android Studio
• Click on the check box and click download button

9. Setting up Android Studio

11. Setting up Android Studio

12. Setting up Android Studio

13. Activity
• An activity represents a single screen with a user interface just like window.
Below are the 3 different activities.

14. B-but they are all WhatsApp!

15. Activity
• An activity is a single, focused thing
that the user can do.
• Almost all activities interact with the
user, so the Activity class takes care
of creating a window for you in
which you can place your UI with
setContentView(View)

16. Life cycle
of Activity
• onCreate()
• onStart()
• onResume()
• onPause()
• onStop()
• onDestroy()

17. onCreate()
• Called when the activity is first created.
• Initialize your objects here.
• Always followed by onStart().
• Called only once in a life of an Activity.

18. onStart()
• Called when the activity is becoming visible to the user.
• User cannot interact with it yet
• Very short gap between onResume() and onStart().
• Followed by onResume().

19. onResume()
• This is the state in which the app interacts with the user.
• The app stays in this state until something happens to take focus away from the
app.
• Initiates the running state of an App.

20. onPause()
• It is called when your activity is not focused
• The system calls this method as the first indication that the user is leaving your
activity
• In Android 7.0 (API level 24) or higher, multiple apps run in multi-window mode.
Because only one of the apps (windows) has focus at any time, the system
pauses all of the other apps.
• A new, semi-transparent activity (such as a dialog) opens. As long as the activity
is still partially visible but not in focus, it remains paused.

21. onStop()
• When your activity is no longer visible to the user, it has entered the Stopped
state.
• This may occur, for example, when a newly launched activity covers the entire
screen
• The system may also call onStop() when the activity has finished running, and is
about to be terminated.
• Your app might pause animations or switch from fine-grained to coarse-grained
location updates.

22. onDestroy()
• Called before the activity is destroyed. The system invokes this callback either
because:
• The activity is finishing (due to the user completely dismissing the activity or due
to finish() being called on the activity), or
• The system is temporarily destroying the activity due to a configuration change
(such as device rotation or multi-window mode)

25. Moving on!

26. Project Structure of Android
Three main folders:
1. java
2. manifest
3. res
4. Gradle scripts

27. java folder
• This folder contains all the logical
source code that performs functions
• Android studio also adds packages
for unit testing
• You can add activities, simple java
classes or packages as you need.

28. manifest folder
• It contains only one file i.e
AndroidManifest.xml
• The AndroidManifest.xml file contains
information of your package, including
components of the application such as
activities, services, broadcast receivers,
content providers etc.
• Why is this needed? To tell the device
information about the app.

29. res folder
• This folder contains external
resources that the app is going to
use
• Images, layouts, icons, colors etc.
• These are xml files.

30. Gradle Scripts
• Gradle is a build system (open
source) which is used to automate
building, testing, deployment etc.
• Simply put, a gradle takes all the
source files (java and XML) and
apply appropriate tools, e.g.,
converts the java files into dex files
and compresses all of them into a
single file known as apk that is
actually used.

31. Guide to res folder

32. Layout, What is it?
• A view objects are usually called
"widgets" and can be one of many
subclasses.
• A ViewGroup objects are usually
called "layouts" can be one of many
types that provide a different layout
structure.
• A layout defines the structure for a
user interface in your app, such as in
an activity. All elements in the layout
are built using a hierarchy of view
and viewgroup objects.

33. Layout
attributes
• Every View or ViewGroup have
XML attributes that define the
properties of the component
• Some attributes are common
(such as id attribute) while
other are not (such as textSize
is only for text related views)

34. Types of Layout
• Linear Layout
• Constraint Layout
• Relative Layout
• Frame Layout
• Table Layout

35. Linear Layout
• Android LinearLayout is a view group that aligns all children in either vertically or
horizontally.

36. Relative Layout
• Android RelativeLayout enables you
to specify how child views are
positioned relative to each other.
The position of each view can be
specified as relative to sibling
elements or relative to the parent.

37. Constraint Layout
• Constraint Layout is a ViewGroup
(i.e. a view that holds other views)
which allows you to create large and
complex layouts with a flat view
hierarchy, and also allows you to
position and size widgets in a very
flexible way.

38. Frame Layout
• Frame Layout is designed to block
out an area on the screen to display
a single item. Generally,
FrameLayout should be used to hold
a single child view, because it can be
difficult to organize child views in a
way that's scalable to different
screen sizes without the children
overlapping each other.

39. Table Layout
• Android TableLayout going to be
arranged groups of views into rows
and columns. You will use the
<TableRow> element to build a row
in the table. Each row has zero or
more cells; each cell can hold one
View object.

40. Views
• View is the basic building block of UI(User Interface) in android.
• TextView, EditText, Buttons.

41. That’s a lot of theory, right?

42. LET’S MAKE A SIMPLE APP UI!!!