Part A

Module 3 : Android

2020 March

6. What is an intent filter?

Intent Filter is a feature in Android that allows an app to declare the types of intents that it
can handle. It specifies the type of data that an app can receive, the actions that it can
perform, and the categories that it belongs to. This helps the Android system to match and
launch the appropriate app when an intent is sent.

7. Describe the lifetime of an activity.

The lifetime of an activity in Android refers to its creation, starting, pausing, resuming,
stopping, restarting, and destroying. It is managed by the operating system and follows a
particular lifecycle. Activities can be in different states during their lifecycle, and the system
can also kill them if resources are low. Proper management of the activity's lifecycle is
crucial for creating stable and responsive applications.

2021 April

6. Define Service.
A Service is a component in Android that runs in the background to perform long-running
operations or to handle network transactions. It does not have a user interface and can run
even when the app is not visible on the screen. Services can be started and stopped
programmatically and can communicate with other components using Intents or Binders.

7. Define Multimedia.
Multimedia in Android refers to the use of audio, video, and images in Android applications.
Android provides APIs for playing and recording audio and video, displaying images and
video frames, and capturing images and videos using the device's camera. Multimedia can
be used in various types of applications, such as games, social media, and entertainment
apps.
2022 April

6. What do you mean by Activity Life cycle?

Activity Life cycle in Android refers to the sequence of states that an activity goes through
during its entire life, starting from its creation to its destruction. It consists of several callback
methods that get called by the Android system based on the state of the activity.

7. What are the network protocols supported in audio and video

playback?
Android supports several network protocols for audio and video playback, including HTTP
(Hypertext Transfer Protocol), RTSP (Real-Time Streaming Protocol), and RTMP (Real-Time
Messaging Protocol). These protocols enable streaming of media content from remote
servers and support various media formats.
Part B
Module 3 : Android

2020 March

17. Explain Android multimedia framework architecture.

The Android multimedia framework architecture is a layered architecture that consists of the
following layers:

● Application layer: This layer is responsible for the user interface of the multimedia
application. It provides the views and controls that the user uses to interact with the
multimedia content.
● Media layer: This layer is responsible for the playback and recording of multimedia
content. It provides the codecs and other components that are necessary to decode
and encode multimedia content.
● Hardware layer: This layer is responsible for the interaction with the hardware. It
provides the drivers and other components that are necessary to access the
multimedia hardware.

The multimedia framework architecture is designed to be modular and flexible. This allows
developers to add new features and functionality to the framework without having to modify
the existing layers.

18. Write a java code to implement text to speech.

Java code to implement text to speech in Android:
import android.speech.tts.TextToSpeech;
import android.content.Context;
import java.util.Locale;

public class TextToSpeechManager implements TextToSpeech.OnInitListener

{

private TextToSpeech tts;

private boolean initialized;

public TextToSpeechManager(Context context) {

tts = new TextToSpeech(context, this);
}

@Override
public void onInit(int status) {
 if (status == TextToSpeech.SUCCESS) {
tts.setLanguage(Locale.US);
initialized = true;
}
}

public void speak(String text) {

if (initialized) {
tts.speak(text, TextToSpeech.QUEUE_ADD, null, null);
}
}

public void shutdown() {

tts.shutdown();
}
}

This code creates a TextToSpeechManager class that initializes a TextToSpeech object

and sets the language to US English in the onInit method. The speak method takes a
string as input and speaks it using the TextToSpeech object, and the shutdown method
releases the resources used by the TextToSpeech object.

To use this class in an Android activity, you can create an instance of

TextToSpeechManager and call the speak method to speak a string:
TextToSpeechManager ttsManager = new TextToSpeechManager(this);
ttsManager.speak("Hello, world!");

This will speak the text "Hello, world!" using the device's text-to-speech engine.

2021 April

17. Briefly explain the functions i) onCreate() ii) onPause() iii)

onDestroy() iv) onStop()
i) onCreate() is a lifecycle method in Android that is called when an activity or application
is first created. It is used to initialize variables, set up UI elements, and perform other
necessary setup tasks.

