Android Lab Manual

PRACTICAL JOURNAL OF
CSIT-606 Android Programming
BE: III Year
Department of Computer Science and Information Technology
Name : Garv Bhatt
Branch : CI
Section :1
Roll No. : 0827CI201067
Session : JAN-JUNE 2023
AITR, Indore.
Android Lab Manual Department of Computer Science and Information Technology

ACROPOLIS INSTITUTE OF TECHNOLOGY & RESEARCH, INDORE
Department of Computer Science Engineering
Certificate
This is to certify that the experimental work entered in this

journal as per the BE II year syllabus prescribed by the
RGPV was done by Ms. Garv Bhatt BE III year VI semester
CI in the Android Programming Laboratory of this institute
during the academic year 2022- 2023.
Signature of Faculty

Acropolis Institute of Technology and Research, Indore
.
CSIT Vision
To develop competent professionals to become a valuable source for industry, nation
and humanity by adapting industry inspired practices.
CSIT Mission
1. To strengthen industry collaboration for maximizing career opportunities ,
professional and entrepreneurship skills .
2. To improve employment marketability, positive attitude , communication skills
and learning agility.
3. To Facilitate value-based research and innovation for broadening knowledge,
skills and intellectual abilities

LAB INDEX
1. Introduction to android operating system and study of basic widgets.
2. Installation of Java JDK and Android
3. Study of UI in Android
4. Study of android lifecycle and demonstration of it.
5. Study of Android Layouts
6. Study of Intents in android
7. Study of android database (SQlite)
8. Create a basic application of Hello World on Constraint Layout
9. Create an application to add two numbers on Linear Layout
10. Create an application for calculator in Relative layout
11. Create an application for the registration page in Table Layout

Practical 1
Aim: Introduction to android
Objective: Student should get the knowledge of android operating system background.
Outcome: Student will be aware of the android operating system.
Android Architecture
Android operating system is a stack of software components which is roughly divided into five
sections and four main layers as shown below in the architecture diagram.
Linux kernel At the bottom of the layers is Linux - Linux 2.6 with approximately 115 patches.
This provides basic system functionality like process management, memory management, device
management like camera, keypad, display etc. Also, the kernel handles all the things that Linux is
really good at such as networking and vast array of device drivers, which take the pain out of
interfacing to peripheral hardware.
Libraries On top of Linux kernel there is a set of libraries including open -source Web browser
engine WebKit, well known library libc, SQLite database which is a useful repository for storage and
sharing of application data, libraries to play and record audio and video, SSL libraries responsible for
Internet security etc.
Android Runtime This is the third section of the architecture and available on the second layer
from the bottom. This section provides a key component called Dalvik Virtual Machine which is a
kind of Java Virtual Machine specially designed and optimized for Android.

The Dalvik VM makes use of Linux core features like memory management and multi-threading,
which is intrinsic in the Java language. The Dalvik VM enables every Android application to run in
its own process, with its own instance of the Dalvik virtual machine.
The Android runtime also provides a set of core libraries which enable Android application
developers to write Android applications using standard Java programming language.
Application Framework The Application Framework layer provides many higher-level services to
applications in the form of Java classes. Application developers are allowed to make use of these
services in their applications.
Applications You will find all the Android application at the top layer. You will write your
application to be installed on this layer only. Examples of such applications are Contacts Books,
Browser, Games etc.
Android UI An Android application user interface is everything that the user can see and interact
with. You have learned about the various layouts that you can use to position your views in an
activity. This chapter will give you detail on various views.
A View is an object that draws something on the screen that the user can interact with and a
ViewGroupis an object that holds other View (and ViewGroup) objects in order to define the layout
of the user interface.
You define your layout in an XML file which offers a human-readable structure for the layout,
similar to HTML.
Android UI Controls
There are number of UI controls provided by Android that allow you to build the graphical user
interface for your app.
UI Control & Description
TextView This control is used to display text to the user.
EditText EditText is a predefined subclass of TextView that includes rich editing

capabilities.
AutoCompleteTextVie The AutoCompleteTextView is a view that is similar to EditText, except that it

w shows a list of completion suggestions automatically while the user is typing.
Button A push-button that can be pressed, or clicked, by the user to perform an action.
ImageButton AbsoluteLayout enables you to specify the exact location of its children.
CheckBox An on/off switch that can be toggled by the user. You should use checkboxes
when presenting users with a group of selectable options that are not mutually
exclusive.
ToggleButton An on/off button with a light indicator.
RadioButton The RadioButton has two states: either checked or unchecked. RadioGroup

