MOBILE APPLICATION DEVELOPMENT

Problem Statement 1: Login Application with Menu-Based Fragment Navigation

Design and develop an Android application that starts with a Login Screen using RelativeLayout. The
login screen must contain:
 An EditText for Username
 An EditText for Password
 A Login Button
Apply appropriate layout rules so that all components are properly aligned and visually appealing.
After entering a valid username and password, when the user taps the Login button, the application
must navigate to a Home Fragment.
The Home Fragment should contain:
 A Menu Button
 A Logout Button
When the user clicks the Menu Button, a Menu Fragment must open. This Menu Fragment should
display clickable images representing different sections of the application such as Home and Profile.
When the user selects Profile, the application should navigate to a Profile Fragment that displays:
 Profile picture using ImageView
 Name and details using TextView
Clicking the Logout Button should navigate back to the Login Screen.
Use Fragment Transactions for navigation, apply styles and themes, store login status
using SharedPreferences, validate user input, and display error messages for invalid credentials.
Problem Statement 2: Scientific Calculator Application
Design and develop an Android application that works as a Scientific
Calculator using LinearLayout as the main layout structure. The application must be capable of
performing both basic arithmetic operations and scientific mathematical operations.
User Interface Requirements
1. The calculator screen should contain:
 A TextView at the top to display the entered mathematical expression and the
calculated result.
 Multiple Buttons arranged using LinearLayout for numeric inputs and operators.
2. The calculator must include buttons for the following basic arithmetic operations:
 Addition (+)
 Subtraction (−)
 Multiplication (×)
 Division (÷)
3. The calculator must also support the following scientific operations:
 Trigonometric functions: Sine (sin), Cosine (cos), Tangent (tan)
 Logarithmic function (log)
 Square Root (√)
 Factorial (!)
4. Numeric buttons (0–9) and a decimal point (.) must be provided to allow decimal
calculations.
Problem Statement 3: Hello Toast and Counter Application
Design and develop an Android application that demonstrates basic user interaction, event handling,
and activity lifecycle awareness. The application should consist of two Buttons and one TextView,
arranged using a suitable layout such as LinearLayout.
The user interface must include:
1. A TextView to display a numeric counter value, which should be initialized to zero (0) when
the application starts.
2. A Button that, when clicked, displays a Toast message with the text “Hello Android”.
3. A second Button that, when clicked, increments the counter value displayed in the TextView
by one.
The application must handle button click events using appropriate onClick listeners, ensuring that
each button performs its intended action correctly. The counter value should update dynamically on
the screen every time the increment button is pressed.
Additionally, explain how activity lifecycle methods such
as onCreate(), onStart(), onResume(), onPause(), and onDestroy() influence the behavior of the user
interface, particularly during events like application launch, backgrounding, and screen rotation.

Problem Statement 4: Silent Mode Toggle Application

Design and develop an Android application that allows the user to toggle the mobile phone’s ringer
mode between Silent Mode and Normal Mode using a single button. The application should be
implemented using a suitable layout such as LinearLayout.
The user interface must include:
1. A Button that toggles the phone’s ringer state when clicked.
 2. A TextView that displays the current ringer mode of the device (for example, Silent
Mode or Normal Mode).
When the user presses the button:
 If the phone is currently in Normal Mode, it should be switched to Silent Mode.
 If the phone is currently in Silent Mode, it should be switched back to Normal Mode.
The application must access and control the device’s audio settings using appropriate system services.
Handle all required permissions properly and ensure that the application responds smoothly without
crashing. The TextView should update dynamically to reflect the current ringer mode after each toggle
operation.

Problem Statement 5: Two Activities Data Passing Application

