Module 1: Introduction to Android

and it’s components

- Shweta Waghmare,TIMSCDR
Topics
Creating an android application, Creating the activity, Design user interface with
Views, Working with intents, fragments, services and different types of layouts
components. Displaying picture and menus using views.

Self-Learning Topics:

The android platform, the layers of android, Four kinds of

android components, understanding the androidManifest.xml file

 Installation of Android Studio
Prerequisite : Java

Steps:
● Check java is installed or not: java -version on cmd
● If not install the Java
● Download android studio : https://developer.android.com/studio
● Install it.
● How to Install Android Studio on Windows 10:
https://www.youtube.com/watch?v=0zx_eFyHRU0

With Screenshot :
https://www.c-sharpcorner.com/article/how-to-download-and-install-android-studio-in-wi
ndows-10/
What is HAXM….

HAXM stands for "Hardware Accelerated Execution Manager". It is used for

launching Emulators and must be installed and in usable status. Please note
that Emulator launching means Virtualisation. So, we need to ensure that Intel
Hardware to launch Virtualisation Technology(VT) is enabled in our machine.

Error 1 : Not installed

https://stackoverflow.com/questions/32011025/cant-install-intel-haxm-for-and
roid-studio-error-x86-emulation-currently-requi
Creating an android application
Official site(syllabus)
https://developer.android.com/codelabs/build-your-first-android-app#2
Step 1: Create a new project
1. Open Android Studio.
2. In the Welcome to Android Studio dialog, click Start a new Android Studio
project.
3.Select Basic
Activity (not
the default).
Click Next.
4. Give your
application a name
such as My First App.
5. Make sure the
Language is set to
Java
6. Leave the defaults
for the other fields.
7. Click Finish.
Step 2: Get your screen set up

Step 3: Explore the project structure

and layout

Step 4: Create a virtual device (emulator)

Note: System images can take up a large

amount of disk space, so just download
what you need.

Step 5: Run your app on your new

emulator
Android Project folder Structure
● Android Studio is the official IDE
(Integrated Development Environment)
developed by the JetBrains community
which is freely provided by Google for
android app development.

● After completing the setup of Android

Architecture we can create an android
application in the studio. We need to
create a new project for each sample
application and we should understand
the folder structure.
Android Project folder Structure
The android project contains different types of app modules, source code files, and
resource files. We will explore all the folders and files in the android app.

1. Manifests Folder
2. Java Folder
3. res (Resources) Folder
○ Drawable Folder
○ Layout Folder
○ Mipmap Folder
○ Values Folder
4. Gradle Scripts
Manifests Folder

Manifests folder contains AndroidManifest.xml for our creating the android application.
This file contains information about our application such as the Android version,
metadata, states package for Kotlin file, and other application components. It acts as an
intermediary between android OS and our application.

Following is the manifests folder structure in the android application

Java folder

The Java folder contains all the java and Kotlin source code (.java) files that we
create during the app development, including other Test files. If we create any new
project using Kotlin, by default the class file MainActivity.kt file will create
automatically under the package name “com.geeksforgeeks.myfirstkotlinapp” as
shown below
Resource (res) folder

The resource folder is the most important folder because it contains all the non-code
sources like images, XML layouts, and UI strings for our android application.
Gradle Scripts folder

Gradle means automated build system and it contains a number of files that are
used to define a build configuration that can be applied to all modules in our
application. In build.gradle (Project) there are build scripts and in build.gradle
(Module) plugins and implementations are used to build configurations that can be
applied to all our application modules.
Task: Explore the layout editor
Find and open the layout folder (app > res > layout) on the left side in the Project panel.
Layouts are defined in XML. The layout editor lets you define and modify your layout
either by coding XML or by using the interactive visual editor.

Task: Add color resources use Values folder

How To Create New Activity in Android Studio

Step 1: Firstly, click on app > res > layout > Right Click on layout. After that
Select New > Activity and choose your Activity as per requirement.

Step 2: After that Customize the Activity in Android Studio. Enter the “Activity
Name” and “Package name” in the Text box and Click on Finish button.

Step 3: After that your new Activity in Layout will be created. Your XML Code is
in Text and your Design Output is in Design.
Design user interface with Views
Designing User Interface With Views In Android App

What is View :

The view is the component which Android provides us to design the layouts of
the app. So, we can understand view as a rectangular area which is going to
contain some element inside it.

