Unit-4

Android Applications: Working with Eclipse and Android, Various life cycles for applications, building a
User Interface: Blank UI, Folding and Unfolding a scalable UI, Making Activity, Fragment, Multiple layouts;
Content Provider,
Location and Mapping: location based services, Mapping, Google Maps activity, working with MapView
and MapActivity;
Playing and Recording of Audio and Video in application; Sensors and Near Field Communication; Native
libraries and headers, Building client server applications.

In Android mobile development, "building a User Interface (UI)" involves creating and structuring the
layout, design, and interactive elements that users see and interact with on their screen.
1. Blank UI:
o A "Blank UI" typically refers to a simple, starting point or empty UI setup, often used as a
template. It’s essentially an empty screen with no UI components yet added, serving as a
foundation for adding widgets (buttons, text fields, images, etc.).
o In Android Studio, a "Blank Activity" template is commonly used when beginning a new
screen layout. Developers can use this as a base to build more complex layouts as
required.
2. Folding and Unfolding a Scalable UI:
o This concept is highly relevant in designing UIs for devices with foldable screens, such as
foldable smartphones. Foldable UIs must adapt dynamically when the device changes
from folded to unfolded modes. Android offers tools for creating scalable UIs that adjust
seamlessly to different screen configurations.
o When a device unfolds, it typically provides more screen space, which allows for
additional information or features to be displayed. Conversely, when folded, the UI might
be scaled down, showing only essential information.
o Achieving this involves using responsive layouts, which can adapt to different screen sizes
and orientations. This often includes setting flexible constraints, using ConstraintLayout,
FlexboxLayout, or GridLayout, and employing multi-window support features to ensure
smooth transitions between folded and unfolded states.
3. Scalable UI:
o A scalable UI is designed to work well across a wide range of screen sizes, densities, and
orientations, ensuring that the layout and content adapt without losing functionality or
visual quality.
o To achieve scalability, Android developers use flexible units like dp (density-independent
pixels), wrap content, and match parent attributes, along with techniques like
ConstraintLayouts and layout weights.
o Scalable UI is especially important with the growing range of Android devices, from small
phones to large tablets and foldable devices. Responsive design practices, such as
adjusting font sizes, margins, and element placements based on available screen space,
help create UIs that look polished and are user-friendly across all device types.
Activities and Fragments are two fundamental building blocks used to create a flexible and modular user
interface. Here’s an explanation of each:
Activity
• An Activity represents a single, focused screen with a user interface, such as a login screen, a list
of items, or a settings page.
• Activities act as the entry points for user interaction. Every app must have at least one Activity,
usually the main one (like MainActivity), which is the first screen that opens when the app is
launched.
• Activities are managed in a lifecycle, which includes states such as onCreate, onStart, onResume,
onPause, onStop, and onDestroy. Understanding this lifecycle is critical, as it allows developers to
manage resources efficiently, handle user navigation, and respond appropriately to system
interruptions.
• Activities can interact with each other, allowing navigation between screens using Intents, which
are objects that allow data to be passed from one activity to another.
Example:
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main); // Set the layout for the activity
}
}
• MainActivity extends AppCompatActivity, which is a base class for activities that use the support
library action bar features.
• The onCreate method in MainActivity initializes the activity when it is created
Fragment
• A Fragment represents a reusable UI component or behavior that can be embedded within an
Activity. Fragments allow for a more modular design, as multiple fragments can be combined
within a single activity to build flexible UIs.
• Unlike activities, fragments depend on an activity for their existence. They cannot exist on their
own but must be embedded within an activity (typically within a FragmentContainerView or
similar layout).
• Fragments also have their own lifecycle (which is slightly different from an Activity’s), allowing
them to manage their own UI states within an activity. This lifecycle includes onAttach, onCreate,
onCreateView, onActivityCreated, onStart, onResume, and onPause.
• Fragment Transactions are used to add, remove, replace, or hide/show fragments dynamically
within an activity. This enables navigation between different fragments or different views within
the same activity.
Example:
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import androidx.fragment.app.Fragment;
 public class ExampleFragment extends Fragment {
public ExampleFragment() {
// Required empty public constructor
}

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_example, container, false);
}

@Override
public void onViewCreated(View view, Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
// Set up UI and behavior here
}
}
ExampleFragment extends Fragment, allowing it to be embedded within an Activity. The onCreateView
method inflates the fragment's layout, and you can use the onViewCreated method to perform further UI
initialization or setup.

When to Use Activities vs. Fragments:

