SNS COLLEGE OF TECHNOLOGY

(An Autonomous Institution)

COIMBATORE-35

DEPARTMENT OF COMPUTER SCIENCE AND

ENGINEERING (UG & PG)

19CSB303 – COMPOSING MOBILE APPS

LABORATORY
PRACTICAL RECORD

NAME :

REGISTER No :

CLASS :

SEMESTER :
 SNS COLLEGE OF TECHNOLOGY
(An Autonomous Institution)
COIMBATORE-35

DEPARTMENT OF COMPUTER SCIENCE AND

ENGINEERING (UG & PG)

19CSB303 – COMPOSING MOBILE APPS

LABORATORY

Name : ……………………………………. Class : ……………….

Branch: ……………………………………. Roll No: ……………….

Register No.

Certified that this is the bonafide record of work done by the above student in the 19CSB303 –
Composing Mobile Apps Laboratory during the year 2023 - 2024.

Signature of Lab in-charge Head of the Department

Submitted for the practical examination held on ……………………

Internal Examiner External Examiner

 INDEX

S.No Date Experiment Name Page No Mark Sign

INSTALLATION OF JAVA WIRELESS

1. TOOLKIT(J2ME) 1

2. WORKING WITH JAVA FEATURES

2

WORKING ON DRAWING AND

3.
IMAGES 4

4. CREATING MENU
8

5.
BROADCAST RECEIVER APPLICATION 13

6. TELEPHONE AND SMS APPLICATION 17

7. ANIMATED APPLICATION USING 22

CUSTOM VIEWS, CANVAS

8. APPLICATION FOR PLAYING MUSIC IN 28

THE BACKGROUND

9. TESTING DEVELOPED APPLICATION 32

 EXP NO: 1 INSTALLATION OF JAVA WIRELESS
TOOLKIT(J2ME)

DATE:

AIM:

STEPS FOR INSTALLATION:

• Download the Java Wireless Toolkit:

Visit the Oracle website or search for the Java Wireless Toolkit download page.
Locate the appropriate version for your operating system.
• Install the toolkit:
Once the download is complete, run the installer file and follow the on-screen
instructions to install the Java Wireless Toolkit on your computer.
• Set up environment variables (optional):
If the installer does not automatically set up environment variables, you may
need to do it manually. Set the WTK_HOME environment variable to the
installation directory of the Java Wireless Toolkit. Additionally, add the bin
directory of the toolkit to your system's PATH variable to access the command-
line tools.
• Launch the Java Wireless Toolkit:
After the installation is complete, you can launch the Java Wireless Toolkit.
Look for an icon or shortcut on your desktop or start menu. Alternatively, you can
navigate to the installation directory and run the appropriate executable file.

RESULT:

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 1

 EXP NO: 2 WORKING WITH JAVA FEATURES

DATE:

AIM:

FEATURES OF JAVA:

• Object-Oriented Programming (OOP):

Java is primarily an object-oriented language, which means it provides features

such as classes, objects, inheritance, and polymorphism. These features enable
developers to write modular, reusable, and maintainable code.

• Platform Independence:

One of Java's key features is its ability to run on multiple platforms without
requiring recompilation. Java programs are compiled into an intermediate
representation called bytecode, which can be executed on any system that has a
Java Virtual Machine (JVM) installed. This platform independence makes Java
suitable for developing cross-platform applications.

• Garbage Collection:

Java includes automatic memory management through its built-in garbage

collector. It automatically handles memory allocation and deallocation, freeing
developers from managing memory explicitly. This feature helps prevent common
memory-related errors like memory leaks and segmentation faults.

• Exception Handling:

Java has a robust exception-handling mechanism that allows developers to

handle and recover from runtime errors. By catching and handling exceptions,
developers can write more reliable and fault-tolerant code.

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 2

 • Multithreading:

Java supports multithreading, allowing concurrent execution of multiple threads

within a single program. Multithreading enables developers to write efficient,
responsive, and scalable applications that can perform tasks concurrently, making
good use of modern multi-core processors.