ii) onPause() is called when an activity is no longer in the foreground and has lost focus. It
is often used to save the state of the activity, such as user input, so that it can be restored
later when the activity comes back into focus.
iii) onDestroy() is called when an activity is being destroyed and removed from memory. It
is used to clean up any resources that were allocated by the activity, such as unregistering
listeners or releasing memory.

iv) onStop() is called when an activity is no longer visible to the user. It is often used to
release resources that are no longer needed while the activity is in the background, such as
stopping a media player or releasing a camera.

18. Write java and xml code to play an audio file.

Java and XML code to play an audio file in Android:

Java Code:
import android.media.MediaPlayer;
import android.os.Bundle;
import android.view.View;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

private MediaPlayer mediaPlayer;

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

public void playAudio(View view) {

if (mediaPlayer == null) {
mediaPlayer = MediaPlayer.create(this, R.raw.audio_file);
}
mediaPlayer.start();
}

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

XML Code:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent">

<Button
android:id="@+id/play_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Play Audio"
android:onClick="playAudio"/>

</LinearLayout>

To play an audio file in Android, we define a MediaPlayer object and initialize it using the
create() method. The start() method is used to play the audio file on the click of a
button. The onStop() method is used to release the MediaPlayer object and free up
system resources. The audio file must be added to the "raw" folder in the "res" folder of the
Android project.

2022 April

17. Explain intent. Explain how intents are created?

An Intent is an abstract messaging object that provides a way to communicate between
components such as activities, services, broadcast receivers, and content providers. Intents
are used to start or stop an activity, service, or broadcast receiver, and pass data between
them.

Intents can be created using two constructors: explicit and implicit. Explicit intents are used
to start a specific component in the same application, while implicit intents are used to start
any component that can perform a particular action regardless of the application.

To create an intent, you first need to specify its action, which is a string that identifies the
action to be performed. Then, you can add any additional data or extras to the intent, such
as a URI or a bundle of key-value pairs. Finally, you can use the startActivity() method to
start the activity associated with the intent.

18. What are the classes used to play Audio and Video in
Android?
The classes used to play audio are MediaPlayer and AudioManager. MediaPlayer is a class
that can play various types of audio formats and provides various methods to control the
playback, such as start(), pause(), stop(), and release(). AudioManager is used to control the
volume and audio settings of the device.

The class used to play video in Android is VideoView. VideoView is a subclass of

SurfaceView and provides an easy way to play videos. It has built-in support for playing
various types of video formats and provides various methods to control the playback, such
as start(), pause(), stopPlayback(), and setVideoPath(). It also supports various video
display options, such as full screen and aspect ratio adjustments.
Part C
Module 3 : Android

2020 March

24. Write java and xml code to speak whatever written in

editText using Text to speech methods in Android.
Java and XML code to speak whatever is written in EditText using Text to Speech methods
in Android:

Java Code:
import android.os.Bundle;
import android.speech.tts.TextToSpeech;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;

import androidx.appcompat.app.AppCompatActivity;

import java.util.Locale;

public class MainActivity extends AppCompatActivity implements

TextToSpeech.OnInitListener {
private EditText editText;
private Button speakButton;
private TextToSpeech textToSpeech;

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

editText = findViewById(R.id.edit_text);
speakButton = findViewById(R.id.speak_button);

textToSpeech = new TextToSpeech(this, this);

speakButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
String text = editText.getText().toString();
textToSpeech.speak(text, TextToSpeech.QUEUE_FLUSH,
null);
}
});
}

@Override
public void onDestroy() {
if (textToSpeech != null) {
textToSpeech.stop();
textToSpeech.shutdown();
}
super.onDestroy();
}

@Override
public void onInit(int status) {
if (status == TextToSpeech.SUCCESS) {
int result = textToSpeech.setLanguage(Locale.US);
if (result == TextToSpeech.LANG_MISSING_DATA || result ==
TextToSpeech.LANG_NOT_SUPPORTED) {
speakButton.setEnabled(false);
} else {
speakButton.setEnabled(true);
}
}
}
}

