Q- What is SMS manager class and which functions are used in SMS manager class?

*Package.in android.te dot SMS manager, get default() (object of sms manager)
access manager object of
* sMS manager class- it is used to send messages messages of different type like
text message data message, multimedia message the function specified in SMS manager
class.
* we have to import android.telephony. SMS manager package.
* there are different functions using which we can send messages as send text
message().

# send a text message()- it is used to send text message to a number which is

mentioned as first argument of the method.
* to use send text message() we have to use the object of SMS manager class.
* get default() function is used for creation of SMS manager object and by using
this object we can send text messages.
* send text messages() contains 5 arguments- we have to pass number and message in
SMS manager sm=smsMa sMS managernager.get Default dot get default();
sm.sendTextMessage(no,null,msg,null.null) First and third arguments of
sendTextmessages.
* to send data message we have to see use send data message of SMS manager class.
This function also contents 5 arguments.
* to send it data message we have to use send a data message of SMS manager class.
This function also contents 5 arguments.
* to create app for sending SMS message we have to design the UI by using-----
Textview--NO|___|---e edit textditext.

#Key Functions in SmsManager Class.

sendTextMessage(): Sends a text-based SMS message.
Parameters: destinationAddress, scAddress, text, sentIntent, deliveryIntent.
sendMultipartTextMessage(): Sends a multi-part text-based SMS message. This is
useful for long messages that exceed the standard SMS message length.
Parameters: destinationAddress, scAddress, parts, sentIntents, deliveryIntents
sendDataMessage(): Sends a data-based SMS message.
Parameters: destinationAddress, port, scAddress, data, sentIntent,
deliveryIntent.Ex-SmsManager smsManager = SmsManager.getDefault();
smsManager.sendTextMessage("+1234567890", null, "Hello, World!", null, null);

Q-write a program to send a sms message using edit text and button control?

To create an Android application that sends an SMS message using an EditText and a
Button control, We need to follow these steps:

Add Necessary Permissions: Ensure we have the necessary permissions in our

AndroidManifest.xml.
Design the User Interface: Create an activity layout with EditText and Button.
Handle Button Click: Write the code to send the SMS when the button is clicked.
Handle Runtime Permissions: Manage runtime permissions for sending SMS on devices
running Android 6.0 and higher.

Q-n Android, a Service is a component that can perform long-running operations in

the background and does not provide a user interface. A Service can run in the
background indefinitely, even if the application is destroyed, allowing for
operations such as downloading files, playing music, or performing network
operations.

Types of Services
Foreground Service:
Runs in the foreground and is noticeable to the user.
Must display a notification.
Example: Music player that shows a notification with playback controls.
Background Service:

Runs in the background without a user interface.

Could be limited or restricted in recent Android versions due to battery
optimization.
Example: Syncing data with a server.
Bound Service:

Binds to other components (like Activities) and allows interaction.

Example: Service that provides data to multiple activities.
Lifecycle of a Service
The lifecycle of a service is controlled primarily by its creation and destruction:

Started Service:

onCreate(): Called when the service is first created. Used to initialize the
service.
onStartCommand(): Called every time a client starts the service using
startService(). The service starts and can run indefinitely.
onDestroy(): Called when the service is no longer used and is being destroyed. Used
to clean up resources.
Bound Service:

onCreate(): Called when the service is first created.

onBind(): Called when a component binds to the service using bindService(). Returns
an IBinder interface that the client uses to communicate with the service.
onUnbind(): Called when all clients have disconnected from a particular interface
published by the service.
onRebind(): Called when new clients bind to the service after it had previously
been unbound.
onDestroy(): Called when the service is no longer used and is being destroyed.

The lifecycle methods (onCreate, onStartCommand, onBind, onDestroy, etc.) provide

hooks to manage the service's operations, ensuring proper resource management and
clean-up.

Q-what is broadcast receiver and how to create broadcast receiver?

A Broadcast Receiver in Android is a component that responds to broadcast messages
(or intents) from other applications or the system itself. These broadcasts can be
used to notify the application about changes in the system or other events, such as
incoming calls, SMS messages, changes in network connectivity, and more.

#Types of Broadcasts:-
System Broadcasts: Sent by the Android system when certain system events occur
(e.g., device boot completed, battery low, etc.).
Custom Broadcasts: Sent by applications to communicate within the app or with other
apps.
Creating a Broadcast Receiver
To create a Broadcast Receiver, We need to:

#Define a Broadcast Receiver class.

Register the Broadcast Receiver.
Step 1: Define a Broadcast Receiver Class
we have created a subclass of BroadcastReceiver and override the onReceive() method
to define the actions that should occur when the broadcast is received.
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.widget.Toast;