RadioGroup A RadioGroup is used to group together one or more RadioButtons.
ProgressBar The ProgressBar view provides visual feedback about some ongoing tasks, such
as when you are performing a task in the background.
Spinner A drop-down list that allows users to select one value from a set.
TimePicker The TimePicker view enables users to select a time of the day, in either 24-hour
mode or AM/PM mode.
DatePicker The DatePicker view enables users to select a date of the day.
Create UI Controls
As explained in previous chapter, a view object may have a unique ID assigned to it which will
identify the View uniquely within the tree. The syntax for an ID, inside an XML tag is:
android:id="@+id/text_id"
To create a UI Control/View/Widget you will have to define a view/widget in the layout file and
assign it a unique ID
Then finally create an instance of the Control object and capture it from the layout, use the
following:
TextView myText = (TextView) findViewById(R.id.text_id);
Android Event Handling
Events are a useful way to collect data about a user's interaction with interactive components of your
app, like button presses or screen touch etc. The Android framework maintains an event queue into
which events are placed as they occur and then each event is removed from the queue on a first-in,
first-out (FIFO) basis. You can capture these events in your program and take appropriate action as
per requirements.
There are following three concepts related to Android Event Management:
• Event Listeners: The View class is mainly involved in building up a Android GUI, same View
class provides a number of Event Listeners. The Event Listener is the object that receives
notification when an event happens.
• Event Listeners Registration: Event Registration is the process by which an Event Handler gets
registered with an Event Listener so that the handler is called when the Event Listener fires the
event.
• Event Handlers: When an event happens and we have registered and event listener fo the event,
the event listener calls the Event Handlers, which is the method that actually handles the event.

Event Listeners & Event Handlers
Event Handler Event Listener & Description

onClick() OnClickListener()
This is called when the user either clicks or touches or focuses upon any
widget like button,text, image etc. You will use onClick() event handler to
handle such event.
onLongClick() OnLongClickListener()
This is called when the user either clicks or touches or focuses upon any
widget like button, text, image etc. for one or more seconds. You will
use onLongClick() event handler to handle such event.
onFocusChange() OnFocusChangeListener()
This is called when the widget looses its focus ie.user goes away from the
view item. You will use onFocusChange() event handler to handle such
event.
onKey() OnFocusChangeListener()
This is called when the user is focused on the item and presses or releases a
hardware key on the device. You will use onKey() event handler to handle
such event.
onTouch() OnTouchListener()
This is called when the user presses the key, releases the key, or any
ovement gesture on the screen. You will use onTouch() event handler to
handle such event.
onMenuItemClick( OnMenuItemClickListener()
) This is called when the user selects a menu item.You will use
onMenuItemClick() event handler to handle such event.
There are many more event listeners available as a part of View class like OnHoverListener,
OnDragListener etc.

Practical 2
Installation of Java JDK and Android
How to Set Up Android Studio on Windows 10 and 11
Android Studio is fantastic, but it can be difficult to set up properly. Follow these steps and you'll
be good to go in no time.
Android Studio is one of the best programs for Android app development. It offers a plethora of
features and integrated tools for creating professional Android apps.
The program includes a feature-rich Android emulator, testing tools, and a consistent development
environment. In addition, it also features an intelligent code editor that provides you with advanced
code suggestions.
Due to many configuration steps, Android Studio may be challenging to set up if you're a novice
developer. Here, we show how to install Android Studio on Windows and create a sample
application.
How to Download and Install the Java JDK
Before installing Android Studio, you first need to install the Java JDK and set up the Java
environment to start working on it.
The Java Development Kit (JDK) is a required development package for creating Java-based
applications. Additionally, it also includes tools for developers for testing Java-coded applications.
Follow these steps to get the latest version of Java JDK for Windows and set it up:
1. Go to the official Oracle Java Downloads page.

2. Choose the most recent version of Java JDK and download the x64 MSI Installer under
the Windows tab.
3. Open the file you've just downloaded from the Downloads folder.
4. Follow the on-screen instructions to install the latest Java JDK.
Now that you've successfully installed JDK, you need to set up a Java environment so that Android
Studio can easily find the location of Java on your desktop.
Setting Up the Java Environment
Here are the steps you've to perform for setting up the Java environment:
1. Open Windows search and type "Edit environment variables."
2. Hit the Enter key to open the Environment Variables window.
3. Now, under the System variables section, click Path > Edit > New
4. Copy the path of the folder where the JDK binaries are installed. For example, in our case,
the path is C:\Program Files\Java\jdk-18.0.1.1\bin
5. Switch to the Environment variables window and paste the path you've copied and save
the changes.
6. Next, under the User Variables section, click New.
7. Add PATH_HOME in the variable name box and C:\Program Files\Java\jdk-18.0.1.1 in
the variable value box.
8. Finally, save the changes by clicking OK.

How to Install Android Studio on Windows
Follow these steps to download and install Android Studio for Windows:
1. Visit the Android Developers website and click on Download Android Studio.
2. Now, open the downloaded file to install Android Studio.
3. Click Next to continue installing Android Studio.
4. Further, click Install and wait while Android Studio is being installed on your PC.
5. Once done, click Finish to close the installer and start Android Studio.
6. Android Studio will now ask you to import settings. Click OK to continue to set up
Android Studio.
You should use SSD storage when working with Android Studio to get better performance and
faster processing.
If the installer crashes or closes with a random error code, the chances are that your PC doesn't
meet the minimum system requirements. For this, you must check the below-mentioned
requirements once.
The System Requirements for Android Studio on Windows