Design and develop an Android application that demonstrates communication between two
activities using Explicit Intents. The application should consist of two separate activities.
The first activity must include:
1. An EditText field that allows the user to enter a text message.
2. A Send Button that initiates navigation to the second activity.
When the user enters a message and clicks the Send button, the entered text should be passed from the
first activity to the second activity using an Explicit Intent.
The second activity must:
1. Display the received message using a TextView.
2. Include a Reply Button that allows the user to send a response message back to the first
activity.
When the Reply button is clicked, the response should be transferred back to the first activity using an
Intent, and the received reply should be displayed on the first activity screen. The application should
ensure smooth navigation between activities and proper handling of user input.
Problem Statement 6: Implicit Intent Demonstration Application
Design and develop an Android application that demonstrates the use of Implicit Intents for
performing common system-level actions. The application should consist of a single activity
containing three Buttons, each representing a different action.
The user interface must include:
1. A Button labeled “Open Website” that opens a specified website in the device’s default web
browser.
2. A Button labeled “Open Location” that opens a specified geographic location in Google
Maps.
3. A Button labeled “Share Text” that allows the user to share a predefined text message using
any compatible application available on the device (such as messaging or email apps).
Each button click should trigger its corresponding action using an Implicit Intent, allowing the
Android system to choose the appropriate application to handle the request. The application should
clearly demonstrate how implicit intents are used to interact with other applications without explicitly
specifying the target component. Ensure proper handling of user actions and smooth execution of all
intent-based operations.
Problem Statement 7: Cafe Food Ordering Application
Design and develop a simple food ordering Android application that allows users to select food items
by interacting with images. The application should demonstrate image-based user interaction, Toast
messages, and activity navigation.
The user interface must include:
1. Multiple ImageView components representing different food items (such as Donut, Ice
Cream, and Froyo).
2. A Cart Icon or Button that allows the user to proceed to the next activity.
When the user clicks on any food item image:
 The application should display a Toast message indicating the name of the selected food item.
When the user clicks the Cart icon:
 The application should navigate to a second activity that confirms the selected order or
displays order-related information.
The application should handle image click events properly and ensure smooth navigation between
activities using Explicit Intents. The design should be simple, user-friendly, and clearly demonstrate
basic interaction handling in Android.

Problem Statement 8: EditText Input Types Demonstration

Design and develop an Android application that demonstrates the use of different EditText inputType
attributes to control the type of data entered by the user. The application should use a suitable layout
such as LinearLayout to organize the input fields.
The user interface must include:
1. An EditText field for entering a person’s name, configured to accept only text input.
2. An EditText field for entering a phone number, configured to display a numeric keypad.
3. An EditText field for entering an email address, configured to validate email-style input.
 4. An EditText field for entering numeric data, such as age or quantity, restricted to numeric
input.
Each EditText field should use the appropriate inputType attribute to ensure correct keyboard display
and data entry. The application should clearly demonstrate how inputType attributes improve data
validation, usability, and user experience during form input.

Problem Statement 9: Spinner-Based Course Selection Application

Design and develop an Android application that allows the user to select a course using
a Spinner component. The application should demonstrate the use of spinner controls and item
selection handling in Android.
The user interface must include:
1. A Spinner that displays a list of course names such as CSE, AI & ML, ECE, and MECH.
2. A Submit Button to confirm the selected course.
3. A TextView or Toast message to display the selected course name.
When the user selects a course from the Spinner and clicks the Submit button, the application should
display the chosen course clearly on the screen. The Spinner should be populated using
an ArrayAdapter, and the application should properly handle item selection events to retrieve and
display the selected value.

Problem Statement 10: Date Picker Application

Design and develop an Android application that allows the user to select a date using a DatePicker
Dialog. The main layout should use LinearLayout or RelativeLayout as the primary structure.
User Interface Requirements
The main screen should contain:
 A Button labeled “Select Date” to open the DatePicker dialog.
 A TextView to display the selected date in DD/MM/YYYY format.
Functionality Requirements
  When the user clicks the “Select Date” button, a DatePicker Dialog must appear.
 The dialog should allow the user to select day, month, and year.
 After the user selects a date, the TextView must update to display the chosen date.
 The application should handle the case where the user cancels the dialog gracefully without
crashing.
 Optionally, maintain the selected date when the device orientation changes
using savedInstanceState.

Problem Statement 11: Time Picker Application

Design and develop an Android application that enables the user to select a time using a TimePicker
Dialog. The main layout should use LinearLayout or RelativeLayout as the primary structure.
User Interface Requirements
The main screen should contain:
 A Button labeled “Select Time” to open the TimePicker dialog.
 A TextView to display the selected time in HH:MM format.
Functionality Requirements
 When the user clicks the “Select Time” button, a TimePicker Dialog must appear.
 The dialog should allow the user to select hours and minutes (12-hour or 24-hour format).
 After the user selects a time, the TextView must update to display the chosen time.
 Handle cases where the user cancels the dialog without crashing the app.