A View is a superclass for all the UI components.

Working with views
● View is the basic building block of UI(User Interface) in android. View
refers to the android.view.View class, which is the super class for all the
GUI components like TextView, ImageView, Button etc.
● View class extends Object class and implements Drawable.Callback,
KeyEvent.Callback and AccessibilityEventSource.
● View can be considered as a rectangle on the screen that shows some
type of content. It can be an image, a piece of text, a button or anything
that an android application can display. The rectangle here is actually
invisible, but every view occupies a rectangle shape.
● By specifying the exact size(with proper units) or by using some
predefined values. These predefined values are match_parent and
wrap_content
● match_parent means it will occupy the complete
space available on the display of the device.
Whereas, wrap_content means it will occupy only
that much space as required for its content to
display.

● A View is also known as Widget in Android. Any

visual(that we can see on screen) and
interactive(with which user can interact with) is
called a Widget.
XML syntax for creating a View
Designing User Interface With Views In Android App

In particular, you will learn about the following ViewGroups:

● Basic views — Commonly used views such as the TextView, EditText, and
Button views
● Picker views — Views that enable users to select from a list, such as the
TimePicker and DatePicker views
● List views — Views that display a long list of items, such as the ListView
and the SpinnerView views
● Specialized fragments — Special fragments that perform specific
functions
In Android applications, the following are Basic Views.
● TextView
● EditText - subclass of TextView
● Button- represents a push-button widget.
● ImageButton-similar to Button View except that it displays an image with
text.
● CheckBox-is a type of button that has two states; i.e., checked or
unchecked.
● ToggleButton -displays checked/unchecked states using a light indicator.
● RadioButton & RadioGroup
RadioGroup and RadioButton, both have two states: either checked or
unchecked. A RadioGroup is used to group together one or more RadioButton
Views, thereby allowing only one RadioButton to be checked within the
RadioGroup.
● Picker views — Views that enable users to select from a list,
such as the TimePicker and DatePicker views

TimePicker :
https://www.tutorialspoint.com/android/android_timepicker_control.htm
https://www.javatpoint.com/android-timepicker-examplev

DatePicker views : https://www.javatpoint.com/android-datepicker-example

 ● List views — Views that display a long list of items, such as
the ListView and the SpinnerView views

Spinner view :
A Spinner is a type of view that hold items in form of a dropdown menu available
for user selection. It creates a menu with multiple options where a user can
select any one option. Following is an example of a spinner.
What's the difference between Spinner and ListView?
Both ListView and Spinner looks very similar. But they differ from each other.
Spinners provide a quick way to select one value from a given set of values and in the
default state, a spinner only shows the currently selected value. When you touch(tap on)
the spinner, it displays a dropdown menu with all other available values(options), from
which the user can select a new one.
ListView, on the other hand, is a view group that displays a list of scrollable items. The list
items are automatically inserted to the list using an Adapter that pulls content from a data
source such as an array or database table and converts each dataitem into a view that is
placed in the list.
Therefore, a Spinner and ListView differs in the way they appear and in their usage too. If
you want to select only one value from a set of options then you should use a Spinner. If
you want to display a list of data then use a list view.
How does a Spinner works?
Define the data source: A data source can be a list, an array, a JSON data or data
coming from a database.
String days[] = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday",
"Sunday"};

Define the Adapter

There will be an Adapter(ArrayAdapter etc) to take data from data source, create a view
of it and then pass it to the AdapterView i.e. Spinner. Thus, you need to tell the Adapter
how to display the data by specifying a layout for the drop down.

ArrayAdapter<String> adapter = new ArrayAdapter<>(this,

android.R.layout.simple_spinner_item, days);
There are 3 parameters used to instantiate an ArrayAdapter(we have used an
ArrayAdapter in our example):
● Context c: Refers to the current class object where ArrayAdapter is being
instantiated.
● Layout: It is a layout file that defines how a single item will appear in the
spinner. Android SDK by default provides layouts like simple_spinner_item
and simple_spinner_dropdown_item and if you do not have any special
design requirements, we suggest you use these only.
● Data source: It is the data source from which data will be converted into a
view.
Define any actions for Spinner
To add an event handler for option selection, you can implement OnItemSelectedListener
interface, to determine what happens when a user selects any option from the menu. For
this, you need to implement the above mentioned interface and override two methods:

onItemSelected()
This method has 4 parameters:

● AdapterView av: It's the Spinner view that you have used.
● View v: It defines the TextView inside the spinner that was clicked.
● int position: It tells the position of the item that was clicked in the Spinner. The index or
the position starts from 0.
● long id: It gives the row id of the item clicked in the Spinner. This parameter is mainly
used when dealing with databases in Android.
onNothingSelected()
This method has only 1 parameter:

AdapterView av: It's the Spinner view that you have used. This method is
called whenever the currently selected item is removed from the list of
available items in the Spinner. If the adapter is modified such that the
currently selected item is no longer available, then this method will be called.
This method may be used so that you can set which item will be selected
when the previous item is no longer available. This prevents the spinner from
automatically selecting the next item in the list.
If mySpinner is an instance of a Spinner view then, following is how we can
implement the above listeners:
mySpinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {

@Override
public void onItemSelected(AdapterView<?> parent, View view, int position, long id)
{
// An item was selected. You can retrieve the selected item using
// parent.getItemAtPosition(pos)
}

@Override
public void onNothingSelected(AdapterView<?> parent)
{
// If an option is removed then what to do
// or anything else
}
});
Working with intents, fragments, services
What is fragment and intents?

Intent, you can think of intention to do some work. It can be either go from
one activity to another activity, send email, open some links and so on.
Fragment is just like part of those activities. To make it simple you can think of
activities as full website page whereas fragment as a part of that website page
Android Intent is the message that is passed between components such as
activities, content providers, broadcast receivers, services etc.
It is generally used with startActivity() method to invoke activity, broadcast
receivers etc.
The dictionary meaning of intent is intention or purpose. So, it can be described as
the intention to do action.

Android intents are mainly used to:

● Start the service
● Launch an activity
● Display a web page
● Display a list of contacts
● Broadcast a message
● Dial a phone call etc.
Types of Android Intents

There are two types of intents in android: implicit and explicit.

1) Implicit Intent
Implicit Intent doesn't specifiy the component. In such case, intent provides
information of available components provided by the system that is to be invoked.
For example, you may write the following code to view the webpage.

2) Explicit Intent
Explicit Intent specifies the component. In such case, intent provides the external
class to be invoked.
Intent
Intent :

It mainly used to perform following task :

● Start an activity
● Start a service
● Delivery a broadcast
● Display a Webpage etc.
Activities

An activity represents a single screen with a user interface,in-short

Activity performs actions on the screen.
An activity is implemented as a subclass of Activity class as follows
−
public class MainActivity extends Activity {

}
Services
A service is a component that runs in the background to perform long-running
operations.

A service is implemented as a subclass of Service class as follows −