• Activities are ideal for distinct screens with separate functionality (like a main menu, a settings
screen, or a splash screen).
• Fragments are better suited for creating reusable, modular components within a single activity,
especially when building UIs for larger screens (such as tablets or foldable devices) where
multiple views are needed on one screen.
Key Differences:
Aspect Activity Fragment
Independent, fully managed by
Lifecycle Dependent on an Activity’s lifecycle
Android
Standalone
Can function independently Requires an Activity to exist
Capability
Modular, reusable components within
Use Case Entire screen or distinct task
screens

Designing a user interface (UI) in Android applications involves using XML layout files to define how
elements are arranged on the screen. Android provides various layout types, allowing you to create
flexible and responsive UIs. Here’s how you can design a UI with multiple layouts in Android, including an
example of a simple app layout that incorporates multiple views.
Common Layout Types in Android
1. LinearLayout: Arranges its children in a single column or row, either vertically or horizontally.
2. RelativeLayout: Allows you to position children relative to each other or to the parent layout.
3. ConstraintLayout: A flexible layout that allows you to define complex layouts with a flat view
hierarchy. It's the recommended layout for most situations.
4. FrameLayout: A simple layout that can contain a single child view, typically used for stacking
views.
5. GridLayout: Arranges its children in a grid-like structure.
Below is a guide on how to design a UI with multiple layouts using Java.
Explanation:
• MainActivity contains a button that opens SecondActivity.
• SecondActivity displays a message and has a button that opens ThirdActivity.
• ThirdActivity contains two EditText fields for user input and a Submit button that displays a Toast
message with the entered values.
• Each activity uses a separate XML layout, providing a modular design that can easily be
maintained and modified.

Step 1: Create a New Android Project

1. Open Android Studio.
2. Create a new project and choose an "Empty Activity" template.
3. Name your project and set the package name.
Step 2: Define XML Layouts
For this example, let’s create three layouts: a main layout with a Button, a secondary layout with a
TextView, and a third layout with a LinearLayout containing multiple EditText fields.
1. Main Layout (activity_main.xml)
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent">

<Button
android:id="@+id/buttonOpenSecondLayout"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Open Second Layout"
android:layout_centerInParent="true" />

</RelativeLayout>
2. Second Layout (layout_second.xml)
<?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">

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Welcome to the Second Layout"
android:layout_gravity="center"
android:textSize="18sp" />

<Button
android:id="@+id/buttonOpenThirdLayout"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Open Third Layout"
android:layout_gravity="center"
android:layout_marginTop="20dp" />
</LinearLayout>
3. Third Layout (layout_third.xml)
<?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"
android:padding="16dp">

<EditText
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="Enter your name" />

<EditText
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="Enter your email" />

<Button
android:id="@+id/buttonSubmit"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Submit"
android:layout_gravity="center"
android:layout_marginTop="20dp" />
</LinearLayout>
Step 3: Implementing Activity Logic in Java
Now, let's implement the logic in your main activity to handle navigation between the layouts.
MainActivity.java
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

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

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

buttonOpenSecondLayout.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// Open second layout
Intent intent = new Intent(MainActivity.this, SecondActivity.class);
startActivity(intent);
}
});
}
}
SecondActivity.java
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;

public class SecondActivity extends AppCompatActivity {

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

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

buttonOpenThirdLayout.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// Open third layout
Intent intent = new Intent(SecondActivity.this, ThirdActivity.class);
startActivity(intent);
 }
});
}
}
ThirdActivity.java
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;

public class ThirdActivity extends AppCompatActivity {

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

EditText editTextName = findViewById(R.id.editTextName);

EditText editTextEmail = findViewById(R.id.editTextEmail);
Button buttonSubmit = findViewById(R.id.buttonSubmit);

buttonSubmit.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
String name = editTextName.getText().toString();
String email = editTextEmail.getText().toString();

// Display a toast message with user input

Toast.makeText(ThirdActivity.this, "Name: " + name + ", Email: " + email,
Toast.LENGTH_SHORT).show();
}
});
}
}
Step 4: Update the Manifest
Make sure to declare your new activities in the AndroidManifest.xml:
<activity android:name=".SecondActivity"></activity>
<activity android:name=".ThirdActivity"></activity>

A Content Provider in Android is a component that allows you to manage access to a structured
set of data. It serves as an abstraction layer that enables applications to interact with data from
other applications or share data with other applications securely. Content Providers are typically
used to store and retrieve data from databases, files, or any other persistent storage mechanism.
Key Features of Content Providers:

• Data Sharing: Content Providers facilitate sharing of data between applications. For
example, the Contacts app uses a Content Provider to allow other apps to access contact
information.
• URI-based Access: Content Providers use Uniform Resource Identifiers (URIs) to
identify the data, making it easy for apps to query or manipulate data.
• CRUD Operations: Content Providers support Create, Read, Update, and Delete (CRUD)
operations, allowing applications to manipulate the data they expose.

Key Classes and Methods Used for Content Providers:

1. ContentProvider Class:
o The base class for all Content Providers. You must subclass this class to create
your own Content Provider.
o Important methods to override:
▪ onCreate(): Called when the Content Provider is first created. It is used to
initialize the provider and set up any necessary resources.
▪ query(): Called to retrieve data from the Content Provider. You return a
Cursor that contains the data.
▪ insert(): Called to insert new data into the Content Provider. You return
the URI of the newly created record.
▪ update(): Called to update existing data. It returns the number of rows
affected.
▪ delete(): Called to delete data. It returns the number of rows deleted.
▪ getType(): Called to return the MIME type of the data at the given URI.
2. ContentResolver Class:
o Provides methods to access and manipulate data from a Content Provider.
o Important methods to use:
▪ query(Uri uri, String[] projection, String selection, String[]
selectionArgs, String sortOrder): Used to retrieve data.
▪ insert(Uri uri, ContentValues values): Used to insert data.
▪ update(Uri uri, ContentValues values, String selection, String[]
selectionArgs): Used to update existing data.
▪ delete(Uri uri, String selection, String[] selectionArgs): Used to
delete data.
▪ getType(Uri uri): Used to retrieve the MIME type for the data at the given
URI.

Location and Mapping in Android

Location and mapping services are essential features in mobile applications, providing users with location-
based functionalities such as navigation, nearby services, and more. In Android, this can be achieved
through Google Maps and Location Services. Below, we’ll explain these concepts with real-life examples,
including the relevant classes and methods.
Real-Life Example: A Food Delivery App
Imagine a food delivery app where users can order food from local restaurants. The app uses location-
based services to show restaurants nearby, allows users to view their location on the map, and tracks the
delivery person’s location in real-time. Here's how to implement this:
Key Concepts and Components
1. Location-Based Services:
o Use Case: Find nearby restaurants based on the user’s current location.
o Classes and Methods:
▪ FusedLocationProviderClient: This class is part of Google Play Services and
provides access to the device’s location services.
▪ Methods:
▪ getLastLocation(): Retrieves the last known location of the
device.
▪ requestLocationUpdates(): Requests periodic location
updates.
2. Mapping:
o Use Case: Display a map showing the user’s location and nearby restaurants.
o Classes and Methods:
▪ MapView: A view that displays a map. It allows you to control the map in your
layout.
▪ Methods:
▪ onCreate(), onResume(), onPause(), onDestroy():
Lifecycle methods to manage the map's lifecycle.
▪ getMapAsync(OnMapReadyCallback callback):
Initializes the map asynchronously.
▪ GoogleMap: Represents the map itself and provides methods to manipulate it.
▪ Methods:
▪ addMarker(MarkerOptions options): Adds a marker to
the map.
▪ moveCamera(CameraUpdate update): Moves the
camera to a specific position.
3. Google Maps Activity:
o Use Case: To provide a full-screen map activity for navigation.
o Classes and Methods:
▪ MapActivity: An activity that provides built-in support for displaying a map.
▪ Methods:
▪ onCreate(): Set up the map.
▪ onMapReady(GoogleMap googleMap): Callback
method to handle the map when it's ready.
Implementation Steps
1. Setting Up Location Services
First, you'll need to set up location services to get the user’s location.
java
import com.google.android.gms.location.FusedLocationProviderClient;
import com.google.android.gms.location.LocationServices;
 import com.google.android.gms.tasks.OnSuccessListener;

public class MainActivity extends AppCompatActivity {

private FusedLocationProviderClient fusedLocationClient;

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

fusedLocationClient = LocationServices.getFusedLocationProviderClient(this);

// Get last known location

fusedLocationClient.getLastLocation()
.addOnSuccessListener(this, new OnSuccessListener<Location>() {
@Override
public void onSuccess(Location location) {
if (location != null) {
// Use the location object
double latitude = location.getLatitude();
double longitude = location.getLongitude();
// Show nearby restaurants based on this location
}
}
});
}
}
2. Integrating Google Maps with MapView
Next, you can integrate Google Maps into your application.
<!-- activity_map.xml -->
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent">