How the TimePicker Dialog Works
 The TimePicker Dialog is a built-in Android component that allows users to pick a time
interactively.
 It is initialized with a default hour and minute, typically the current system time.
  When the user selects a time and confirms, the dialog sends the selected hour and minute to
the application through an OnTimeSetListener callback.
 The application retrieves these values and updates the TextView dynamically.

Problem Statement 12: ListView-Based Student List Application

Design and develop an Android application that displays a list of student names using a ListView. The
main layout should use LinearLayout or RelativeLayout as the primary structure.
User Interface Requirements
The main screen should contain:
 A ListView to display the list of student names.
 Ensure proper spacing and alignment so that all list items are clearly visible.
Functionality Requirements
 Populate the ListView using an ArrayAdapter with a predefined list of student names.
 When the user clicks on any student name, display the selected name using a Toast message.
 Implement item click listeners to detect which list item the user has selected and trigger the
Toast.
How Item Click Listeners Work
 An OnItemClickListener is attached to the ListView.
 When a list item is clicked, the listener retrieves the position of the clicked item.
 Using the position, the corresponding student name is obtained from the adapter.
 The name is then displayed in a Toast message, providing immediate feedback to the user.
Problem Statement 13: ScrollView-Based Registration Form
Design and develop an Android application that implements a student registration form using
a ScrollView to allow vertical scrolling. The main layout should use LinearLayout (inside the
ScrollView) or RelativeLayout as the primary structure.
User Interface Requirements
The registration form should contain the following input fields and components:
 EditText for Name
 EditText for Roll Number
 EditText for Email
 EditText for Phone Number
 EditText for Address
 A Submit Button to submit the form data
Ensure proper spacing, alignment, and padding so that all fields are clearly visible and the form is
visually appealing.
Functionality Requirements
 Allow the user to scroll vertically to view all fields if the form content exceeds the screen
height.
 When the user taps the Submit Button, validate the entered data (optional: check for empty
fields or valid email/phone formats).
 Provide feedback (e.g., using a Toast message) when the form is submitted.
Problem Statement 14: GridLayout Image Gallery Application
Design and develop an Android application that displays multiple images in a GridLayout. The main
layout should use GridLayout as the primary structure for arranging images in rows and columns.
User Interface Requirements
The main screen should contain:
 A GridLayout to display multiple images (thumbnails).
 Each image should be properly sized and spaced so that all images are clearly visible and
clickable.
Functionality Requirements
 Populate the GridLayout with images either from the drawable folder or local resources.
 Each image should be clickable.
 When a user clicks on an image, one of the following actions should occur:
 Display the image name using a Toast message, or
 Open a new Activity that displays the selected image in a larger view.
 Ensure that the app handles clicks smoothly without lag, even for multiple images.
How Image Clicks are Handled
 Use OnClickListener for each image in the GridLayout.
 Retrieve the image information (e.g., name or resource ID) when the image is clicked.
 Display the information using a Toast or pass it to a new Activity via Intent extras.
Problem Statement 15: Fragment Lifecycle Demonstration Application
Design and develop an Android application that demonstrates the Fragment Lifecycle. The main
layout should use FrameLayout or RelativeLayout to host the fragment.
User Interface Requirements
The main screen should contain:
 A Fragment container (e.g., FrameLayout) where the fragment will be displayed.
 Optionally, Buttons to add, replace, or remove the fragment to observe lifecycle changes.
Functionality Requirements
 Implement a Fragment in the application.
 Override the following Fragment lifecycle methods:
 onCreate()
 onCreateView()
 onStart()
 onResume()
 onPause()
 onStop()
 onDestroy()
 Use Log messages inside each lifecycle method to track when it is called.
 Display a Toast notification in each lifecycle method to visually show the lifecycle flow to the
user.
 Optionally, allow interaction such as navigating between fragments or replacing fragments to
observe the lifecycle in real-time.

Problem Statement 16: Dynamic Fragment Loading Application

Design and develop an Android application that allows dynamic loading of fragments into a container
layout. The main layout should use FrameLayout or RelativeLayout to host the fragments.
User Interface Requirements
The main screen should contain:
 Two Buttons labeled:
 “Load Fragment A”
 “Load Fragment B”
 A Fragment container (e.g., FrameLayout) where the fragments will be dynamically