XML Code:
<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/main_layout"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">

<EditText
android:id="@+id/edit_text"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="Enter text to speak" />

<Button
android:id="@+id/speak_button"
 android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@+id/edit_text"
android:layout_centerHorizontal="true"
android:layout_marginTop="16dp"
android:text="Speak" />

</RelativeLayout>

2021 April

24. a) Explain activity in detail. b) Explain the use of intent with

suitable programs.
a) Android Activity
In Android, an activity is a fundamental component of an application that represents a single
screen with a user interface. An application can have multiple activities, each representing a
distinct user interaction within the app.

An activity provides a window for drawing the user interface and handles user interactions
such as button clicks, touch events, and keystrokes. It also manages the lifecycle of the app,
handling events such as when the app is started, paused, resumed, and stopped.

When an activity is launched, it is placed on the top of the activity stack, and the user
interacts with it until it is finished or the user navigates to another activity. The Android
system manages the activity stack, and activities can be launched and closed dynamically
based on user interactions or programmatic logic.

Activities are defined in the AndroidManifest.xml file, and each activity has a unique name
and can be launched by an intent. An activity can also pass data to another activity using
intent extras or receive data from another activity using startActivityForResult() method.

Overall, activities are a critical part of Android app development and provide the foundation
for creating interactive user interfaces and managing the lifecycle of an application.

b) Use of Intents
Intents are used to communicate between the components of an Android application, such
as activities, services, and broadcast receivers, as well as to communicate with other
applications on the device. Intents are used to initiate actions, pass data, and start activities.

There are two types of intents: explicit intents and implicit intents. Explicit intents are used to
start a specific component within the same application, whereas implicit intents are used to
start a component outside of the application.
Here are two examples of how to use intents in Android:

1. Starting a new activity using an explicit intent:

// Creating an Intent to start a new activity
Intent intent = new Intent(MainActivity.this, SecondActivity.class);

// Starting the new activity

startActivity(intent);

2. Sending data between two activities using an explicit intent:

In the sending activity:

// Creating an Intent to start the receiving activity
Intent intent = new Intent(MainActivity.this, SecondActivity.class);

// Adding data to the Intent

intent.putExtra("name", "John Doe");
intent.putExtra("age", 25);

// Starting the new activity

startActivity(intent);

In the receiving activity:

// Retrieving the data from the Intent
Intent intent = getIntent();
String name = intent.getStringExtra("name");
int age = intent.getIntExtra("age", 0);

In the above example, we pass two pieces of data (name and age) from the sending activity
to the receiving activity using an explicit intent. The receiving activity retrieves the data from
the intent using the getIntent() method and the getStringExtra() and getIntExtra() methods.

2022 April

24. Explain in detail Service and Broadcast life cycle with a

neat diagram.
Service and Broadcast are two important components in the Android operating system that
allow developers to perform tasks in the background and respond to system events
respectively. Here is a detailed explanation of their life cycles:
Service Life Cycle:

● onCreate() - Called when the service is created.

● onStartCommand() - Called when the service is started.
● onHandleIntent() - This method is called from onStartCommand() and contains the
actual code to be executed by the service.
● onBind() - This method is called when a client wants to bind to the service.
● onUnbind() - Called when all clients have unbound from the service.
● onDestroy() - Called when the service is destroyed.

Broadcast Life Cycle:

 ● onReceive() - This method is called when the broadcast is received.
● setResult() - Used to set the result of the broadcast.
● getResult() - Used to get the result of the broadcast.
● abortBroadcast() - Used to abort the broadcast.
● setPriority() - Used to set the priority of the broadcast receiver.
● isOrderedBroadcast() - Used to check if the broadcast is ordered.
● getAbortBroadcast() - Used to check if the broadcast was aborted.

In summary, the Service life cycle is responsible for the creation, execution, and destruction
of services while the Broadcast life cycle is responsible for handling incoming broadcasts
and providing a response. Understanding these life cycles is crucial for building robust and
efficient Android applications.