<com.google.android.gms.maps.MapView
android:id="@+id/mapView"
android:layout_width="match_parent"
android:layout_height="match_parent"/>
</RelativeLayout>

Java
import com.google.android.gms.maps.GoogleMap;
import com.google.android.gms.maps.MapView;
import com.google.android.gms.maps.OnMapReadyCallback;
 public class MapActivity extends AppCompatActivity implements OnMapReadyCallback {
private MapView mapView;
private GoogleMap googleMap;

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

mapView = findViewById(R.id.mapView);
mapView.onCreate(savedInstanceState);
mapView.getMapAsync(this);
}

@Override
public void onMapReady(GoogleMap map) {
googleMap = map;

// Set the map to show the user's current location

googleMap.setMyLocationEnabled(true);

// Add a marker for a nearby restaurant

LatLng restaurantLocation = new LatLng(12.9716, 77.5946); // Example coordinates
googleMap.addMarker(new MarkerOptions().position(restaurantLocation).title("Nearby
Restaurant"));
googleMap.moveCamera(CameraUpdateFactory.newLatLngZoom(restaurantLocation, 15));
}

@Override
protected void onResume() {
super.onResume();
mapView.onResume();
}

@Override
protected void onPause() {
super.onPause();
mapView.onPause();
}

@Override
protected void onDestroy() {
super.onDestroy();
mapView.onDestroy();
}
 @Override
public void onLowMemory() {
super.onLowMemory();
mapView.onLowMemory();
}
}
Explanation of the Code:
1. Location Services:
o In MainActivity, we use FusedLocationProviderClient to get the last known location of the
user. If a valid location is available, it can be used to find nearby restaurants.
2. MapView Setup:
o In MapActivity, we set up a MapView in the layout to display the Google Map.
o We implement OnMapReadyCallback to know when the map is ready to be manipulated.
o In onMapReady(), we can add markers to the map, such as for nearby restaurants, and
enable user location tracking.
Real-Life Application Features
• Nearby Restaurant Discovery: Users can see nearby restaurants based on their current location.
• Navigation: Users can tap on a restaurant marker to get navigation directions.
• Delivery Tracking: Delivery persons can also use the map to navigate to the user's location in real-
time.

In Android, sensors provide data about the environment of the device, which can enhance the
functionality and interactivity of applications. Android devices come with a wide variety of sensors that
measure everything from device orientation to physical environment conditions like temperature and air
pressure.
Accessing Sensors in Android
To access sensors in an Android application, you use the SensorManager class. This class provides
methods to retrieve and register various sensors.
Steps to Access Sensors in Android
1. Declare Permissions (if needed): Some sensors, like location-based sensors, require specific
permissions. Declare these in the AndroidManifest.xml.
2. Get an Instance of SensorManager: Use SensorManager to access sensors on the device.
SensorManager sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
3. Get Specific Sensors: Use SensorManager.getDefaultSensor() to get specific sensors like
accelerometer or gyroscope.
Sensor accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
4. Register the Sensor Listener: Implement SensorEventListener and register it with SensorManager
to listen for changes in sensor data.
sensorManager.registerListener(sensorEventListener, accelerometer,
SensorManager.SENSOR_DELAY_NORMAL);
5. Handle Sensor Data: In onSensorChanged, use the SensorEvent to get data from the sensor.
SensorEventListener sensorEventListener = new SensorEventListener() {
@Override
 public void onSensorChanged(SensorEvent event) {
float[] values = event.values; // Get sensor data
}

@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
// Handle accuracy changes
}
};
Different Sensors Supported by Android
Android devices support three main types of sensors: Motion sensors, Environmental sensors, and
Position sensors. Here’s an overview of each type and the sensors within each category:

1. Motion Sensors
Motion sensors measure the physical movement of the device and are commonly used in gaming, fitness,
and navigation applications.
• Accelerometer (Sensor.TYPE_ACCELEROMETER): Measures the device's acceleration along three
axes (X, Y, and Z) and detects device movement or tilt.
• Gyroscope (Sensor.TYPE_GYROSCOPE): Measures the device's rate of rotation around each axis.
Useful for applications that need precise orientation, like VR or AR apps.
• Gravity Sensor (Sensor.TYPE_GRAVITY): Measures the force of gravity on each axis. Often derived
from the accelerometer to provide a stable reference for the device's orientation.
• Linear Acceleration (Sensor.TYPE_LINEAR_ACCELERATION): Provides the acceleration of the
device minus the gravity, giving the pure linear motion.
• Rotation Vector (Sensor.TYPE_ROTATION_VECTOR): Measures the device's orientation in three
dimensions. Useful in AR, gaming, and VR applications.
• Step Counter (Sensor.TYPE_STEP_COUNTER): Counts the steps taken by the user, great for fitness
or health apps.