displayed.
 Ensure proper spacing and alignment of buttons and container so that the UI is clean and
intuitive.
Functionality Requirements
 Clicking “Load Fragment A” should load Fragment A into the container.
 Clicking “Load Fragment B” should load Fragment B into the container.
 Only one fragment should be visible at a time; the previous fragment should be replaced by
the new one.
 Optionally, add animations for smooth fragment transitions.

Problem Statement 17: Activity Lifecycle Logger Application

Design and develop an Android application that demonstrates the Activity Lifecycle. The main layout
can use RelativeLayout or LinearLayout as the primary structure.
User Interface Requirements
The main screen should contain:
 A simple layout with an optional TextView showing a message like “Activity Lifecycle
Demo.”
 No additional input fields are required, as the focus is on lifecycle events.
Functionality Requirements
 Override the following Activity lifecycle methods:
 onCreate()
 onStart()
 onResume()
 onPause()
 onStop()
 onDestroy()
  In each lifecycle method:
 Display a Log message using Log.d() or Log.i() to track when each method is called.
 Display a Toast message briefly showing the lifecycle event to the user.
 Test the application by performing actions such as:
 Opening the app
 Minimizing the app (pressing Home)
 Returning to the app
 Closing the app
How Activity Lifecycle Works
 An Activity goes through a sequence of lifecycle states from creation to destruction.
 Lifecycle methods are called automatically by the system when the activity changes state:
 onCreate() → activity is created
 onStart() → activity becomes visible
 onResume() → activity comes to the foreground and becomes interactive
 onPause() → activity loses focus but is still partially visible
 onStop() → activity is no longer visible
 onDestroy() → activity is destroyed and resources are released
 Logging and Toast messages help visualize these changes during testing.

Problem Statement 18: Button-Based Activity Navigation Application

Design and develop an Android application that allows navigation between multiple activities
using buttons. The main layout can use LinearLayout or RelativeLayout to arrange buttons neatly on
the screen.
User Interface Requirements
The main screen should contain:
 Multiple Buttons, each labeled according to the activity it will open (e.g., “Activity A,”
“Activity B,” etc.).
 Ensure proper spacing, alignment, and padding so that all buttons are clearly visible and
clickable.
Functionality Requirements
 When a user clicks any button, the application should navigate to the
corresponding activity using an Explicit Intent.
 Each target activity should have a simple layout, for example, a TextView showing the
activity name.
  Optionally, provide a Back Button in each activity or allow the system Back button to return
to the main screen.

Problem Statement 19: Basic UI Styling Application

Design and develop an Android application that demonstrates the use of Styles and Themes for
consistent and appealing user interface design. The main layout can
use LinearLayout or RelativeLayout for arranging UI components.
User Interface Requirements
 Create two versions of the same screen:
1. Without styles – manually set properties (e.g., text size, color, padding) directly in the
layout XML.
2. With styles applied – use a style resource to define common properties and apply
them to the components.
 The screen should contain:
 TextView for a title or heading.
 EditText fields for user input (optional).
 Buttons for actions (e.g., Submit, Cancel).
 Ensure proper alignment, spacing, and layout for all UI components.
Functionality Requirements
 Display both versions of the screen to allow comparison:
 One screen shows manually formatted UI components.
 Another screen applies styles and themes for a consistent look.
 Apply TextAppearance, color, padding, and background styles in the styled version.
 Optionally, allow switching between styled and unstyled screens for demonstration purposes.
Problem Statement 20: Mini Application
Design and develop a mini-Android application that integrates multiple Module–1 concepts,
including Layouts, Views, Activities, Intents, and Fragments. The application should demonstrate
proper navigation, UI design, and component interaction.
User Interface Requirements
The application should include:
 At least two Activities (e.g., MainActivity and DetailActivity).
 One Fragment embedded in one of the activities.
 Multiple UI controls, such as:
 Buttons for navigation and actions
 TextViews to display data
 EditTexts for user input
 Optional ImageView or other view components
 Use appropriate layouts (LinearLayout, RelativeLayout, or ConstraintLayout) to organize the
UI.