public class MyBroadcastReceiver extends BroadcastReceiver {

@Override
public void onReceive(Context context, Intent intent) {
// Perform the actions you want when the broadcast is received
Toast.makeText(context, "Broadcast Received", Toast.LENGTH_SHORT).show();
}
}

Step 2: Register the Broadcast Receiver

We can register a Broadcast Receiver in two ways: statically in the
AndroidManifest.xml or dynamically in our application code.
<receiver android:name=".MyBroadcastReceiver">
<intent-filter>
<action android:name="android.intent.action.BOOT_COMPLETED"/>
<!-- Add more actions as needed -->
</intent-filter>
</receiver>

Q-Write a program to create a service and use it in your app?

To create a Service and use it in your Android app, follow these steps:

Define the Service.

Register the Service in the AndroidManifest.xml.
Start and stop the Service from an Activity.
Step 1: Define the Service {MyService.java:}
Create a new Java class for your service, extending Service, and override necessary
methods such as onStartCommand and onDestroy.
Step 2: Register the Service in AndroidManifest.xml
Add the service to your AndroidManifest.xml file:
Step 3: Start and Stop the Service from an Activity{MainActivity.java:}
Create an Activity with buttons to start and stop the service.
Layout File for MainActivity
Create a layout file res/layout/activity_main.xml with two buttons to start and
stop the service.

activity_main.xml:
Summary
This example shows how to create a basic service in an Android app, register it in
the AndroidManifest.xml, and control it from an activity using start and stop
buttons. When the service starts and stops, it shows toast messages to indicate its
state. This basic structure can be extended to perform more complex background
operations as needed.

Q-Describe option menu,context menu and pop-up menu?

In Android, menus provide a consistent user interface for presenting actions and
options. There are three primary types of menus: Option Menu, Context Menu, and
Popup Menu.

Option Menu:-
The Option Menu is the primary collection of menu items for an activity. It is
typically used for actions and options that are relevant to the current activity.
The Option Menu appears in the app bar (or toolbar) and can overflow into a
dropdown menu.
Characteristics:-
Displayed in the app bar (toolbar) or as an overflow menu.
Contains actions that have a global impact on the activity.
Example:-
1)Define the Menu in XML (res/menu/menu_main.xml):
2)Inflate the Menu in Activity (MainActivity.java):

Context Menu:-
A Context Menu is a floating menu that appears when the user performs a long-click
(press and hold) on an element. It is used for providing actions related to a
specific item in the UI.

Characteristics:
Triggered by a long-click on a View.
Provides contextual actions for the specific item.
Example:
1)Register the Context Menu (MainActivity.java):
2)Define the Context Menu in XML (res/menu/context_menu.xml):

Popup Menu
A Popup Menu is a modal menu that anchors to a particular view and displays a list
of items in a vertical list. Unlike the Context Menu, a Popup Menu is not triggered
by a long-click but is typically shown upon clicking a button or other UI element.

Characteristics:
Anchored to a specific view.
Provides a simple, lightweight list of actions.
Example:
1)Create and Show the Popup Menu (MainActivity.java):
2)Define the Popup Menu in XML (res/menu/popup_menu.xml):

Option Menu: For global actions related to the activity, usually shown in the app
bar.
Context Menu: For contextual actions related to a specific item, shown on long-
click.
Popup Menu: For a simple list of actions anchored to a view, shown on a click.

Q-how to create and implement a tab?

To create and implement tabs in an Android application, you typically use the
TabLayout component from the Android Design Support Library. Tabs are used to
organize content across different pages within the same activity.

Here's a step-by-step guide to create and implement tabs using TabLayout and
ViewPager2:

1. Add Dependencies
Ensure you have the necessary dependencies in your build.gradle file:
2. Create Layout for Tabs.Create a layout file for your activity with a TabLayout
and ViewPager2 component.
activity_main.xml:
3. Create Fragments for Tabs
Create fragment classes for the different tabs you want to display. For example:
FirstFragment.java:
4. Create a PagerAdapter
Create an adapter to manage the fragments in the ViewPager.
ViewPagerAdapter.java:
5. Set Up TabLayout and ViewPager in Activity
In your main activity, set up the TabLayout and ViewPager2 to work together.
MainActivity.java:
Summary-
Dependencies: Add material and viewpager2 dependencies.
Layout: Create a layout with TabLayout and ViewPager2.
Fragments: Create fragments for each tab.
Adapter: Create a FragmentStateAdapter to manage the fragments.
Activity: Set up the TabLayout and ViewPager2 in your activity.