• Libraries and APIs:

Java provides a vast collection of standard libraries and APIs (Application

Programming Interfaces) that simplify the development of various applications.
These libraries cover areas such as networking, database access, graphical user
interfaces (GUI), XML processing, and more. Java also has a vibrant ecosystem
with numerous third-party libraries and frameworks available for specific use
cases.

• Security:

Java incorporates built-in security features to protect against unauthorized access

and malicious activities. It includes features like a security manager, bytecode
verification, and a sandboxed execution environment that restricts potentially
harmful actions.

• Dynamic Reflection:

Java supports dynamic reflection, which allows developers to inspect and

manipulate the structure and behavior of classes and objects at runtime. This
feature enables tasks like dynamic loading of classes, introspection, and invoking
methods dynamically.

RESULT:

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 3

 EXP NO: 3 WORKING ON DRAWING AND
IMAGES

DATE:

AIM:

ALGORITHM:
Step 1. Load or create an image:
If you're working with an existing image, load it into memory using a suitable
library or API. If you want to create a new image, initialize a blank canvas with a
specified width and height.
Step 2. Get the graphics context:
Obtain the graphics context or create a graphics object that allows you to draw
on the image. The specific method may vary depending on the library or API you're
using.
Step 3. Perform drawing operations:
Use the available drawing methods to add shapes, lines, text, or other visual
elements to the image. This can include drawing rectangles, circles, polygons, and
lines, or even applying more complex transformations like rotations or scaling. You
can also set colors, gradients, or textures for filling or stroking shapes.
Step 4. Save or display the modified image:
Depending on your requirements, you may want to save the modified image to
a file in a specific format (e.g., PNG, JPEG) using the appropriate library functions.
Alternatively, if you're working within a graphical framework, you can display the
image directly on the screen or within a graphical component.
Step 5. Clean up resources:
Release any resources you used during the process, such as closing file handles
or disposing of graphics objects, to free up memory and prevent resource leaks.

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 4

PROGRAM:

import javax.swing.*;
import java.awt.*;
import java.awt.image.BufferedImage;

public class DrawingExample extends JFrame {

private final BufferedImage image;

public DrawingExample() {
setTitle("Drawing Example");
setSize(400, 400);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocationRelativeTo(null);

// Create a new image

image = new BufferedImage(2000, 2000, BufferedImage.TYPE_INT_ARGB);

// Get the Graphics2D object to draw on the image

Graphics2D g2d = image.createGraphics();

// Set the background color

g2d.setColor(Color.WHITE);
g2d.fillRect(0, 0, image.getWidth(), image.getHeight());

// Set the drawing color and draw a rectangle

g2d.setColor(Color.RED);
g2d.drawRect(50, 50, 500, 600);

// Set the drawing color and draw a circle

g2d.setColor(Color.BLUE);
g2d.drawOval(75, 75, 400, 400);

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 5

 // Dispose of the Graphics2D object
g2d.dispose();
}

@Override
public void paint(Graphics g) {
super.paint(g);
Graphics2D g2d = (Graphics2D) g;

// Draw the image on the window

g2d.drawImage(image, 50, 50, null);
}

public static void main(String[] args) {

SwingUtilities.invokeLater(() -> {
DrawingExample example = new DrawingExample();
example.setVisible(true);
});
}
}

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 6

OUTPUT:

RESULT:

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 7

 EXP NO: 4 CREATING MENU

DATE:

AIM:

ALGORITHM:

Step 1. Create a menu bar:

Initialize a menu bar object to hold the menus and menu items.
Step 2. Create menus:
Create a "File" menu and an "Edit" menu using appropriate menu objects.
Step 3. Create menu items:
Create menu item objects for each operation (cut, copy, paste, delete, select all,
unselect all).
Step 4. Implement action listeners:
Write an action listener that will be triggered when a menu item is selected.
Inside the action listener, implement the desired logic for each operation.
Step 5. Add action listeners to menu items:
Attach the action listeners to the respective menu items.
Step 6. Add menu items to menus:
Add the menu items to the "Edit" menu.
Step 7. Add menus to the menu bar:
Add the "File" and "Edit" menus to the menu bar.
Step 8. Set the menu bar:
Set the menu bar as the menu bar for the main frame or window.

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 8