2. Environmental Sensors
Environmental sensors provide information about the environment around the device. These sensors are
useful for apps that track atmospheric or physical conditions.
• Ambient Temperature (Sensor.TYPE_AMBIENT_TEMPERATURE): Measures the air temperature
near the device in degrees Celsius.
• Light Sensor (Sensor.TYPE_LIGHT): Measures ambient light levels (lux) and is typically used for
adjusting screen brightness based on lighting conditions.
• Pressure Sensor (Sensor.TYPE_PRESSURE): Measures air pressure in hectopascals (hPa) and is
often used to determine altitude changes.
• Humidity Sensor (Sensor.TYPE_RELATIVE_HUMIDITY): Measures relative humidity in the
environment around the device. Useful in weather or environment monitoring apps.

3. Position Sensors
Position sensors provide the physical position of the device relative to the Earth’s magnetic field. These
sensors are typically used in navigation, location-based services, and augmented reality applications.
 • Proximity Sensor (Sensor.TYPE_PROXIMITY): Detects if an object is close to the device. Commonly
used to turn off the screen when the user places the phone near their ear during a call.
• Magnetic Field Sensor (Sensor.TYPE_MAGNETIC_FIELD): Measures the magnetic field around the
device and is often used for compass applications to determine the direction.
• Orientation Sensor (Deprecated): Previously provided device orientation, but its functionality is
now covered by accelerometer and gyroscope.
• Geometric Rotation Vector (Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR): Provides device
orientation without using the gyroscope, making it more battery-efficient for AR applications.

In Android applications, playing and recording audio and video is achieved using the MediaPlayer,
MediaRecorder, and ExoPlayer (for more complex needs) APIs. These classes provide a range of options
for media playback and capture, making it possible to create rich multimedia applications.
1. Playing Audio and Video in Android
a. Using MediaPlayer for Audio Playback
The MediaPlayer class is ideal for playing audio and video files. It supports local resources and streaming
from the internet.
Steps for Audio Playback with MediaPlayer:
1. Initialize the MediaPlayer:
o To play an audio file, initialize MediaPlayer and set the data source to a local resource or a
URL.
MediaPlayer mediaPlayer = MediaPlayer.create(this, R.raw.sample_audio); // For local audio
// Or use mediaPlayer.setDataSource("audio_url");
for online streaming
2. Prepare and Start Playback:
o Call mediaPlayer.start() to begin playback.
mediaPlayer.start();
3. Pause and Stop Playback:
o Use mediaPlayer.pause() to pause and mediaPlayer.stop() to stop playback.
4. Release Resources:
o Always release MediaPlayer resources when done using mediaPlayer.release() to free
memory.
5. Example Code for Audio Playback:
MediaPlayer mediaPlayer = MediaPlayer.create(this, R.raw.sample_audio);

// Start playback
mediaPlayer.start();

// Stop playback
mediaPlayer.stop();

// Release resources
mediaPlayer.release();
b. Using MediaPlayer for Video Playback
Playing video is similar to playing audio, with an additional UI component (VideoView) to display the
video.
Steps for Video Playback:
1. Add a VideoView to Layout:
o Include a VideoView in the XML layout to display video content.
<VideoView
android:id="@+id/videoView"
android:layout_width="match_parent"
android:layout_height="wrap_content" />
2. Initialize VideoView and Set Data Source:
o Set the video URI using videoView.setVideoURI().
3. Control Video Playback:
o Use start(), pause(), and stopPlayback() methods of VideoView.
4. Example Code for Video Playback:
VideoView videoView = findViewById(R.id.videoView);
Uri videoUri = Uri.parse("android.resource://" + getPackageName() + "/" + R.raw.sample_video);
videoView.setVideoURI(videoUri);