Your PC must meet the following requirements to run Android Studio efficiently:
 64-bit Microsoft Windows OS 8/10/11.

 1280 x 800 minimum screen resolution.
 x86_64 CPU architecture; 2nd generation Intel Core or newer; or AMD CPU with
Hypervisor support.
 8GB of RAM or more.
 12GB of available disc space is required (IDE + Android SDK + Android Emulator).
How to Set Up Android Studio on Windows
While you've installed Android Studio on your Windows PC, to create a new project you'll have
to configure the Setup Wizard. The Setup Wizard will help you create a development
environment for your future projects.
Follow these steps to set up Android Studio:
1. In the Setup Wizard window, select the Standard option to apply the recommended
settings and click Next.
2. Next, select a theme you want and click Next again to verify the settings you've
configured.
3. On the following screen, select Accept and click Finish to apply the changes.
4. Wait till the Setup Wizard downloads some required files. It may take somewhere around
15 to 30 minutes, depending on your network speed.
5. Once the download is completed, click Finish to complete the setup process.
If it gets stuck while downloading, it's because of either high CPU usage or interruption in
downloading. This is why you must close all the programs that may consume the internet or are
still running in the background.

How to Create a New Test Project in Android Studio
Now, that you've set up and configured Android Studio, follow these steps to run a test project
from scratch:
1. Open Android Studio and click New Project.

2. Select the Basic Activity option and click Next to proceed further.
3. On the next screen, type in a name for your app, and select the language (for example,
Java).
4. Next, select the Minimum SDK for your app. The Minimum SDK defines the minimum
Android version needed to run your test app.
5. Once done, click Finish to generate a new test project.
6. Finally, click Allow access on the next screen to allow ADB to access your public
network.
7. That's it. Now, you can make changes to your test project and build your Android app.
The first test project takes around 10-15 minutes to load all the files and sync the project using
Gradle (a build automation tool). Once it is done, you can interact with your app's project
structure and view different activities in Android Studio.
After making the changes to your project, you have many different options to run your test
app:
 Device Manager: You can create a new emulator from the device manager and run your
app on it. However, the emulator consumes a large number of resources, so we don't
recommend using this option if you're using a low-end PC.
 Pair Devices Using Wi-Fi: You can also run the test app on your Android smartphone.
The only condition here is that your smartphone and your PC should be connected to the
same Wi-Fi network.
 ADB Connection: Lastly, you can use a USB cable and turn on USB Debugging on your
phone to run your app via an ADB connection.

Practical 3
Aim: Study of UI in Android
Objective: Student should be able to design their own UI for android application using XML.
Outcome: Student will demonstrate the basic application using UI in android.
Create Android Application
The first step is to create a simple Android Application using Eclipse IDE. Follow the option
File → New → Project and finally select →Android New Application wizard from the wizard list.
Now name your application as HelloWorld using the wizard window as follows:
Next, follow the instructions provided and keep all other entries as default till the final step.
Once your project is created successfully, you will have following project screen:

Anatomy of Android Application
Before you run your app, you should be aware of a few directories and files in the Android
project:
Folder, File & Description
src
This contains the .java source files for your project. By default, it includes an MainActivity.java
source file having an activity class that runs when your app is launched using the app icon.
gen
This contains the .R file, a compiler-generated file that references all the resources found in
your project. You should not modify this file.
bin
This folder contains the Android package files .apk built by the ADT during the build process
and everything else needed to run an Android application.
res/drawable-hdpi
This is a directory for drawable objects that are designed for high-density screens.
res/layout
This is a directory for files that define your app's user interface.
res/values
This is a directory for other various XML files that contain a collection of resources, such as
strings and colors definitions.
AndroidManifest.xml
This is the manifest file which describes the fundamental characteristics of the app and defines
each of its components.

Following section will give a brief overview few of the important application files.
The Main Activity File
The main activity code is a Java file MainActivity.java. This is the actual application file which
ultimately gets converted to a Dalvik executable and runs
your application. Following is the default code generated by the application wizard for
Hello World! Application:
package com.example.helloworld;
import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;
import android.view.MenuItem;
import android.support.v4.app.NavUtils;
public class MainActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState)
{ super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
@Override
public boolean onCreateOptionsMenu(Menu menu)
{ getMenuInflater().inflate(R.menu.activity_main, menu); return true;
}
}
Here, R.layout.activity_main refers to the activity_main.xml file located in the res/layout folder.
TheonCreate() method is one of many methods that are fired when an activity is loaded.
The Manifest File
Whatever component you develop as a part of your application, you must declare all its
components in a manifest file called AndroidManifest.xml which ressides
at the root of the application project directory. This file works as an interface between Android
OS and your application, so if you do not declare your component in this file, then it will not be
considered by the OS. For example, a default manifest file will look like as following file:
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.helloworld"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk
android:minSdkVersion="8"
android:targetSdkVersion="15" />
<application
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >

<activity
android:name=".MainActivity" android:label="@string/title_activity_main" > <intent-filter>
<action android:name="android.intent.action.MAIN" /> <category
android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
</activity>
</application>
</manifest>
Here <application>...</application> tags enclosed the components related to the application.