public class MyService extends Service {

Demo of Music Player Service

Broadcast Receivers
Broadcast Receivers simply respond to broadcast messages from other
applications or from the system.

A broadcast receiver is implemented as a subclass of BroadcastReceiver class

and each message is broadcaster as an Intent object.
public class MyReceiver extends BroadcastReceiver {

public void onReceive(context,intent){}

}
Content Providers
A content provider component supplies data from one application to others on
request. Such requests are handled by the methods of the ContentResolver class.
The data may be stored in the file system, the database or somewhere else entirely.
A content provider is implemented as a subclass of ContentProvider class and must
implement a standard set of APIs that enable other applications to perform
transactions.
public class MyContentProvider extends ContentProvider {
public void onCreate(){}
}
Additional Components
Fragments : Represents a portion of user interface in an Activity.
Views : UI elements that are drawn on-screen including buttons, lists forms
etc.
Layouts : View hierarchies that control screen format and appearance of the
views.
Intents : Messages wiring components together.
Resources : External elements, such as strings, constants and drawable
pictures.
Manifest : Configuration file for the application.
Activities, Fragments and Intents

Activity is an application component that gives a user interface where the user
can interact.

The fragment is only part of an activity, it basically contributes its UI to that

activity. Fragment is dependent on activity. It can't exist independently.

Intent, you can think of intention to do some work. It can be either go from one
activity to another activity, send email, open some links and so on.

Fragment is just like part of those activities. To make it simple you can think of
activities as full website page whereas fragment as a part of that website page.
Activities :

● Activity is one of the most important component for any android app.

● Activities are the User Interface (UI) screens which user see.

● It is similar to the main() function in different programming languages.

● Its is the main entry point for user interaction.

● You can have multiple activities in your app.

● All your activities must be declared in the manifest file, with their

attributes.
Every activity has different functions
throughout its life, onCreate(),
onStart(), onResume(), onPause(),
onStop(), onRestart(), onDestroy().
Intents :
Intent is one of the most important and most used app component of an
android application.
Using Intents, you call to other app components or to other activity or also call
other applications on your phone.
Intents are two types:
Explicit Intents where you call another activity or something with a class name.
For instance, you can call another activity when some action happened in one
activity. So you here explicitly specifies which activity to call.
Implicit Intents where we do not specify a class name but specify some sort of
action, which can be handled by some other inbuilt apps or some other apps.
For instance, you may want to open a camera, showing a map, sending emails
etc. Here you don’t directly call camera app or map app, you will just specify the
action.
Fragment
Android Fragment is the part of activity, it is also known as sub-activity. There can
be more than one fragment in an activity. Fragments represent multiple screen
inside one activity.
Android fragment lifecycle is affected by activity lifecycle because fragments are
included in activity.
Each fragment has its own life cycle methods that is affected by activity life cycle
because fragments are embedded in activity.
The FragmentManager class is responsible to make interaction between fragment
objects.
Refer for Life Cycle : https://www.javatpoint.com/android-fragments
Different types of layouts components

https://www.tutorialspoint.com/andr
oid/android_user_interface_layouts.
htm
Layout :
● 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.

● A View usually draws something the user can see and interact with.

● Whereas a ViewGroup is an invisible container that defines the layout structure for View and other

ViewGroup

● The View objects are usually called "widgets" and can be one of many subclasses, such as Button or

TextView.

● The ViewGroup objects are usually called "layouts" can be one of many types that provide a

different layout structure, such as LinearLayout or ConstraintLayout .

Different types of layouts components
1 Linear Layout : LinearLayout is a view group that aligns all children in a single
direction, vertically or horizontally.
2 Relative Layout : RelativeLayout is a view group that displays child views in relative
positions.
3 Table Layout : TableLayout is a view that groups views into rows and columns.
4 Absolute Layout : AbsoluteLayout enables you to specify the exact location of its
children.
5 Frame Layout The FrameLayout is a placeholder on screen that you can use to display
a single view.
6 List View ListView is a view group that displays a list of scrollable items.
7 Grid View :GridView is a ViewGroup that displays items in a two-dimensional,
scrollable grid.
Linear Layout
● Linear layouts are one of the simplest and most common types of layouts
used by Android developers to organize controls within their user
interfaces.
● The linear layout works much as its name implies: it organizes controls
linearly in either a vertical or horizontal fashion.
● When the layout’s orientation is set to vertical, all child controls within it
are organized in a single column; when the layout’s orientation is set to
horizontal, all child controls within it are organized in a single row.
Recall that, from within the Activity, only a single line of code within the onCreate() method is
necessary to load and display a layout resource on the screen. If the layout resource was
stored in the /res/layout/rainbow.xml file, that line of code would be:

Inside Activity:

setContentView(R.layout.rainbow);
Important Linear Layout Properties and Attributes
Some specific attributes apply to linear layouts. Some of the most important attributes you’ll use with
linear layouts include:

● The orientation attribute (required), which can be set to vertical or horizontal (class: LinearLayout)
● The gravity attribute (optional), which controls how all child controls are aligned and displayed
within the linear layout (class: LinearLayout)
● The layout_weight attribute (optional, applied to each child control) specifies each child control’s
relative importance within the parent linear layout (class: LinearLayout.LayoutParams)
Table Layout
In android, TableLayout is a ViewGroup
subclass that is used to display the child View
elements in rows and columns.

Following is the pictorial representation of table

layout in android applications.
RelativeLayout
● The Relative Layout is very flexible layout used in android for custom layout
designing. It gives us the flexibility to position our component/view based on the
relative or sibling component’s position. Just because it allows us to position the
component anywhere we want so it is considered as most flexible layout.
● For the same reason Relative layout is the most used layout after the Linear
Layout in Android. It allow its child view to position relative to each other or
relative to the container or another container.
● In Relative Layout, you can use “above, below, left and right” to arrange the
component’s position in relation to other component. For example, in the below
image you can see content is placed in related to Heading.
Difference Between Relative and Linear
RELATIVE LAYOUT:
● Every element of relative layout arranges itself to the other element or a parent
element.
● It is helpful while adding views one next to other etc
● In a relative layout you can give each child a Layout Property that specifies
exactly where it should go in relative to the parent or relative to other children.
● Views can be layered on top of each other.
LINEAR LAYOUT:
● In a linear layout, like the name suggests, all the elements are displayed in a
linear fashion either vertically or horizontally.
● Either Horizontally or Vertically this behavior is set in android:orientation which
is an property of the node Linear Layout.
android:orientation=”horizontal” or android:orientation=”vertical”
● Linear layouts put every child, one after the other, in a line, either horizontally
or vertically.
GridLayout
The number of rows and columns within the grid can be declared using the
android:rowCount and android:columnCount properties. Typically, however, if the number
of columns is declared the GridLayout will infer the number of rows based on the number of
occupied cells making the use of the rowCount property unnecessary.

Similarly, the orientation of the GridLayout may optionally be defined via the
android:orientation property. The following example XML declares a 2 x 2 GridLayout
configuration in horizontal orientation:
● A view can be placed within a specific cell by specifying the intersecting row and column number of the
destination cell. The following Button view will be placed in the cell and row 1, column 2 of the parent
GridLayout:

<Button
android:id="@+id/button5"
android:layout_column="2"
android:layout_row="1"
android:layout_gravity="left|top"
android:text="Button" />

● rowSpan or colspan ?
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.
Displaying picture and menus using views.
Android Gallery
Android Gallery is a widget. Unfortunately, this is deprecated in API 16. This view shows
items in a horizontal, centrally locked pattern. By default, Theme_galleryItemBackground
is used as background for each view which is given to the gallery via Adapter.
Gallery should use LayoutParams as type of layout parameters supplied to the views.
LayoutParams of views tell the parent view about their placing or position in respective
views.

Android ImageView and ImageSwitcher

Android ImageView is a class. This class can load images from various sources. It displays
an image as icon
Android Menus
In android, Menu is an important part of the UI component which is used to
provide some common functionality around the application. With the help of
menu, users can experience a smooth and consistent experience throughout
the application. In order to use menu, we should define it in a separate XML
file and use that file in our application based on our requirements. Also, we
can use menu APIs to represent user actions and other options in our android
application activities.
Three types of menus with which users are provided to perform some actions.
They are as follows:
1. Android Options Menu
2. Android Context Menu
3. Android Pop-up menu
Assignment No 1 : 20 marks

The android platform, the layers of android, Four kinds of android

components, understanding the androidManifest.xml file

Explain in details. Handwritten notes only

Module 2 : Basic Controls and UI
Components

- Shweta Waghmare,TIMSCDR
Topics
Module: Basic Controls and UI Components

Text view, Radio button, Checkbox, Image Button, Edit Text, Slider and other

controls

Self-Learning Topics: Methods of all control class

Basic Controls and UI Components
Android UI Controls are those components of Android that are used to design
the UI in a more interactive way.

It helps us to develop an application that makes user interaction better with

the view components.

Android provides us a huge range of UI controls of many types such as

buttons, text views, etc.
Android UI controls for our applications:

● TextView ● ProgressBar
● EditText ● Spinner
● Button ● TimePicker
● ImageButton ● DatePicker
● ToggleButton ● SeekBar
● RadioButton ● AlertDialog
● RadioGroup ● Switch
● CheckBox
● RatingBar
● AutoCompleteTextView
Application components
Application components are the essential building blocks of an Android application. These
components are loosely coupled by the application manifest file AndroidManifest.xml that
describes each component of the application and how they interact.

Four main components:

Activities : They dictate the UI and handle the user interaction to the smart phone screen

Services : They handle background processing associated with an application.

Broadcast Receivers :They handle communication between Android OS and applications.

Content Providers :They handle data and database management issues.

Practical - 1 : Write a program to demonstrate activity
life cycle.
 Activity Life Cycle
Activity instances in your app transition through different states in their lifecycle. The Activity class
provides a number of callbacks that let the activity know when a state changes or that the system is
creating, stopping, or resuming an activity or destroying the process the activity resides in.

Within the lifecycle callback methods, you can declare how your activity behaves when the user leaves
and re-enters the activity. For example, if you're building a streaming video player, you might pause the
video and terminate the network connection when the user switches to another app. When the user
returns, you can reconnect to the network and let the user resume the video from the same spot.

For example, good implementation of the lifecycle callbacks can help your app avoid the following:

● Crashing if the user receives a phone call or switches to another app while using your app.
● Consuming valuable system resources when the user is not actively using it.
● Losing the user's progress if they leave your app and return to it at a later time.
● Crashing or losing the user's progress when the screen rotates between landscape and portrait
orientation.
To navigate transitions between
stages of the activity lifecycle, the
Activity class provides a core set of
six callbacks: onCreate(), onStart(),
onResume(), onPause(), onStop(),
and onDestroy(). The system
invokes each of these callbacks as
the activity enters a new state.
onPause()
Called as part of the activity lifecycle when the user no longer actively interacts with the
activity, but it is still visible on screen. The counterpart to onResume().

When activity B is launched in front of activity A, this callback will be invoked on A. B will not
be created until A's onPause() returns, so be sure to not do anything lengthy here.
onStop()
● When Activity is in background then onPause() method will execute. After a millisecond of
that method next onStop() method will execute.
● Means here also Activity is not visible to user when onStop() executed.
● We will use onStop() method to stop Api calls etc. This onStop() method will
clean up all your activities resources.
MainActivity.Java
@Override
protected void onStart() {
super.onStart();
Log.d("lifecycle", "onStart invoked"); @Override
} protected void onRestart() {
super.onRestart();
Log.d("lifecycle", "onRestart invoked");
@Override
}
protected void onResume() {
super.onResume(); @Override
Log.d("lifecycle", "onResume invoked"); protected void onDestroy() {
} super.onDestroy();
Log.d("lifecycle", "onDestroy invoked");
@Override }
protected void onPause() {
super.onPause();
Log.d("lifecycle", "onPause invoked");
}

@Override
protected void onStop() {
super.onStop();
Log.d("lifecycle", "onStop invoked");
}
Linear Layout
LinearLayout is the most basic layout in android studio, that aligns all the children
sequentially either in a horizontal manner or a vertical manner by specifying the
android:orientation attribute.
If one applies android:orientation=”vertical” then elements will be arranged one after
another in a vertical manner and If you apply android:orientation=”horizontal” then
elements will be arranged one after another in a horizontal manner.
Practical - 2 : Design the following
User Interface using Linear Layout.
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.
To arrange them in a proper order we need to use the relative layout. To arrange them we need some
advanced properties. Basically, we use layout_width, layout_height, layout_text properties while
creating an application using the linear layout. But we need some more advanced properties which are
supported by relative layout. There are so many properties that are supported by relative layout. some
of the most used properties are listed below
● layout_alignParentTop
● layout_alignParentBottom
● layout_alignParentRight
● layout_alignParentLeft
● layout_centerHorozontal
● layout_centerVertical
● layout_above
● layout_below
Practical - 3 : Design the
following User Interface using
Relative Layout.
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.
TableLayout containers do not display border lines for their rows,
columns, or cells.
Practical - 4 Design the following
screen.
Frame Layout
Android Framelayout is a ViewGroup subclass that is used to specify the
position of multiple views placed on top of each other to represent a single
view screen.
Generally, we can say FrameLayout simply blocks a particular area on the screen
to display a single view. Here, all the child views or elements are added in stack
format means the most recently added child will be shown on the top of the
screen.
But, we can add multiple children’s views and control their positions only by
using gravity attributes in FrameLayout.
Practical - 5 Design a screen
which displays the frame image
and write a quote on that.
Practical - 7 Write a program to demonstrate radio buttons and checkboxes, Toggle button,Image
button.

Changes Required in Manifest file for allowing activity as main launcher

<activity
android:name=".OtherActivity"
android:exported="true">
<intent-filter>
<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />

</intent-filter>
</activity>
Intents :
Intent is one of the most important and most used app component of an
android application.
Using Intents, you call to other app components or to other activity or also call
other applications on your phone.
Intents are two types:
Explicit Intents where you call another activity or something with a class name.
For instance, you can call another activity when some action happened in one
activity. So you here explicitly specifies which activity to call.
Implicit Intents where we do not specify a class name but specify some sort of
action, which can be handled by some other inbuilt apps or some other apps.
For instance, you may want to open a camera, showing a map, sending emails
etc. Here you don’t directly call camera app or map app, you will just specify the
action.
Write a program to take user input from one activity and display it in another
activity(explicit)
Write a program to demonstrate implicit intent.
Android RadioButton with Examples

● Radio Button is a two-states button that can be either checked or unchecked and it’s the same
as CheckBox control, except that it will allow only one option to select from the group of options.
● The user can press or click on the radio button to make it select. In android, CheckBox control
allow users to change the state of control either Checked or Unchecked but the radio button
cannot be unchecked once it is checked.
● Generally, we can use RadioButton controls in an android application to allow users to select
only one option from the set of values.
● Following is the pictorial representation of using RadioButton control in android applications.
In android, we use radio buttons with in a RadioGroup to combine multiple radio buttons into
one group and it will make sure that users can select only one option from the group of multiple
options.

By default, the android RadioButton will be in OFF (Unchecked) state. We can change the
default state of RadioButton by using android:checked attribute.

In case, if we want to change the state of RadioButton to ON (Checked), then we need to set
android:checked = “true” in our XML layout file.
In android, we can create RadioButton control in two ways either in the XML layout file or create it in the Activity
file programmatically.
Create RadioButton in XML Layout File
Following is the sample way to define RadioButton control using RadioGroup in the XML layout file in the
android application.

<?xml version="1.0" encoding="utf-8"?>

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent" android:layout_height="match_parent">
<RadioGroup
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="vertical">
<RadioButton
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Java"
android:checked="true"/>
</RelativeLayout>
If you observe above code snippet, here we defined RadioButton control and setting RadioButton state ON using android:checked
attribute in xml layout file.
Create RadioButton Control in Activity File

In android, we can create RadioButton control programmatically in activity file based on our
requirements.
Following is the example of creating a RadioButton control dynamically in activity file.

LinearLayout layout = (LinearLayout)findViewById(R.id.l_layout);

RadioButton rd = new RadioButton(this);
rd.setText("Tutlane");
rd.setChecked(true);
layout.addView(rd);

This is how we can define RadioButton in XML layout file or programmatically in activity file based
on our requirements.
Handle Android RadioButton Click Events

Generally, whenever the user click on RadioButton to Select or Deselect the RadioButton object will
receives an on-click event.
In android, we can define RadioButton click event in two ways either in the XML layout file or create it in
Activity file programmatically.

Define RadioButton Click Event in XML Layout File

We can define click event handler for button by adding the android:onClick attribute to the
<RadioButton> element in our XML layout file.

The value of android:onClick attribute must be the name of the method which we need to call in
response to a click event and the Activity file which hosting XML layout must implement the corresponding
method.
Following is the example of defining a RadioButton click event using android:onClick attribute in XML layout file.

<?xml version="1.0" encoding="utf-8"?>

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent" android:layout_height="match_parent">
<RadioGroup
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="vertical">
<RadioButton
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Java"
android:onClick="onRadioButtonClicked"/>
</RadioGroup>
</RelativeLayout>
In Activity that hosts our XML layout file, we need to implement click event method like as shown below.

public void onRadioButtonClicked(View view) {

// Is the view now checked?
boolean checked = ((RadioButton) view).isChecked();
// Check which RadioButton was clicked
switch(view.getId()) {
case R.id.chk1:
if (checked)
// Do your coding
else
// Do your coding
break;
// Perform your logic
}
}
Define RadioButton Click Event in Activity File
In android, we can define RadioButton click event programmatically in Activity file rather than XML layout file.

To define RadioButton click event programmatically, create View.OnClickListener object and assign it to the
button by calling setOnClickListener(View.OnClickListener) like as shown below.

RadioButton rdb = (RadioButton) findViewById(R.id.radiobutton1);

rdb.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
boolean checked = ((RadioButton) v).isChecked();
// Check which radiobutton was pressed
if (checked){
// Do your coding
}
else{
// Do your coding
}
}
});
Android RadioButton Control Attributes
If you observe above code we created a multiple RadioButton controls, one TextView control and one Button
control in XML Layout file.

Once we are done with the creation of layout with required controls, we need to load the XML layout resource
from our activity onCreate() callback method, for that open main activity file MainActivity.java and write the
code like as shown in next…
For Other Component
https://www.tutlane.com/tutorial/android/android-radiobutton-with-examples
https://www.tutlane.com/tutorial/android/android-checkbox-with-examples
https://www.tutlane.com/tutorial/android/android-toggle-button-with-exampl
es
https://www.tutlane.com/tutorial/android/android-spinner-dropdown-list-with
-examples