PROGRAM:

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class MenuExample extends JFrame {

public MenuExample() {
setTitle("Menu Example");
setSize(400, 300);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocationRelativeTo(null);

// Create a menu bar

JMenuBar menuBar = new JMenuBar();

// Create the File menu

JMenu fileMenu = new JMenu("File");
JMenuItem exitMenuItem = new JMenuItem("Exit");
exitMenuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
System.exit(0);
}
});
fileMenu.add(exitMenuItem);
menuBar.add(fileMenu);

// Create the Edit menu

JMenu editMenu = new JMenu("Edit");
JMenuItem cutMenuItem = new JMenuItem("Cut");
JMenuItem copyMenuItem = new JMenuItem("Copy");
JMenuItem pasteMenuItem = new JMenuItem("Paste");

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 9

 JMenuItem deleteMenuItem = new JMenuItem("Delete");
JMenuItem selectAllMenuItem = new JMenuItem("Select All");
JMenuItem unselectAllMenuItem = new JMenuItem("Unselect All");

// ActionListener for menu items

ActionListener menuActionListener = new ActionListener() {
public void actionPerformed(ActionEvent e) {
String command = e.getActionCommand();
switch (command) {
case "Cut":
// Perform cut operation
System.out.println("Cut operation");
break;
case "Copy":
// Perform copy operation
System.out.println("Copy operation");
break;
case "Paste":
// Perform paste operation
System.out.println("Paste operation");
break;
case "Delete":
// Perform delete operation
System.out.println("Delete operation");
break;
case "Select All":
// Perform select all operation
System.out.println("Select all operation");
break;
case "Unselect All":
// Perform unselect all operation
System.out.println("Unselect all operation");
break;
}

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 10

 }
};

// Add ActionListener to menu items

cutMenuItem.addActionListener(menuActionListener);
copyMenuItem.addActionListener(menuActionListener);
pasteMenuItem.addActionListener(menuActionListener);
deleteMenuItem.addActionListener(menuActionListener);
selectAllMenuItem.addActionListener(menuActionListener);
unselectAllMenuItem.addActionListener(menuActionListener);

// Add menu items to Edit menu

editMenu.add(cutMenuItem);
editMenu.add(copyMenuItem);
editMenu.add(pasteMenuItem);
editMenu.add(deleteMenuItem);
editMenu.add(selectAllMenuItem);
editMenu.add(unselectAllMenuItem);
menuBar.add(editMenu);

// Set the menu bar to the frame

setJMenuBar(menuBar);
}

public static void main(String[] args) {

SwingUtilities.invokeLater(() -> {
MenuExample example = new MenuExample();
example.setVisible(true);
});
}

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 11

OUTPUT:

RESULT:

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 12

 EXP NO: 5 BROADCAST RECEIVER APPLICATION

DATE:

AIM:

ALGORITHM:

Step 1: Create a new Java class that extends the BroadcastReceiver class. This class
will handle the received broadcasts.

Step 2: Declare the receiver in the AndroidManifest.xml file. Open the file and add the
following code within the `<application>` tag.

Step 3: Implement the logic to handle the received broadcast in the `onReceive()`
method of the receiver class. Access the received data and perform the necessary
operations.

Step 4: Optionally, you can register and unregister the receiver dynamically within an
activity or fragment. In the activity or fragment class.

Step 5: Build and run your application. The broadcast receiver will now listen for the
specified broadcast and execute the logic in the `onReceive()` method when a
matching broadcast is received.

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 13

PROGRAM:

BroadcastReceiver.java:

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.util.Log;