// Start playback
videoView.start();
c. Using ExoPlayer for Advanced Playback
ExoPlayer is recommended for more complex requirements, such as streaming, adaptive bitrates, and
subtitles.
2. Recording Audio in Android
The MediaRecorder class is used to capture audio in Android.
Steps for Audio Recording with MediaRecorder:
1. Set Up Permissions:
o Add RECORD_AUDIO and WRITE_EXTERNAL_STORAGE permissions in the manifest file.
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
2. Initialize MediaRecorder:
o Configure MediaRecorder by setting the audio source, output format, and encoding.
MediaRecorder mediaRecorder = new MediaRecorder();
mediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
mediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
mediaRecorder.setOutputFile(getExternalFilesDir(null).getAbsolutePath() +
"/recorded_audio.3gp");
3. Start and Stop Recording:
o Call mediaRecorder.prepare() and mediaRecorder.start() to begin recording. To stop, call
mediaRecorder.stop().
4. Release Resources:
o Use mediaRecorder.release() to release resources when done.
5. Example Code for Audio Recording:
MediaRecorder mediaRecorder = new MediaRecorder();
mediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
 mediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
mediaRecorder.setOutputFile(getExternalFilesDir(null).getAbsolutePath() + "/recorded_audio.3gp");

try {
mediaRecorder.prepare();
mediaRecorder.start();
} catch (IOException e) {
e.printStackTrace();
}

// To stop recording
mediaRecorder.stop();
mediaRecorder.release();
3. Recording Video in Android
Steps for Video Recording with MediaRecorder:
1. Set Up Permissions:
o Add CAMERA, RECORD_AUDIO, and WRITE_EXTERNAL_STORAGE permissions in the
manifest file.
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
2. Initialize Camera and MediaRecorder:
o Set the camera as the video source and configure other settings, such as output format
and file path.
3. Start and Stop Recording:
o Prepare the MediaRecorder, call start() to begin recording, and stop() to end it.
4. Release Resources:
o Always release both the camera and the MediaRecorder to free up resources.
Additional Notes on Media Recording
• Storage Paths: For recording, ensure that the output file is saved in a valid directory.
• Permissions: From Android 6.0 (API level 23), runtime permissions are required.
• Error Handling: Proper error handling is essential for preventing crashes due to unexpected
media issues.

Near Field Communication (NFC) is a short-range wireless technology that enables the exchange of data
between devices when they are brought close together, typically within a range of a few centimeters
(about 4 cm or less). NFC is often used in mobile devices like smartphones, tablets, and other compatible
gadgets. It operates at a frequency of 13.56 MHz, allowing quick, seamless communication between two
NFC-enabled devices or between an NFC device and an NFC tag.
Key Features of NFC
• Short Range: NFC works at a very close range, which enhances security by requiring devices to be
almost touching to exchange data.
• Low Power: NFC requires very little power to operate, making it suitable for mobile devices
without draining the battery quickly.
• Fast Connection: NFC establishes a connection almost instantly, within a fraction of a second.
 • Secure Communication: NFC’s close-range requirement reduces the risk of interception, making it
more secure for sensitive data transactions.
Modes of NFC Operation
1. Peer-to-Peer Mode: Allows two NFC-enabled devices to exchange data with each other, such as
sharing files or contacts.
2. Read/Write Mode: One device, typically a smartphone, reads data from or writes data to an NFC
tag (like a poster or product label).
3. Card Emulation Mode: This mode allows an NFC-enabled device, like a smartphone, to emulate a
contactless smart card, which can be used for mobile payments or entry to secured areas.
Common Uses of NFC
• Mobile Payments: NFC is widely used in digital payment systems like Google Pay, Apple Pay, and
Samsung Pay. The user can make a payment simply by tapping their smartphone near an NFC-
enabled payment terminal.
• Contactless Cards: NFC technology is embedded in contactless credit cards, access cards, and
transit passes.
• Data Sharing: With Android Beam (now replaced with Nearby Share on newer Android versions),
users can share files, contacts, and apps between devices.
• Smart Advertising: NFC tags on posters or products allow users to tap their phone to get
information, download content, or access a website.
• Home Automation: NFC can be used to trigger home automation actions, like enabling Wi-Fi or
setting an alarm by tapping on a designated NFC tag.
How NFC Works
NFC operates on the principle of electromagnetic induction, enabling it to communicate data by
generating an electromagnetic field between two devices. When two devices are close enough, an NFC-
enabled active device (like a smartphone) can read the information from an NFC-enabled passive device
(like an NFC tag) or initiate data exchange with another active NFC device.
NFC Classes and Methods in Android
In Android, NFC functionality is primarily handled through the NfcAdapter class. Here's a brief overview of
important classes and methods:
1. NfcAdapter: The main class for managing NFC communication.
o isEnabled(): Checks if NFC is enabled on the device.
o enableForegroundDispatch(): Allows an app to intercept NFC tags.
o disableForegroundDispatch(): Stops intercepting NFC tags.
2. NdefMessage and NdefRecord: Used for reading and writing NFC data in a format compatible
with most devices.
o NdefMessage(byte[] payload): Creates an NFC data message.
o NdefRecord.createTextRecord(): Creates an NFC text record.
3. PendingIntent: Used with enableForegroundDispatch() to handle NFC intents when a tag is
detected.