Attributeandroid:icon will point to the application icon available under res/drawable-hdpi. The
application uses the image named ic_launcher.png located in the drawable folders
The <activity> tag is used to specify an activity and android:name attribute specifies the fully
qualified class name of the Activity subclass and the android:label attributes specifies a string to
use as the label for the activity. You can specify multiple activities using <activity> tags.
The action for the intent filter is named android.intent.action.MAIN to indicate that this activity
serves as the entry point for the application. The category for the intent-filter is
namedandroid.intent.category.LAUNCHER to indicate that the application can be launched from
the device's launcher icon.
The @string refers to the strings.xml file explained below. Hence, @string/app_name refers to
theapp_name string defined in the strings.xml fi le, which is "HelloWorld". Similar way, other
strings get populated in the application.
Following is the list of tags which you will use in your manifest file to specify different
Android application components:
<activity>elements for activities

<service> elements for services
<receiver> elements for broadcast receivers
<provider> elements for content providers
The Strings File
The strings.xml file is located in the res/values folder and it contains all the text that your
application uses. For example, the names of buttons, labels, default text, and similar types of
strings go into this file. This file is responsible for their textual content. For example, a default
strings file will look like as following file:
<resources>
<string name="app_name">HelloWorld</string>
<string name="hello_world">Hello world!</string> <string
name="menu_settings">Settings</string> <string
name="title_activity_main">MainActivity</string>
</resources>