public class MyBroadcastReceiver extends BroadcastReceiver {

private static final String TAG = "MyBroadcastReceiver";

@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();

if (action != null) {
switch (action) {
case Intent.ACTION_POWER_CONNECTED:
Log.d(TAG, "Power connected");
// TODO: Handle power connected event
break;
case Intent.ACTION_POWER_DISCONNECTED:
Log.d(TAG, "Power disconnected");
// TODO: Handle power disconnected event
break;
case Intent.ACTION_BOOT_COMPLETED:
Log.d(TAG, "Boot completed");
// TODO: Handle boot completed event
break;
default:
Log.d(TAG, "Unknown action: " + action);
break;

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 14

 }
}
}
}

AndroidManifest.xml:
<receiver android:name=".MyBroadcastReceiver">
<intent-filter>
<action
android:name="android.intent.action.ACTION_POWER_CONNECTED" />
<action
android:name="android.intent.action.ACTION_POWER_DISCONNECTED" />
<action android:name="android.intent.action.BOOT_COMPLETED" />
</intent-filter>
</receiver>

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 15

OUTPUT:

RESULT:

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 16

 EXP NO: 6 TELEPHONE AND SMS APPLICATION

DATE:

AIM:

ALGORITHM:

Step 1: Start the application and display the initial menu.

Step 2: Initialize a scanner object to read user input.
Step 3: Enter a loop to continuously display the menu and process user options until
the user chooses to exit.
Step 4: Within the loop:
• Display the menu options: Make a phone call, Send an SMS, or Exit.
• Read the user's option choice.
• Use a switch statement to handle the chosen option:
• If the option is 1 (Make a phone call):
▪ Prompt the user to enter the phone number.
▪ Read the phone number from the user.
▪ Call the `makePhoneCall()` function, passing the phone number as an
argument.
• If the option is 2 (Send an SMS):
▪ Prompt the user to enter the phone number and the message.
▪ Read the phone number and the message from the user.
▪ Call the `sendSMS()` function, passing the phone number and message as
arguments.
• If the option is 3 (Exit):
▪ Display a farewell message and exit the application.
▪ If the option is invalid (not 1, 2, or 3):
▪ Display an error message indicating an invalid option and prompt the user to
try again.

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 17

Step 5: Implement the `makePhoneCall()` function:
• Print a message indicating that a call is being made to the provided phone number.
• Implement the code to initiate a phone call using telephony APIs or third-party
libraries.
Step 6: Implement the `sendSMS()` function:
• Print a message indicating that an SMS is being sent to the provided phone
number with the given message.
• Implement the code to send an SMS using telephony APIs or third-party libraries.
Step 7: End the application.

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 18

PROGRAM:

import java.util.Scanner;

public class TelephoneAndSMSApp {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

System.out.println("Telephone and SMS Application");

System.out.println("=============================");

while (true) {
System.out.println("\nPlease select an option:");
System.out.println("1. Make a phone call");
System.out.println("2. Send an SMS");
System.out.println("3. Exit");

int option = scanner.nextInt();

scanner.nextLine(); // Consume the newline character

switch (option) {
case 1:
System.out.print("Enter the phone number: ");
String phoneNumber = scanner.nextLine();
makePhoneCall(phoneNumber);
break;
case 2:
System.out.print("Enter the phone number: ");
phoneNumber = scanner.nextLine();
System.out.print("Enter the message: ");
String message = scanner.nextLine();
sendSMS(phoneNumber, message);
break;

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 19

 case 3:
System.out.println("Exiting...");
return;
default:
System.out.println("Invalid option. Please try again.");
}
}
}

private static void makePhoneCall(String phoneNumber) {

System.out.println("Calling " + phoneNumber + "...");
// Code to initiate a phone call using telephony APIs or third-party libraries
}

private static void sendSMS(String phoneNumber, String message) {

System.out.println("Sending SMS to " + phoneNumber + ": " + message);
// Code to send an SMS using telephony APIs or third-party libraries
}
}

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 20

OUTPUT:

RESULT:

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 21

 EXP NO: 7 ANIMATED APPLICATION USING
CUSTOM VIEWS, CANVAS