Advantages of NFC
• Convenience: Users can simply tap to pay, share, or authenticate, making it faster than Bluetooth.
• Security: Short-range communication minimizes the chance of data interception.
• Low Energy Consumption: Ideal for mobile devices as it doesn’t consume much battery.
Disadvantages of NFC
 • Limited Range: Requires close proximity, limiting its usability for certain applications.
• Security Risks: Although secure, it’s still susceptible to hacking attempts like eavesdropping and
relay attacks if not implemented properly.
NFC has become a core feature in modern mobile applications, enhancing user experience with
convenient, contactless interactions for payments, sharing, and accessing information.

In Android development, native libraries and headers play a significant role in providing functionality at a
low level for performance-intensive applications. These components are used in Android to leverage high-
performance C and C++ code within an app, especially for tasks like graphics rendering, audio processing,
and certain calculations that benefit from native execution speed.
Native Libraries in Android
Native libraries are precompiled libraries written in C or C++ that provide specific functionality for
Android applications. These libraries are part of the Android Native Development Kit (NDK) and allow
developers to utilize low-level system resources, improve performance, and access advanced
functionality.
Common Native Libraries in Android:
• libc: The standard C library for C language, providing basic functionalities like memory
management, file operations, and thread management.
• libm: The math library, which provides mathematical functions like sin, cos, sqrt, etc.
• libz: The compression library, often used for data compression in applications.
• OpenGL ES: A graphics library for 2D and 3D graphics rendering, essential for high-performance
applications like games.
• libGLES: OpenGL ES libraries that allow developers to implement complex graphics processing.
• WebKit: A library that provides web browsing functionalities within Android apps.
• SQLite: A relational database library allowing apps to use a database for data storage.
• SSL/TLS (libcrypto, libssl): Security libraries that provide encryption and network security
functionalities.
Uses of Native Libraries:
• Improved Performance: Since native code runs directly on the device’s hardware, it’s often faster
than code running in the Android runtime. This is especially beneficial for computationally
intensive tasks like image processing, games, and audio processing.
• Low-Level Hardware Access: Native libraries allow direct access to hardware components,
making them useful for applications that require detailed control over system resources.
• Porting Existing Code: Many applications, such as video players or scientific computation libraries,
have existing codebases in C or C++. Native libraries make it easier to reuse these without
rewriting them in Java.
Headers in Android
Headers are files that contain definitions of functions, constants, and data types used in native libraries.
In Android, header files (.h files) declare the functions, structures, and constants that you can call from
your C or C++ code. They act as an interface between your Android Java code and the underlying native
code.
Uses of Headers:
 • Define APIs for Native Libraries: Headers define the API interface for native libraries, allowing
Android apps to call native functions without needing to understand the low-level
implementation details.
• Enable JNI Communication: Headers are essential for Java Native Interface (JNI) code, which
allows Java code to call C/C++ functions. By including headers, developers can bridge Java and
native code in a safe and structured way.
• Code Organization and Reusability: Header files help in organizing code by separating
declarations from implementations, allowing multiple files to share functions and constants
without duplicating code.
How Native Libraries and Headers Work Together
1. Native Library Usage: When writing an Android application in Java, you might use the NDK to
write performance-critical code in C or C++. You can compile this code into a native library (like
.so file) and bundle it with your app.
2. Headers for JNI: If the Java part of your app needs to communicate with native code, it uses the
Java Native Interface (JNI) mechanism. JNI requires header files to map Java calls to native
methods in C/C++.
3. Calling Native Functions from Java: You declare native methods in Java, generate JNI headers,
implement those methods in C/C++, and then call them from Java. Headers provide the required
function definitions for JNI to understand what it’s calling.