The R File
The gen/com.example.helloworld/R.java file is the glue between the activity Java files
likeMainActivity.java and the resources like strings.xml. It is an automatically generated file and
you should not modify the content of the R.java file. Following is a sample of R.java file:
/* AUTO-GENERATED FILE. DO NOT MODIFY

package com.example.helloworld;
public final class R {
public static final class attr {
}
public static final class dimen {
public static final int padding_large=0x7f040002; public static

final int padding_medium=0x7f040001; public static final int
padding_small=0x7f040000;
}
public static final class drawable {
public static final int ic_action_search=0x7f020000; public static
final int ic_launcher=0x7f020001;
}
public static final class id {
public static final int menu_settings=0x7f080000;
}
public static final class layout {
public static final int activity_main=0x7f030000;
}
public static final class menu {
public static final int activity_main=0x7f070000;
}
public static final class string {
public static final int app_name=0x7f050000; public static final int
hello_world=0x7f050001; public static final int
menu_settings=0x7f050002; public static final int
title_activity_main=0x7f050003;
}
public static final class style {
public static final int AppTheme=0x7f060000;
}
}
The Layout File

The activity_main.xml is a layout file available in res/layout directory, that is referenced by your
application when building its interface. You will modify this file very frequently to change the
layout of your application. For your "Hello World!" application, this file will have following
content related to default layout:
<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent" >

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_centerVertical="true"
android:padding="@dimen/padding_medium"
android:text="@string/hello_world"
tools:context=".MainActivity" />
</RelativeLayout>
The TextView is an Android control used to build the GUI and it have various attribuites like
android:layout_width,android:layout_height etc which are being used to set its width and height
etc. The @string refers to the strings.xml file located in the res/values folder. Hence,
@string/hello_world refers to the hello string defined in the strings.xml fi le, which is "Hello
World!".
Running the Application
Let's try to run our Hello World! application we just created. I assume you had created your
AVD while doing environment setup. To run the app from Eclipse, open one of your project's
activity files and click Run icon from the toolbar. Eclipse installs the app on your AVD and
starts it and if everything is fine with your setup and application, it will display following
Emulator window:

Practical 4
Aim: Develop an application demonstrating Activity Life Cycle
Objective: Student should get the knowledge of developing an application android activity
lifecycle.
Outcome: Student will create application for Activity lifecycle
Android Activity Lifecycle is controlled by 7 methods of android.app.Activity class. The

android Activity is the subclass of ContextThemeWrapper class.
An activity is the single screen in android. It is like window or frame of Java. By the help of
activity, you can place all your UI components or widgets in a single screen. The 7 lifecycle
method of Activity describes how activity will behave at different states.
Android Activity Lifecycle methods

Method Description
onCreate called when activity is first created.
onStart called when activity is becoming visible to the user.
onResume called when activity will start interacting with the user.
onPause called when activity is not visible to the user.
onStop called when activity is no longer visible to the user.
onRestart called after your activity is stopped, prior to start.
onDestroy called before the activity is destroyed.

File: activity_main.xml
1. <?xml version="1.0" encoding="utf-8"?>
2. <android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/
android"
3. xmlns:app="http://schemas.android.com/apk/res-auto"
4. xmlns:tools="http://schemas.android.com/tools"
5. android:layout_width="match_parent"
6. android:layout_height="match_parent"
7. tools:context="example.javatpoint.com.activitylifecycle.MainActivity">
8. <TextView
android:text="Hello World!"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintLeft_toLeftOf="parent"
app:layout_constraintRight_toRightOf="parent"
app:layout_constraintTop_toTopOf="parent" />
</ android.support.constraint.ConstraintLayout>
Android Activity Lifecycle Example

It provides the details about the invocation of life cycle methods of activity. In this example, we
are displaying the content on the logcat.
File: MainActivity.java
1. package example.javatpoint.com.activitylifecycle;
2. import android.app.Activity;
3. import android.os.Bundle;
4. import android.util.Log;
5. public class MainActivity extends Activity {
6. @Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Log.d("lifecycle","onCreate invoked"); }
@Override
protected void onStart() {
super.onStart();
Log.d("lifecycle","onStart invoked"); }
@Override
protected void onResume() {
super.onResume();
Log.d("lifecycle","onResume invoked"); }
@Override
protected void onPause() {
super.onPause();
Log.d("lifecycle","onPause invoked"); }
@Override

protected void onStop() {
super.onStop();
Log.d("lifecycle","onStop invoked"); }
@Override
protected void onRestart() {
super.onRestart();
Log.d("lifecycle","onRestart invoked"); }
@Override
protected void onDestroy() {
super.onDestroy();
Log.d("lifecycle","onDestroy invoked"); } }
Output:
You will not see any output on the emulator or device. You need to open logcat.
Now see on the logcat: onCreate, onStart and onResume methods are invoked.

Now see on the emulator. It is on the home. Now click on the center button to launch the app
again. Now click on the lifecycle activity icon.
Now see on the logcat: onRestart, onStart and onResume methods are invoked.

If you see the emulator, application is started again.
Now click on the back button. Now you will see onPause methods is invoked.
Now click on the back button. Now you will see onPause methods is invoked.
After a while, you will see onStop and onDestroy methods are invoked.
*** The onCreate() and onDestroy() methods are called only once throughout the activity
lifecycle.
Practical 5

Aim: Android Layouts
Android Linear Layout
Android LinearLayout is a view group that aligns all children in either vertically or horizontally.
Modify the default content of res/layout/activity_main.xml file to include a few buttons in linear
layout.
No need to change string Constants.Android studio takes care of default strings
Run the application to launch the Android emulator and verify the result of the changes done in
the application.
Example 1
activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<Button android:id="@+id/btnStartService"
android:layout_width="270dp"
android:text="Start"/>
<Button android:id="@+id/btnPauseService"
android:text="Pause"/>
<Button android:id="@+id/btnStopService"
android:text="Stop"/>
</LinearLayout>

Example 2
android:layout_height="fill_parent"
android:orientation="vertical" >
<TextView android:id="@+id/text"
android:text="Nisha_Text_Demo" />
<Button android:id="@+id/button"
android:text="Nisha_Button_Demo" />

</LinearLayout>

Android Relative Layout
Android Relative Layout 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

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_height="match_parent"
tools:context=".MainActivity">
<TextView
android:id="@+id/txt_instruction"
android:text="Relative view Demo"
android:gravity="center"/>
<TextView
android:id="@+id/txt_1"
android:layout_marginTop="10dp"
android:layout_below="@+id/txt_instruction"
android:text="Enter User Name"/>
<EditText
android:id="@+id/txt_price"

android:layout_below="@id/txt_instruction"
android:layout_alignParentRight="true"
android:text="Nisha" />
<TextView
android:layout_below="@+id/txt_1"
android:text="Enter Password"/>
<EditText
android:id="@+id/txt_cash_down_payment"
android:layout_marginTop="-10dp"
android:layout_below="@id/txt_price"
android:layout_alignParentRight="true"
android:text="Nisha123" />
<TextView
android:layout_below="@+id/txt_2"
android:text="Enter Semester"/>

<RadioGroup
android:id="@+id/select_year"
android:orientation="vertical"
android:layout_centerInParent="true"
android:layout_below="@+id/txt_cash_down_payment">
<RadioButton
android:id="@+id/year2"
android:text="I sem"
android:layout_height="wrap_content"/>
<RadioButton
android:text="II sem"
<RadioButton

android:text="III sem"
</RadioGroup>
<TextView
android:layout_below="@+id/select_year"
android:text="Press below button to confirm submission"/>
<Button
android:id="@+id/button_loanReport"
android:layout_below="@id/txt_3"
android:text="Submit"
/>
</RelativeLayout>

Android Table Layout
Android TableLayout is going to arrange 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 xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_height="fill_parent">
<TableRow
<TextView
android:text="Time"
android:layout_column="1" />
<TextClock
android:id="@+id/textClock"
</TableRow>
<TableRow>
<TextView
android:text="First Name"
<EditText
android:width="200px"
android:layout_height="wrap_content" />
</TableRow>
<TableRow>
<TextView
android:text="Last Name"

<EditText
android:width="100px"
android:layout_height="wrap_content" />
</TableRow>
<TableRow
<RatingBar
android:id="@+id/ratingBar"
</TableRow>
<TableRow
android:layout_height="fill_parent"/>
<TableRow
<Button
android:text="Submit"
android:id="@+id/button"
</TableRow>
</TableLayout>

Practical 6
Aim: Study of Intents in android
Objective: Student should know what is intent in android and whatare the types of it.
Outcome: Student will develop a good application using the intents and its properties efficiently
An intent is a messaging object used to request any action from another app component. Intents
facilitate communication between different components in several ways. The intent is used to
launch an activity, start the services, broadcast receivers, display a web page, dial a phone call,
send messages from one activity to another activity, and so on.
Type Of Intent
Explicit Intent: Explicit intents are communicated between two activities inside the same
application. We can use explicit intents when we need to move from one activity to another
activity.
Example:- when a user wants to start a service to download a file or when a new activity gets
started in response to a user action.
//Explicit Intent
Intent send = new Intent(FirstActivtiy.this,
SecondActivity.class);
//Starts TargetActivity
startActivity(send);
activity_main.xml
tools:context="com.example.application.myapplication.MainActivity">
<TextView
android:id="@+id/textView"

android:text="This is First Activity" />

<Button
android:layout_below="@id/textView"
android:text="GO TO OTHER ACTIVITY" />
</RelativeLayout>
activity_2.xml


tools:context="com.example.application.myapplication.Activity2">

<TextView
android:text="This is Second Activity " />
<Button
android:layout_below="@id/textView"
android:text="open activity 2" />
</RelativeLayout>
MainActivity.Java
} package com.example.application.myapplication;
import android.content.Intent;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
public class MainActivity extends AppCompatActivity {

private Button button;
@Override

button = (Button) findViewById(R.id.button);

button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
openActivity2();
}
});
}
public void openActivity2() {

//Explicit Intent
Intent intent = new Intent(this, Activity2.class);
startActivity(intent);
}
Activity2.Java
package com.example.application.myapplication;
public class Activity2 extends AppCompatActivity {

private Button button;
@Override
setContentView(R.layout.activity_2);
button = (Button) findViewById(R.id.button);
button.setOnClickListener(new View.OnClickListener() {
@Override
// Back to the MainActivity
openActivity1();
}
});
}
public void openActivity1() {
//Explicit Intent
Intent intent = new Intent(this, MainActivity.class);
}
}

Output:-
Implicit Intent: Implicit intent is communicated between two activities of an application. One
thing to note here is we should not name a specific component. In place of that we can declare a
general action to perform which allows a component from another app to handle it.
Example:- To show the user a location on a map, we can use an implicit intent.
//Implicit intent
Intent intent = new Intent();
intent.setAction(android.content.Intent.ACTION_VIEW);
intent.setData(Contract.Contacts.CONTENT_URL);
activity_main.xml
< ? xml versiоn = "1.0"

enсоding = "utf-8" ? >
<
!--асtivity_mаin-- >
<
RelаtiveLаyоut xmlns : аndrоid = "httр://sсhemаs.аndrоid.соm/арk/res/аndrоid" < !--аndrоid-- >
<
!--defаult lаyоut struсture-- >
xmlns: tооls = "httр://sсhemаs.аndrоid.соm/tооls" < !--tооls-- >
xmlns: арр = "httр://sсhemаs.аndrоid.соm/арk/res-аutо" < !--арр-- >
tооls: соntext = "соm.exаmрle.imрliсitintent.MаinАсtivity"

аndrоid: lаyоut_width = "mаtсh_раrent" < !--fоr width-- >
аndrоid: lаyоut_height = "mаtсh_раrent" < !--fоr height-- > >
<
!--inрut field fоr writing website nаme-- >
<
EditText <
!--fоr inрut field-- >
аndrоid: id = "@+id/editText" < !--edittext id nаme-- >
аndrоid: lаyоut_width = "wrар_соntent" < !--fоr width-- >
аndrоid: lаyоut_height = "wrар_соntent" < !--fоr height-- > аndrоid: lаyоut_mаrginEnd = "7dр"
< !--mаrgin аt the end-- >
аndrоid: lаyоut_mаrginStаrt = "7dр" < !--mаrgin аt the stаrt-- >
аndrоid: lаyоut_mаrginTор = "70dр" < !--mаrgin аt the tор-- >
аndrоid: ems = "9" <
!--fоr аlignment-- >
аndrоid: lаyоut_аlignРаrentTор = "true"
аndrоid: lаyоut_сenterHоrizоntаl = "true" /
>
<
!--Орen webраge-- >
< Buttоn аndrоid: id = "@+id/buttоn" < !--buttоn id nаme-- >
аndrоid: lаyоut_width = "wrар_соntent" < !--fоr width-- >
аndrоid: lаyоut_height = "wrар_соntent" < !--fоr height-- >

<EditText
android:id="@+id/idEdtNumber1"
android:layout_margin="20dp"
android:hint="Enter First Number"

android:inputType="number"
android:textColor="@android:color/black" />

<EditText
android:id="@+id/idEdtNumber2"
android:hint="Enter Second Number"
android:textColor="@android:color/black" />

<Button
android:id="@+id/idBtnAdd"
android:padding="4dp"
android:text="Add"
android:textAllCaps="false"
app:background="@color/black"
app:backgroundTint="@color/black" />

<TextView
android:id="@+id/idTVSum"

android:layout_gravity="center"
android:text="Sum"
android:textAlignment="center"
android:textColor="@android:color/black"
android:textSize="20sp"
android:textStyle="bold" />
</LinearLayout>
MainActivity.java
package com.example.Garv_layout;
import androidx.appcompat.app.AppCompatActivity;
import android.util.Log;
import android.widget.TextView;
import android.widget.Toast;
import org.w3c.dom.Text;
// on below line creating a variables for edit text, button and text
views.

private EditText numberOneEdt, numberTwoEdt;
private Button addBtn;
private TextView sumTV;
@Override
// on below line initializing variables.
numberOneEdt = findViewById(R.id.idEdtNumber1);
numberTwoEdt = findViewById(R.id.idEdtNumber2);
addBtn = findViewById(R.id.idBtnAdd);
sumTV = findViewById(R.id.idTVSum);
// adding click listener for button on below line.
addBtn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
// on below line checking if edit text is empty or not.
if (!numberOneEdt.getText().toString().isEmpty() && !
numberTwoEdt.getText().toString().isEmpty()) {
// on below line getting num1 and num2 from our edit text
int num1 =
Integer.parseInt(numberOneEdt.getText().toString());
int num2 =
Integer.parseInt(numberTwoEdt.getText().toString());
// on the below line getting sum to it.
int sum = num1 + num2;
// on the below line setting sum to it for text view.
sumTV.setText(String.valueOf(sum));

} else {
// on below line displaying toast message if the edit text

is empty
Toast.makeText(MainActivity.this, "Please enter both

numbers..", Toast.LENGTH_SHORT).show();
});
Output:

3. Create an application for calculator in Relative layout.
Activity_main.xml
android:id="@+id/activity_main"
android:paddingBottom="@dimen/activity_vertical_margin"

android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context="abhiandroid.com.calculater.MainActivity"
android:gravity="top"
android:textAlignment="center"
android:background="@android:color/holo_blue_bright"
android:weightSum="1">
<TextView
android:text="@string/enter_two_numbers"
android:layout_height="30dp"
android:gravity="center_horizontal"
android:textColorLink="?android:attr/editTextColor"
tools:textStyle="bold|italic"
android:visibility="visible"
android:layout_weight="0.07" />
android:textStyle="bold|italic"
android:fontFamily="serif"
<EditText
android:ems="10"

android:id="@+id/editOp1"
android:layout_marginBottom="5dp"
android:visibility="visible" />
<EditText
android:ems="10"
android:id="@+id/editOp2"
android:elevation="1dp" />
<LinearLayout
android:orientation="horizontal"
android:layout_height="wrap_content">
<Button
android:text="+"
android:id="@+id/btnadd"
<Button

android:text="-"
android:id="@+id/btnsub"
<Button
android:text="*"
android:id="@+id/btnmul"
android:layout_weight="0.03"/>
<Button
android:text="/"
android:id="@+id/btndiv"
<Button
android:text="Clear"
android:id="@+id/btnclr"
</LinearLayout>
<TextView

android:text="@string/result"
android:id="@+id/textView1"
android:layout_height="50dp"
android:textColorLink="?android:attr/editTextColor"
tools:textStyle="bold|italic"
android:textStyle="bold|italic"
android:fontFamily="serif"
android:visibility="visible"
android:textSize="30sp" />
<EditText
android:ems="10"
android:id="@+id/result"
android:text="0.00"
android:gravity="center_horizontal" />
</LinearLayout>
Main_Activity.java
package com.example.calculatora1;

import android.widget.TextView;
private EditText opr1;
private EditText opr2;
private Button btnadd;
private Button btnsub;
private Button btnmul;
private Button btndiv;
private Button btnclr;
private TextView txtresult;
@Override
opr1 = (EditText) findViewById(R.id.editOp1);
opr2 = (EditText) findViewById(R.id.editOp2);
btnadd = (Button) findViewById(R.id.btnadd);
btnsub = (Button) findViewById(R.id.btnsub);
btnmul = (Button) findViewById(R.id.btnmul);
btndiv = (Button) findViewById(R.id.btndiv);

btnclr = (Button) findViewById(R.id.btnclr);
txtresult= (TextView) findViewById(R.id.result);
// Addition
btnadd.setOnClickListener(new View.OnClickListener() {
@Override
if((opr1.getText().length()>0) && (opr2.getText().length()>0))
double oper1 =
Double.parseDouble(opr1.getText().toString());
double oper2 =
double result = oper1 + oper2;
txtresult.setText(Double.toString(result));
else{
Toast toast= Toast.makeText(MainActivity.this,"Enter The

Required Numbers",Toast.LENGTH_LONG);
toast.show();
});
//Subtraction
btnsub.setOnClickListener(new View.OnClickListener() {
@Override
double oper1 =

double oper2 =
double result = oper1 - oper2;
else{

toast.show();
});
// Multiplication
btnmul.setOnClickListener(new View.OnClickListener() {
@Override
double oper1 =
double oper2 =
double result = oper1 * oper2;
else{

toast.show();

}
});
// Division
btndiv.setOnClickListener(new View.OnClickListener() {
@Override
double oper1 =
double oper2 =
double result = oper1 / oper2;
else{

toast.show();
});
// Reset Feilds
btnclr.setOnClickListener(new View.OnClickListener() {
@Override
opr1.setText("");
opr2.setText("");
txtresult.setText("0.00");
opr1.requestFocus();

}
});
Output:
4. Create an application for the registration page in Table Layout
Activity_main.xml
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:background="#000"
android:stretchColumns="1">
<TextView
<TableRow android:padding="5dip">

<TextView
android:layout_marginBottom="20dp"
android:layout_span="2"
android:text="@string/loginForm"
android:textColor="#0ff"
</TableRow>
<TableRow>
<TextView
android:layout_column="0"
android:layout_marginLeft="10dp"
android:text="@string/userName"
android:textColor="#fff"
<EditText
android:id="@+id/userName"
android:background="#fff"
android:hint="@string/userName"
android:textColor="#000" />
</TableRow>
<TableRow>
<TextView
android:text="@string/password"
android:textColor="#fff"
<EditText
android:id="@+id/password"
android:background="#fff"
android:hint="@string/password"
android:textColor="#000" />
</TableRow>
<TableRow android:layout_marginTop="20dp">

<Button
android:id="@+id/loginBtn"
android:layout_gravity="center"
android:layout_span="2"
android:background="#0ff"
android:text="@string/login"
android:textColor="#000"
</TableRow>
</TableLayout>
Main_Activity.java
package com.example.loginregister;
import android.view.Menu;
import android.view.MenuItem;
@Override
// initiate a button
Button loginButton = (Button) findViewById(R.id.loginBtn);
// perform click event on the button
loginButton.setOnClickListener(new View.OnClickListener() {
@Override
Toast.makeText(getApplicationContext(), "Hello world..!!!",
Toast.LENGTH_LONG).show(); // display a toast message
}
});
}
strings.xml
<resources>
<string name="app_name">TableLayoutExample</string>

<string name="hello_world">Hello world!</string>
<string name="action_settings">Settings</string>
<string name="loginForm">Login Form</string>
<string name="userName">UserName</string>
<string name="password">Password</string>
<string name="login">LogIn</string>
</resources>

Android Lab Manual

Uploaded by

Copyright:

Available Formats

Android Lab Manual

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Android Lab Manual

Uploaded by

Copyright:

Available Formats

PRACTICAL JOURNAL OF

CSIT-606 Android Programming

BE: III Year

Department of Computer Science and Information Technology

Name : Garv Bhatt

Roll No. : 0827CI201067

Session : JAN-JUNE 2023

Department of Computer Science and Information Technology

Android Lab Manual Department of Computer Science and Information Technology

This is to certify that the experimental work entered in this

Android Lab Manual Department of Computer Science and Information Technology

Android Lab Manual Department of Computer Science and Information Technology

1. Introduction to android operating system and study of basic widgets.

2. Installation of Java JDK and Android

4. Study of android lifecycle and demonstration of it.

5. Study of Android Layouts

6. Study of Intents in android

7. Study of android database (SQlite)

8. Create a basic application of Hello World on Constraint Layout

9. Create an application to add two numbers on Linear Layout

10. Create an application for calculator in Relative layout

11. Create an application for the registration page in Table Layout

Android Lab Manual Department of Computer Science and Information Technology

Aim: Introduction to android

Outcome: Student will be aware of the android operating system.

Android Lab Manual Department of Computer Science and Information Technology

EditText EditText is a predefined subclass of TextView that includes rich editing

AutoCompleteTextVie The AutoCompleteTextView is a view that is similar to EditText, except that it

Android Lab Manual Department of Computer Science and Information Technology

TextView myText = (TextView) findViewById(R.id.text_id);

Android Event Handling

There are following three concepts related to Android Event Management:

Android Lab Manual Department of Computer Science and Information Technology

Event Handler Event Listener & Description

Android Lab Manual Department of Computer Science and Information Technology

Installation of Java JDK and Android

How to Set Up Android Studio on Windows 10 and 11

How to Download and Install the Java JDK

1. Go to the official Oracle Java Downloads page.

Setting Up the Java Environment

Android Lab Manual Department of Computer Science and Information Technology

The System Requirements for Android Studio on Windows

 64-bit Microsoft Windows OS 8/10/11.

How to Set Up Android Studio on Windows

Android Lab Manual Department of Computer Science and Information Technology

1. Open Android Studio and click New Project.

Android Lab Manual Department of Computer Science and Information Technology

Aim: Study of UI in Android

Outcome: Student will demonstrate the basic application using UI in android.

Create Android Application

Android Lab Manual Department of Computer Science and Information Technology

Folder, File & Description

Android Lab Manual Department of Computer Science and Information Technology

The Main Activity File

The Manifest File

Android Lab Manual Department of Computer Science and Information Technology

Here <application>...</application> tags enclosed the components related to the application.

<activity>elements for activities

The Strings File

Android Lab Manual Department of Computer Science and Information Technology