DATE:

AIM:

ALGORITHM:

Step 1:
Create a custom view by extending the `View` class or any other appropriate
subclass, such as `SurfaceView` or `TextureView`.
Step 2:
Inside the custom view, define your animation parameters, such as the position,
size, and appearance of the objects to be animated.
Step 3:
Override the `onDraw` method in your custom view. This method is responsible
for drawing the animation on the Canvas.
Step 4:
Inside the `onDraw` method, update the animation parameters based on the
desired animation logic. This could involve changing the position, size, or
appearance of the animated objects.
Step 5:
Use the `Canvas` object provided in the `onDraw` method to draw the animated
objects on the screen. You can use various `Canvas` drawing methods, such as
`drawRect`, `drawCircle`, `drawBitmap`, etc., to render the objects.
Step 6:
Call the `invalidate()` method at the end of the `onDraw` method to trigger a
redraw of the custom view. This ensures that the animation is continuously
updated and displayed on the screen.
Step 7:
Optionally, you can add user interaction by handling touch events, gestures, or
other input events in your custom view. This could involve modifying the
animation parameters based on user input or triggering specific actions.

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 22

 Step 8:
Add the custom view to your activity's view hierarchy by either including it in
the XML layout file or programmatically creating an instance and adding it to a
parent view.
Step 9:
Run your application, and the animation should start playing on the screen based
on the animation logic you defined.

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 23

PROGRAM:

View.java:

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.util.AttributeSet;
import android.view.View;

public class CustomAnimatedView extends View {

private Paint paint;

private float radius = 50;
private float x = 0;
private float y = 0;
private int directionX = 1;
private int directionY = 1;

public CustomAnimatedView(Context context) {

super(context);
init();
}

public CustomAnimatedView(Context context, AttributeSet attrs) {

super(context, attrs);
init();
}

public CustomAnimatedView(Context context, AttributeSet attrs, int defStyle) {

super(context, attrs, defStyle);
init();
}

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 24

 private void init() {
paint = new Paint();
paint.setColor(Color.RED);
}

@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);

// Update the position

x += 5 * directionX;
y += 5 * directionY;

// Check if the ball hits the boundaries

if (x + radius > getWidth() || x - radius < 0) {
directionX *= -1;
}
if (y + radius > getHeight() || y - radius < 0) {
directionY *= -1;
}

// Draw the ball

canvas.drawCircle(x, y, radius, paint);

// Trigger redraw
invalidate();
}
}

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 25

CustomAnimatedView.xml:
<LinearLayout 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"
android:orientation="vertical"
tools:context=".MainActivity">

<com.example.myapp.CustomAnimationView
android:layout_width="match_parent"
android:layout_height="match_parent" />

</LinearLayout>

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 26

OUTPUT:

RESULT:

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 27

 EXP NO: 8 APPLICATION FOR PLAYING MUSIC IN
THE BACKGROUND

DATE:

AIM:

ALGORITHM:

Step 1: Start by creating a new Android project in your preferred Integrated

Development Environment (IDE).

Step 2: Design the user interface (UI) for your music player app. This typically
includes components such as play/pause buttons, a seek bar for tracking the progress
of the song, a list of songs, and any other features you want to include.

Step 3: Add the necessary permissions in the AndroidManifest.xml file to access the
user's music files and control audio playback.

Step 4: Create a service class that extends the Service class in Android. This service
will handle the background music playback. Inside the service, you'll initialize a
MediaPlayer object and manage playback functionality.

Step 5: Implement the necessary methods in the service class to handle the lifecycle of
the service, such as onCreate(), onStartCommand(), and onDestroy(). In the onCreate()
method, initialize the MediaPlayer object and set up any listeners or callbacks for
media playback events.

Step 6: Implement methods in the service class to handle various playback operations,
such as play(), pause(), stop(), and skip to the next/previous song.

Step 7: In the UI components (e.g., buttons) that control the music playback, bind them
to appropriate methods in the service class using the Service Connection mechanism.
This allows communication between the UI and the background service.

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 28