Building a client-server application in Android involves developing an Android app that communicates
with a remote server over the network to access data, services, or functionality. This is commonly
achieved through RESTful APIs, WebSockets, or other protocols that enable the exchange of data between
the client (Android app) and the server.
Here's a step-by-step guide to building a client-server application in Android:
Step 1: Plan the Client-Server Interaction
• Define the requirements of the application: Determine what data the app will need from the
server and what actions users will perform.
• Design the API: Plan RESTful endpoints (e.g., GET /users, POST /login) for the server that the
Android app will call. Define the data formats (usually JSON) for requests and responses.
Step 2: Set Up the Server
The server handles requests from the Android app and sends responses, typically using HTTP. Here are
the steps for setting up the server:
1. Choose a Backend Framework: Common choices include Node.js (Express), Django, or Flask for
web servers.
2. Database Integration: Set up a database (e.g., MySQL, MongoDB) to store data for the app.
3. Create RESTful Endpoints: Implement endpoints to handle different requests from the Android
app (e.g., POST /login, GET /products).
4. Implement Authentication: Use JWT (JSON Web Tokens) or OAuth for secure communication.
5. Deploy the Server: Host the server on a cloud platform like AWS, Heroku, or DigitalOcean to make
it accessible online.
Step 3: Build the Android Client Application
1. Set Up Android Studio Project:
o Start a new project in Android Studio and set up the app’s dependencies.
2. Define Permissions in Manifest:
o Request the INTERNET permission in the AndroidManifest.xml to allow network requests:
<uses-permission android:name="android.permission.INTERNET"/>
3. Implement Networking Logic:
o Use libraries like Retrofit, OkHttp, or Volley to handle HTTP requests and parse JSON
responses.
o Retrofit is a popular choice for making HTTP requests in Android, as it’s easy to use and
well-suited for RESTful APIs.
public interface ApiService {
@GET("products")
Call<List<Product>> getProducts();

@POST("login")
Call<User> loginUser(@Body LoginRequest loginRequest);
}
4. Authentication and Session Management:
o Handle login sessions by storing tokens (e.g., JWTs) securely, using SharedPreferences or
encrypted storage.
SharedPreferences sharedPreferences = getSharedPreferences("app_prefs",
MODE_PRIVATE);
SharedPreferences.Editor editor = sharedPreferences.edit();
editor.putString("auth_token", token);
editor.apply();
5. UI Design and Data Binding:
o Design the UI with XML layouts, using components like RecyclerView for displaying lists.
o Use data binding or ViewModel (from Android Jetpack) for handling data updates in the
UI.
6. Display Data from Server:
o Create UI elements to display data fetched from the server. For example, show a list of
products retrieved from an API endpoint.
ApiService apiService = retrofit.create(ApiService.class);
apiService.getProducts().enqueue(new Callback<List<Product>>() {
@Override
public void onResponse(Call<List<Product>> call, Response<List<Product>> response) {
if (response.isSuccessful() && response.body() != null) {
// Update RecyclerView with data
}
}
@Override
public void onFailure(Call<List<Product>> call, Throwable t) {
// Handle error
}
 });
Step 4: Handle Errors and Edge Cases
• Error Handling: Handle HTTP errors, network issues, and timeouts by displaying user-friendly
messages in the app.
• Offline Mode: Consider caching data locally (using SQLite or Room database) to provide offline
functionality if needed.
• Data Security: Secure sensitive data and prevent unauthorized access.
Step 5: Testing and Debugging
• API Testing: Test server endpoints with tools like Postman before integrating with the Android
app.
• Client Testing: Test different scenarios in the Android app, such as handling slow networks, errors,
and unauthorized access.
• Debugging: Use Android Studio's debugger and logcat to troubleshoot issues.
Step 6: Deployment and Maintenance
• Deploy the Server: Deploy the backend on a secure and reliable platform, ensuring it’s accessible
via a URL.
• Release the App: Publish the Android app on the Google Play Store, following Android’s
deployment guidelines.
• Monitoring: Monitor the app's usage and performance, and regularly update both the client and
server to improve security and functionality.
Example Architecture
• Backend: A Node.js server hosted on AWS or DigitalOcean with MongoDB as a database.
• Client: Android app developed with Retrofit for HTTP requests, a local Room database for
caching, and a user-friendly UI using XML layouts and ViewModel for state management.
• Authentication: JWT-based login, stored in SharedPreferences.
Key Libraries
• Retrofit/OkHttp: HTTP requests and REST API calls.
• Gson: JSON serialization and deserialization for data handling.
• Room: Local database storage for offline mode.
• Glide or Picasso: Image loading for profiles or thumbnails from the server.
With these steps and tools, you can create a responsive and scalable Android client-server application
capable of managing data and user interactions effectively across networked services.