PROGRAM:

import android.media.MediaPlayer;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;

public class MusicPlayerActivity extends AppCompatActivity {

private MediaPlayer mediaPlayer;

private Button playButton;
private boolean isPlaying = false;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_music_player);

// Initialize MediaPlayer with the desired audio file

mediaPlayer = MediaPlayer.create(this, R.raw.background_music);

playButton = findViewById(R.id.play_button);
playButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (isPlaying) {
pauseMusic();
} else {
playMusic();
}
}
});

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 29

 }

private void playMusic() {

if (!mediaPlayer.isPlaying()) {
mediaPlayer.start();
playButton.setText("Pause");
isPlaying = true;
}
}

private void pauseMusic() {

if (mediaPlayer.isPlaying()) {
mediaPlayer.pause();
playButton.setText("Play");
isPlaying = false;
}
}

@Override
protected void onDestroy() {
super.onDestroy();
if (mediaPlayer != null) {
mediaPlayer.release();
mediaPlayer = null;
}
}
}

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 30

OUTPUT:

RESULT:

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 31

 EXP NO: 9 TESTING DEVELOPED APPLICATION

DATE:

AIM:

KEY STEPS AND APPROACHES FOR TESTING:

1. Unit Testing:

Write unit tests for individual components and functionalities of your application,
such as the service class, playback controls, UI interactions, and any custom logic. Use
frameworks like JUnit or Mockito to create and run these tests.

2. Functional Testing:

Perform functional testing to validate that each feature of your app works correctly.
Test various scenarios such as playing, pausing, stopping, skipping tracks, seeking,
and handling playback controls.

3. Integration Testing:

Test the integration of different components and modules within your app to ensure
they work together seamlessly. For example, verify that the UI updates correctly based
on the playback status from the service class.

4. UI Testing:

Use tools like Espresso or UI Automator to automate UI testing. Write test cases to
simulate user interactions like tapping buttons, seeking, and verifying the state of UI
elements during playback.

5. Compatibility Testing:

Test your app on different Android devices and versions to ensure it functions
properly across a range of configurations. Pay attention to device-specific features,
screen sizes, and orientations.

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 32

6. Performance Testing:

Assess the app's performance by measuring factors such as response time, memory
usage, CPU utilization, and battery consumption. Identify potential bottlenecks and
optimize the app accordingly.

7. Usability Testing: Conduct usability testing by involving real users or a focus

group to provide feedback on the app's user interface, ease of use, and overall
experience. Gather insights on areas for improvement.

8. Edge Case Testing:

Test your app in less common or extreme scenarios, such as low memory
conditions, interrupted network connectivity, incoming calls, and other interruptions.
Ensure your app handles such situations gracefully.

9. Localization and Internationalization Testing:

If your app supports multiple languages or regions, verify that the localized
versions display correctly, handle text expansion, and adhere to cultural conventions.

10. Regression Testing:

Regularly perform regression testing to check that new changes or bug fixes do
not introduce new issues or break existing functionality.

11. Accessibility Testing:

Evaluate your app's accessibility by ensuring it meets the guidelines and

standards for accessibility, such as providing alternative text for images, proper color
contrast, and support for screen readers.

12. Security Testing:

Assess the security aspects of your app, such as data storage, network
communication, and user authentication. Look for vulnerabilities and implement
appropriate measures to protect user data.

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 33

13. Beta Testing and User Feedback:

Release your app to a limited set of beta users and gather feedback on real-
world usage. Pay attention to user-reported issues, crashes, and suggestions for
improvement.

14. Continuous Testing: Implement continuous integration and continuous delivery

(CI/CD) processes to automate testing as part of your development pipeline. This
ensures consistent testing throughout the development lifecycle.

15. Bug Tracking and Issue Resolution: Use a bug tracking system to log and track
reported issues. Prioritize and address these issues in subsequent releases or patches.

RESULT:

21CS172 19CSB303-COMPOSING MOBILE APPS LABORATORY 34