Mobile Application Development Topics

(1)
Fragments are a fundamental part of Android app development,
Especially when creating dynamic and flexible user interfaces for various screen sizes (like
phones, tablets, etc.).

What is a Fragment?

A Fragment is a reusable portion of an Android app's user interface (UI).

It acts as a small, modular piece of an activity, which:

 Has its own lifecycle

(similar to an activity but dependent on the parent activity).
 Can contain its own layout and logic.
 Can be added, removed, or replaced dynamically while the app is running.

Fragments are helpful in creating responsive layouts and reusable components within
your app.

Types of Fragments

1. Static Fragments
2. Dynamic Fragments

1. Static Fragments

Static fragments are defined in the XML layout of an activity. These fragments are fixed and
cannot be added, removed, or replaced at runtime.
Key Points:

 Added at design time in XML.

 They remain fixed during the app's runtime.
 Useful when the fragment's content is consistent and doesn't need to change
dynamically.
Example of Static Fragment:

<!-- activity_main.xml -->

<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">

<!-- Static Fragment -->

<fragment
android:id="@+id/staticFragment"
android:name="com.example.MyStaticFragment"
android:layout_width="match_parent"
android:layout_height="wrap_content" />
</LinearLayout>

Here, the fragment is part of the layout and will always appear when the activity is loaded.
2. Dynamic Fragments

Dynamic fragments are added, removed, or replaced programmatically during

runtime.

This allows for more flexibility in building UIs.

Key Points:

 Managed using the FragmentManager.

 Can be added to or removed from a FrameLayout (or other ViewGroup) in the
activity.
 Useful for apps where
the UI needs to change dynamically (e.g., switching
between fragments for navigation).
Example of Dynamic Fragment:

XML Layout (container):

<!-- activity_main.xml -->

<FrameLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/fragmentContainer"
android:layout_width="match_parent"
android:layout_height="match_parent" />

Fragment Class:

// MyDynamicFragment.java
public class MyDynamicFragment extends Fragment {
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle
savedInstanceState) {
 // Inflate fragment layout
return inflater.inflate(R.layout.fragment_dynamic, container, false);
}
}

Activity Code (Add/Replace Fragment):

// MainActivity.java
FragmentManager fragmentManager = getSupportFragmentManager();
FragmentTransaction transaction =
fragmentManager.beginTransaction();

// Create an instance of the fragment

MyDynamicFragment fragment = new MyDynamicFragment();

// Add/Replace the fragment in the container

transaction.replace(R.id.fragmentContainer, fragment);
transaction.commit();

When to Use Static vs Dynamic Fragments

Static Fragments Dynamic Fragments

When you need to change fragments at
When the fragment layout is constant.
runtime.
Simpler to implement (defined in XML). Requires programmatic management.
Suitable for apps with minimal UI
Ideal for apps with flexible or dynamic UIs.
changes.

Fragment Lifecycle Overview

Fragments have their own lifecycle methods that are closely tied to the activity lifecycle:

1. onAttach():

Called when the fragment is attached to the activity.

2. onCreate():

Called when the fragment is created.

3. onCreateView():

Called to create the fragment's UI.

4. onActivityCreated():
 Called when the activity's onCreate() is done.
5. onStart(), onResume(),

etc.: Similar to activity lifecycle methods.

6. onPause(), onStop(), and onDestroyView(): Handle fragment cleanup.

7. onDetach(): Called when the fragment is detached from the activity.

Advantages of Using Fragments

 Reusable UI Components:

Fragments can be reused in multiple activities.

 Responsive Design:

Adapts to different screen sizes (e.g., phones vs. tablets).

 Dynamic UI:

Allows changing UIs dynamically at runtime.

 Code Modularity:

Keeps your code organized by separating UI components into smaller,

manageable parts.

(2)
2. Lifecycle of Fragments

The lifecycle of a Fragment is very similar to an Activity, but with some extra methods. Here's how it works:

a. Fragment Lifecycle Stages

1. onAttach(Context context)
o This is the first step when the fragment is attached to its parent activity.
o You can use this to get a reference to the activity.
Example:

You might connect the fragment to the activity here.

2. onCreate(Bundle savedInstanceState)
 o The fragment is created, but it’s not visible yet.
o Use this method for setting up things that will stay the same, like initializing
variables or fetching data.
3. onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
o The fragment creates its user interface here.
o You inflate the XML layout file for the fragment here.

Example:
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
return inflater.inflate(R.layout.fragment_layout, container,
false);
}

4. onViewCreated(View view, Bundle savedInstanceState)

o After the view is created, you can access UI elements (like buttons, text
views) and set up event listeners.
5. onStart()
o The fragment becomes visible to the user but not yet interactive.
6. onResume()
o The fragment is now visible and ready for user interaction.
7. onPause()
o The fragment is partially visible or is being covered by another activity/fragment.
8. onStop()
o The fragment is completely hidden and no longer visible.
9. onDestroyView()
o The fragment’s view is destroyed. Use this to clean up resources related to
the view.
10. onDestroy()
o The fragment is completely destroyed. Clean up any resources here.
11. onDetach()
o The fragment is detached from its parent activity.

b. Lifecycle Flow Diagram

Here’s the simplified flow of how the fragment lifecycle works:

onAttach → onCreate → onCreateView → onViewCreated → onStart → onResume

(Visible and interactive)
onPause → onStop → onDestroyView → onDestroy → onDetach
3. Communication Between Fragments and Activity

Fragments often need to communicate with their parent activity or other fragments. Here's how you can do it.

a. Fragment to Activity Communication

1. Use an interface to define a listener.

2. Implement this interface in the activity.

Example:
Step 1: Create an interface in the fragment.

public interface FragmentListener {

void onMessageSent(String message);
}
Step 2: Call the listener from the fragment.

FragmentListener listener;
@Override
public void onAttach(Context context) {
super.onAttach(context);
if (context instanceof FragmentListener) {
listener = (FragmentListener) context;
} else {
throw new RuntimeException(context.toString() + " must
implement FragmentListener");
}
}

void sendMessageToActivity() {
if (listener != null) {
listener.onMessageSent("Hello from Fragment!");
}
}
Step 3: Implement the interface in the Activity.

public class MainActivity extends AppCompatActivity

implements Fragment.FragmentListener {
@Override
public void onMessageSent(String message) {
Log.d("Message", message);
}
}

b. Fragment to Fragment Communication

1. Use the parent activity as a mediator.

2. Pass messages between fragments via the activity.

Example:

 Fragment A sends a message to the activity.

 The activity passes the message to Fragment B.

c. Using ViewModel for Communication (Modern Approach)

If both fragments are in the same activity, you can use a shared ViewModel for
easier communication.

Example:
Step 1: Create a shared ViewModel.

public class SharedViewModel extends ViewModel {

private MutableLiveData<String> message = new MutableLiveData<>();
public LiveData<String> getMessage() {
return message;
}
public void sendMessage(String msg) {
message.setValue(msg);
}
}

Step 2: Use the ViewModel in both fragments.

SharedViewModel viewModel = new

ViewModelProvider(requireActivity()).get(SharedViewModel.class);

 Fragment A sends a message:

viewModel.sendMessage("Hello Fragment B!");

 Fragment B observes the message:

viewModel.getMessage().observe(getViewLifecycleOwner(), message -> {

textView.setText(message);
});

4. Summary

 Fragment Lifecycle has extra methods like onAttach, onCreateView, and onDetach.
 Communication is done via interfaces, activity mediators, or shared ViewModels
(modern approach).
 Use ViewModels for cleaner, easier communication when fragments share the
same activity.

(3)
Sure! Let’s go through Creating a Tabbed Activity step by step in a simple way.

1. What is a Tabbed Activity?

A Tabbed Activity is an Android screen where you can switch between different sections of content by tapping
on tabs at the top or swiping left and right. For example:

 A messaging app might have tabs for "Chats," "Status," and "Calls."
 An e-commerce app might have tabs for "Home," "Categories," and "Account."

2. How to Create a Tabbed Activity?

You can easily create a Tabbed Activity in Android Studio. Follow these steps:

Step 1: Create a New Tabbed Activity

1. Open Android Studio.

2. Select File → New → New Project.
3. Choose Tabbed Activity from the list of activity templates.
4. Name your project, select the minimum SDK, and click Finish.

Step 2: Understanding the Default Files

When you create a Tabbed Activity, Android Studio generates the following files:

 MainActivity.java (or MainActivity.kt): This is the main activity where tabs are set up.
 SectionsPagerAdapter.java (or SectionsPagerAdapter.kt): This handles switching between different
fragments for the tabs.
 Fragment Files (e.g., Fragment1, Fragment2): Each tab has its own fragment to display content.
 activity_main.xml: This layout contains a ViewPager and TabLayout for the tabs.

Step 3: Modify the Tabs

1. Update the Tab Titles:

Open SectionsPagerAdapter.java and modify the getPageTitle() method to set the names of the
tabs.
2. @Override
3. public CharSequence getPageTitle(int position) {
4. switch (position) {
5. case 0:
6. return "Tab 1";
7. case 1:
8. return "Tab 2";
9. case 2:
10. return "Tab 3";
11. }
12. return null;
13. }
 14. Add or Remove Tabs:
To add a new tab, increase the count in getCount():
15. @Override
16. public int getCount() {
17. return 3; // Number of tabs
18. }

Step 4: Design the Fragments

Each tab is linked to a fragment. Modify the fragment XML and Java/Kotlin files to customize the content.

Example (fragment_tab1.xml):

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:gravity="center">

<TextView
android:id="@+id/textView"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="This is Tab 1"
android:textSize="18sp" />
</LinearLayout>

Example (FragmentTab1.java):

public class FragmentTab1 extends Fragment {

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle
savedInstanceState) {
return inflater.inflate(R.layout.fragment_tab1, container, false);
}
}

Step 5: Link Fragments to Tabs

In SectionsPagerAdapter.java, link the correct fragment to each tab:

@Override
public Fragment getItem(int position) {
switch (position) {
case 0:
return new FragmentTab1();
case 1:
return new FragmentTab2();
case 2:
return new FragmentTab3();
}
return null;
}

Step 6: Run the App

 1. Connect your Android device or start the emulator.
2. Click the Run button in Android Studio.
3. You’ll see a Tabbed Activity with swipeable tabs.

3. Adding Customizations

a. Add Icons to Tabs

If you want to show icons in the tabs instead of text:

1. Add drawable icons (e.g., icon1.png, icon2.png) to the res/drawable folder.

2. Modify the TabLayout setup in MainActivity.java:
3. TabLayout tabLayout = findViewById(R.id.tabs);
4. tabLayout.getTabAt(0).setIcon(R.drawable.icon1);
5. tabLayout.getTabAt(1).setIcon(R.drawable.icon2);

b. Change Tab Layout Colors

You can customize the colors of the tabs by modifying the res/values/themes.xml file:

<item name="colorPrimary">#6200EE</item> <!-- Tab background color -->

<item name="colorAccent">#03DAC5</item> <!-- Selected tab color -->

4. Key Components Explained

 TabLayout:
Displays the tabs at the top of the screen.
 ViewPager:
Allows swiping between different fragments.
 SectionsPagerAdapter:
Manages which fragment to display for each tab.

(4)
Setting Up Tabs with ViewPager (Simplified Explanation)

When building a mobile app, you might want to organize content into tabs (like WhatsApp with "Chats,"
"Status," and "Calls"). To achieve this in Android, you can use Tabs with ViewPager. Here's how you can set
it up step by step.

1. What is ViewPager?

 ViewPager is a component in Android that allows users to swipe between screens (or pages)
horizontally.
 You can combine it with TabLayout to display tabs at the top and allow users to switch between them.
2. Tools You'll Use

 ViewPager2: The updated version of ViewPager for better performance and features.
 TabLayout: A component to show tabs at the top.
 Fragment: Each tab usually has its own fragment.

3. Step-by-Step Guide

a. Add Dependencies

First, ensure you have the required libraries in your build.gradle file.

dependencies {
implementation 'androidx.viewpager2:viewpager2:1.0.0'
implementation 'com.google.android.material:material:1.8.0'
}

b. Create the Layout

Define the layout in your XML file with a TabLayout and a ViewPager2.

<!-- res/layout/activity_main.xml -->

<androidx.coordinatorlayout.widget.CoordinatorLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent">

<!-- TabLayout for displaying tabs -->

<com.google.android.material.tabs.TabLayout
android:id="@+id/tabLayout"
android:layout_width="match_parent"
android:layout_height="wrap_content" />

<!-- ViewPager2 for swiping between pages -->

<androidx.viewpager2.widget.ViewPager2
android:id="@+id/viewPager"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:layout_marginTop="56dp" />
</androidx.coordinatorlayout.widget.CoordinatorLayout>

c. Create Fragments for Each Tab

Each tab will have its own Fragment.

Example: Tab 1 (Home Fragment)

public class HomeFragment extends Fragment {

@Nullable
@Override
 public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup
container, @Nullable Bundle savedInstanceState) {
return inflater.inflate(R.layout.fragment_home, container, false);
}
}

Example: Tab 2 (Profile Fragment)

public class ProfileFragment extends Fragment {

@Nullable
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup
container, @Nullable Bundle savedInstanceState) {
return inflater.inflate(R.layout.fragment_profile, container, false);
}
}

d. Create a ViewPagerAdapter

This adapter tells the ViewPager which fragment to display for each tab.

public class ViewPagerAdapter extends FragmentStateAdapter {

public ViewPagerAdapter(@NonNull FragmentActivity fragmentActivity) {

super(fragmentActivity);
}

@NonNull
@Override
public Fragment createFragment(int position) {
// Return the fragment based on the tab position
switch (position) {
case 0:
return new HomeFragment();
case 1:
return new ProfileFragment();
default:
return new HomeFragment();
}
}

@Override
public int getItemCount() {
// Number of tabs
return 2;
}
}

e. Set Up the Tabs in the Main Activity

Now, link the TabLayout and ViewPager2 in your MainActivity.

public class MainActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
 // Find TabLayout and ViewPager2
TabLayout tabLayout = findViewById(R.id.tabLayout);
ViewPager2 viewPager = findViewById(R.id.viewPager);

// Set up the ViewPager with the adapter

ViewPagerAdapter adapter = new ViewPagerAdapter(this);
viewPager.setAdapter(adapter);

// Link the TabLayout with the ViewPager

new TabLayoutMediator(tabLayout, viewPager, (tab, position) -> {
switch (position) {
case 0:
tab.setText("Home");
break;
case 1:
tab.setText("Profile");
break;
}
}).attach();
}
}

4. How It Works

 ViewPager2: Handles the horizontal swiping between fragments.

 TabLayoutMediator: Connects the tabs to the ViewPager and updates them when swiped.
 Adapter: Provides the right fragment for each position.

5. Summary

 Create a TabLayout and ViewPager2 in your layout.

 Build separate fragments for each tab.
 Use a ViewPagerAdapter to supply fragments to the ViewPager.
 Use TabLayoutMediator to link the tabs and ViewPager.

Example Output

If you swipe or click on the tabs:

1. Tab 1 (Home) shows content like "Welcome to Home."

2. Tab 2 (Profile) shows content like "This is your Profile."

(5)
Calling Built-in Applications Using Intents in Android

In Android, you can use Intents to call built-in applications, like the camera, phone dialer, browser, email, etc.
Intents are a way for your app to interact with other apps or system components.
Let’s break this topic into small, simple steps.

1. What is an Intent?

An Intent is a messaging object used to request an action from another app or system service.
For example:

 Opening a webpage in the browser.

 Calling a phone number using the dialer.
 Capturing a photo using the camera app.

There are two main types of Intents:

1. Explicit Intent: Used to start a specific activity within your app.

2. Implicit Intent: Used to request actions from other apps or system services (e.g., calling built-in apps).

2. Using Intents to Call Built-in Applications

Here are examples of how to use Intents to call common built-in apps.

a. Open a Webpage in the Browser

To open a webpage, you can use the ACTION_VIEW Intent with a URL.

Code Example:

Intent intent = new Intent(Intent.ACTION_VIEW);

intent.setData(Uri.parse("https://www.google.com"));
startActivity(intent);

 Explanation:
o ACTION_VIEW: Tells the system you want to view something.
o Uri.parse: Converts the URL into a format the browser can understand.
o startActivity(intent): Launches the browser app.

b. Make a Phone Call

To make a phone call, you use the ACTION_DIAL or ACTION_CALL Intent.

⚠️Note: You need permissions for ACTION_CALL.

Code Example:

 To Open the Dialer (ACTION_DIAL):

Intent intent = new Intent(Intent.ACTION_DIAL);
intent.setData(Uri.parse("tel:+1234567890"));
startActivity(intent);

 To Directly Make a Call (ACTION_CALL):

Intent intent = new Intent(Intent.ACTION_CALL);

intent.setData(Uri.parse("tel:+1234567890"));
startActivity(intent);

 Permissions for ACTION_CALL (in AndroidManifest.xml):

<uses-permission android:name="android.permission.CALL_PHONE" />

c. Send an Email

To send an email, use the ACTION_SENDTO Intent with the "mailto:" scheme.

Code Example:

Intent intent = new Intent(Intent.ACTION_SENDTO);

intent.setData(Uri.parse("mailto:[email protected]"));
intent.putExtra(Intent.EXTRA_SUBJECT, "Hello!");
intent.putExtra(Intent.EXTRA_TEXT, "This is the email body.");
startActivity(intent);

 Explanation:
o ACTION_SENDTO: Tells the system to send a message to someone.
o mailto:: Specifies that this is an email.
o putExtra: Adds extra information like subject or message body.

d. Open the Camera App

To open the camera app and capture a photo, use ACTION_IMAGE_CAPTURE.

Code Example:

Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);

startActivityForResult(intent, 101); // 101 is the request code

 Explanation:
o ACTION_IMAGE_CAPTURE: Opens the camera to capture an image.
o startActivityForResult: Allows you to handle the result (like the photo) after the camera app
finishes.

e. Open the SMS App

To send an SMS, use the ACTION_SENDTO Intent with the "smsto:" scheme.
Code Example:

Intent intent = new Intent(Intent.ACTION_SENDTO);

intent.setData(Uri.parse("smsto:+1234567890"));
intent.putExtra("sms_body", "Hello, this is a message!");
startActivity(intent);

 Explanation:
o smsto:: Specifies that the Intent is for sending SMS.
o putExtra("sms_body"): Adds the message text.

f. Pick a Contact

To pick a contact from the Contacts app, use ACTION_PICK.

Code Example:

Intent intent = new Intent(Intent.ACTION_PICK);

intent.setType(ContactsContract.CommonDataKinds.Phone.CONTENT_TYPE);
startActivityForResult(intent, 102); // 102 is the request code

 Explanation:
o ACTION_PICK: Opens the Contacts app.
o CONTENT_TYPE: Filters the results to show phone numbers only.

3. Handling the Result of an Intent

Some Intents, like capturing a photo or picking a contact, return a result. You can handle these results in the
onActivityResult method.

Example: Handling Camera Result

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);

if (requestCode == 101 && resultCode == RESULT_OK) {

// Handle the captured image
Bitmap photo = (Bitmap) data.getExtras().get("data");
imageView.setImageBitmap(photo); // Display the photo in an ImageView
}
}

4. Permissions

Some Intents (like calling or accessing the camera) require permissions.

You must:

1. Add the permission in the AndroidManifest.xml file.

 2. Request the permission at runtime (for dangerous permissions like CALL_PHONE).

Example of Runtime Permission:

if (ContextCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE) !=
PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CALL_PHONE},
1);
}

5. Summary

 Intents let you call built-in apps easily.

 Use ACTION_* constants like ACTION_VIEW, ACTION_DIAL, or ACTION_IMAGE_CAPTURE to define what
action you want.
 Always handle permissions carefully for sensitive actions like making calls or using the camera.
 Use startActivityForResult to get results from apps like the camera or contacts.

(6)
Sure! Let's dive into the topic "Working with Built-in and Implicit Intents" in a simple way.

1. What is an Intent?

An Intent is like a message that you send to Android to do something. It can be used to:

 Start an activity
 Start a service
 Deliver a message to another app or part of your app

There are two main types of intents:

1. Explicit Intents: You tell Android exactly which activity or component you want to open.
2. Implicit Intents: You tell Android what you want to do, and it decides which app can handle it.

2. What are Built-in Intents?

Android provides built-in intents that you can use to perform common tasks. For example:

 Open a webpage
 Dial a phone number
 Send an email
 Share text or images

These tasks are predefined and handled by Android or other apps installed on the device.
3. What are Implicit Intents?

An Implicit Intent doesn’t specify which app or component to use. Instead, it describes the action you want to
perform. Android will show a list of apps that can handle the action, and the user can choose one.

4. How to Work with Built-in and Implicit Intents

Let’s look at some examples to make it clear.

a. Opening a Webpage

If you want to open a webpage, you can use an implicit intent.

Intent intent = new Intent(Intent.ACTION_VIEW);

intent.setData(Uri.parse("https://www.google.com"));
startActivity(intent);

 ACTION_VIEW: Tells Android you want to view something.

 setData(Uri): Specifies the webpage URL.

b. Dialing a Phone Number

If you want to open the phone app with a number pre-filled:

Intent intent = new Intent(Intent.ACTION_DIAL);

intent.setData(Uri.parse("tel:123456789"));
startActivity(intent);

 ACTION_DIAL: Tells Android to open the dialer.

 tel:: Specifies the phone number.

c. Sending an Email

You can use an implicit intent to open the email app with pre-filled fields.

Intent intent = new Intent(Intent.ACTION_SEND);

intent.setType("message/rfc822");
intent.putExtra(Intent.EXTRA_EMAIL, new String[]{"[email protected]"});
intent.putExtra(Intent.EXTRA_SUBJECT, "Subject of the Email");
intent.putExtra(Intent.EXTRA_TEXT, "Body of the Email");
startActivity(Intent.createChooser(intent, "Choose an Email client"));

 ACTION_SEND: Tells Android to send something.

 putExtra: Adds data like recipient, subject, and body to the email.
d. Sharing Text or Images

If you want to share text (like a message or URL):

Intent intent = new Intent(Intent.ACTION_SEND);

intent.setType("text/plain");
intent.putExtra(Intent.EXTRA_TEXT, "This is a message to share.");
startActivity(Intent.createChooser(intent, "Share using"));

 ACTION_SEND: Tells Android you want to share.

 setType: Specifies the type of content (text, image, etc.).
 EXTRA_TEXT: Contains the text you want to share.

e. Capturing a Photo

If you want to launch the camera app:

Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);

startActivity(intent);

 ACTION_IMAGE_CAPTURE: Tells Android to open the camera.

5. Handling Implicit Intents in Your App

Sometimes, your app might want to handle implicit intents from other apps. For example, if your app can open
PDFs, you can let other apps send PDF files to it.

Steps to Handle an Implicit Intent

1. Declare an Intent Filter in the Manifest

Add an <intent-filter> to your activity in the AndroidManifest.xml.

<activity android:name=".YourActivity">
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<data android:mimeType="application/pdf" />
</intent-filter>
</activity>

2. Handle the Intent in Your Activity

In your activity, get the intent and process the data.

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

Intent intent = getIntent();

if (Intent.ACTION_VIEW.equals(intent.getAction())) {
Uri data = intent.getData();
// Handle the PDF file
}
}

6. Summary

 Built-in Intents: Predefined tasks provided by Android (e.g., open a webpage, dial a number).
 Implicit Intents: Tell Android what you want to do (e.g., view, share, or send something).
 Examples:
o Open a webpage: ACTION_VIEW
o Dial a number: ACTION_DIAL
o Send an email: ACTION_SEND
o Share text/images: ACTION_SEND
o Capture a photo: ACTION_IMAGE_CAPTURE
 You can also handle implicit intents in your app by declaring intent filters in the manifest.

Introduction to Content Providers in Android

Let’s simplify the concept of Content Providers for Android apps so you can understand it step by step.

1. What is a Content Provider?

A Content Provider is a component in Android that allows one app to share data with other apps securely.

 Think of it like a middleman:

If App A wants to access App B's data, the Content Provider ensures that the data is shared in a safe and
structured way.
 Common use cases:
o Accessing contacts, photos, or media files from other apps.
o Sharing app-specific data (like notes, tasks, or messages) with other apps.

2. Why Use a Content Provider?

 Data Sharing: It lets you share your app's data with other apps or access data from system apps (like
Contacts).
 Uniform Access: The way you interact with data using a Content Provider is the same, no matter where
the data is stored (database, file system, or over the network).
 Security: It gives controlled access to data using permissions.
3. How Does a Content Provider Work?

A Content Provider works like a gatekeeper. It allows access to data based on the URI (Uniform Resource
Identifier) you provide.

 URI: Think of it like an address for the data. For example:

o content://com.example.contactsprovider/contacts
o This URI points to all the contacts in a hypothetical app.

4. Basic Operations with a Content Provider

A Content Provider supports CRUD operations:

1. Create: Add new data.

2. Read: Retrieve data (e.g., fetch contacts or photos).
3. Update: Modify existing data.
4. Delete: Remove data.

These operations are done using the ContentResolver class.

5. How to Use a Content Provider?

Here’s how you can use a Content Provider in a simple way:

a. Accessing Data from System Content Providers

Android comes with built-in Content Providers for accessing things like contacts, photos, and media files.

Example: Reading Contacts

Cursor cursor = getContentResolver().query(

ContactsContract.Contacts.CONTENT_URI, // URI for contacts
null, // Columns to retrieve (null = all)
null, // Selection criteria (null = all contacts)
null, // Selection arguments
null // Sorting order
);

if (cursor != null && cursor.moveToFirst()) {

do {
String contactName =
cursor.getString(cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME));
Log.d("Contact Name", contactName);
} while (cursor.moveToNext());
cursor.close();
}

b. Creating a Custom Content Provider

If you want to share your app’s data with others, you can create your own Content Provider.
Step 1: Create a class that extends ContentProvider.

public class MyContentProvider extends ContentProvider {

@Override
public boolean onCreate() {
// Initialize the database or data source here
return true; // Return true if initialization is successful
}

@Override
public Cursor query(Uri uri, String[] projection, String selection, String[]
selectionArgs, String sortOrder) {
// Handle "read" operations here
return null;
}

@Override
public Uri insert(Uri uri, ContentValues values) {
// Handle "create" operations here
return null;
}

@Override
public int update(Uri uri, ContentValues values, String selection, String[]
selectionArgs) {
// Handle "update" operations here
return 0;
}

@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
// Handle "delete" operations here
return 0;
}

@Override
public String getType(Uri uri) {
// Return the MIME type for the data
return null;
}
}

Step 2: Add the Content Provider to your AndroidManifest.xml.

<provider
android:name=".MyContentProvider"
android:authorities="com.example.mycontentprovider"
android:exported="true" />

6. Built-in Content Providers in Android

Here are some of the most common built-in Content Providers:

Content Provider Purpose URI Example

Contacts Provider Access device contacts content://contacts/people
Media Store Access images, videos, and audio files content://media/external/images/media
Calendar Provider Access calendar events content://com.android.calendar/events
 Content Provider Purpose URI Example
User Dictionary Access user-defined words and content://user_dictionary/words
Provider shortcuts

7. Advantages of Content Providers

1. Structured Data Access: It provides a uniform interface to access and manipulate data.
2. Data Security: You can control who gets access to your app's data.
3. Reusability: Other apps can use your Content Provider to get data without duplicating logic.

Sure! Let's dive into Accessing Data Using Content Providers in a simple and beginner-friendly way.

What is a Content Provider?

A Content Provider is a component in Android that allows an app to share data with other apps. It manages
access to structured data (like databases, files, or other storage systems) and provides a standard way to query,
insert, update, or delete data.
For example:
 The Contacts app shares contact data with other apps using a content provider.
 The Gallery app shares images with other apps using a content provider.

When Do You Use a Content Provider?

You use a content provider when:
1. You want to share your app’s data with other apps.
2. Your app needs to access data from another app (like contacts or media).
3. You want to organize data in a secure and standardized way.

How Does a Content Provider Work?

Content Providers use a URI (Uniform Resource Identifier) to identify the data they provide.
For example:
 Contacts: content://com.android.contacts/contacts
 Images: content://media/external/images/media
A URI is like a web address but for app data.

Basic Operations of a Content Provider

There are four main operations you can perform with a content provider:
1. Query Data (Read data)
2. Insert Data (Add new data)
3. Update Data (Modify existing data)
4. Delete Data (Remove data)
These operations are performed using a ContentResolver, which acts as a bridge between your app and the
content provider.

Step-by-Step Explanation
1. Querying Data
To access data, you call the query() method.
Example: Fetch contacts from the Contacts app.
Cursor cursor = getContentResolver().query(
ContactsContract.Contacts.CONTENT_URI, // URI to access contacts
null, // Columns to fetch (null means all columns)
 null, // Selection criteria (e.g., WHERE clause)
null, // Selection arguments
null // Sort order
);

if (cursor != null) {
while (cursor.moveToNext()) {
String contactName = cursor.getString(
cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME)
);
Log.d("Contact Name", contactName);
}
cursor.close();
}
2. Inserting Data
To add data, use the insert() method.
Example: Add a new contact (simplified example).
ContentValues values = new ContentValues();
values.put(ContactsContract.RawContacts.ACCOUNT_TYPE, "com.google");
values.put(ContactsContract.RawContacts.ACCOUNT_NAME, "[email protected]");

Uri newContactUri = getContentResolver().insert(

ContactsContract.RawContacts.CONTENT_URI, values
);

Log.d("New Contact URI", newContactUri.toString());

3. Updating Data
To modify data, use the update() method.
Example: Update a contact’s name.
ContentValues values = new ContentValues();
values.put(ContactsContract.Contacts.DISPLAY_NAME, "New Name");

String selection = ContactsContract.Contacts._ID + "=?";

String[] selectionArgs = {"1"}; // ID of the contact to update

int rowsUpdated = getContentResolver().update(

ContactsContract.Contacts.CONTENT_URI, values, selection, selectionArgs
);

Log.d("Rows Updated", String.valueOf(rowsUpdated));

4. Deleting Data
To remove data, use the delete() method.
Example: Delete a contact.
String selection = ContactsContract.Contacts._ID + "=?";
String[] selectionArgs = {"1"}; // ID of the contact to delete

int rowsDeleted = getContentResolver().delete(

ContactsContract.Contacts.CONTENT_URI, selection, selectionArgs
);

Log.d("Rows Deleted", String.valueOf(rowsDeleted));

How to Access Data from a Custom Content Provider?
If another app has a custom content provider, you can access it using the app's content URI.
For example, if the content URI is content://com.example.myapp.provider/items, you can query it like this:
Cursor cursor = getContentResolver().query(
Uri.parse("content://com.example.myapp.provider/items"),
null,
null,
null,
null
);

if (cursor != null) {
while (cursor.moveToNext()) {
String itemName = cursor.getString(cursor.getColumnIndex("name"));
Log.d("Item Name", itemName);
}
cursor.close();
}

Permissions Needed
Some content providers require specific permissions. For example:
 To access contacts, you need:
 <uses-permission android:name="android.permission.READ_CONTACTS" />
 To write contacts, you need:
 <uses-permission android:name="android.permission.WRITE_CONTACTS" />
Always request these permissions in your AndroidManifest.xml and handle runtime permissions for Android
6.0+.

Security Tips
1. Use permissions in your custom content provider to control access.
2. Avoid exposing sensitive data without proper checks.
3. Use exported="false" in your content provider if you don't want to share it with other apps.

Summary
 A Content Provider is a component that allows apps to share or access data in a structured way.
 Operations you can perform: Query, Insert, Update, and Delete.
 Use a ContentResolver to interact with the content provider.
 Always handle permissions and security properly.

Let’s dive into SQLite Basics for Android development! I’ll explain it step by step in a simple way.

1. What is SQLite?
SQLite is a lightweight, built-in database for Android.
 It doesn’t require a server, so it works directly inside your app.
 You can use it to store structured data, like user details, app settings, or any information your app needs.

2. Key Concepts of SQLite

 Database: A file that stores data in tables.
 Tables: Structured data storage, like a spreadsheet (rows and columns).
 Rows: Each record in the table (e.g., a single user’s data).
 Columns: Fields for each row (e.g., name, age, email).
3. Steps to Create and Manage a Database
a. Create a Database
To manage a database, use the SQLiteOpenHelper class in Android.
Here’s how it works:
1. Create a Class
Extend SQLiteOpenHelper and override its methods:
o onCreate(): Creates tables in the database.
o onUpgrade(): Updates the database structure if needed.
2. Define the Database Details
o Database name
o Version number
o Table structure

b. Example Code
Let’s create a database to store user information (name and age).
Step 1: Create the SQLite Helper Class
public class MyDatabaseHelper extends SQLiteOpenHelper {

// Database Name and Version

private static final String DATABASE_NAME = "UserDatabase.db";
private static final int DATABASE_VERSION = 1;

// Table Name and Columns

private static final String TABLE_NAME = "users";
private static final String COLUMN_ID = "id";
private static final String COLUMN_NAME = "name";
private static final String COLUMN_AGE = "age";

// Constructor
public MyDatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}

// onCreate: Creates the table when the database is first created

@Override
public void onCreate(SQLiteDatabase db) {
String createTable = "CREATE TABLE " + TABLE_NAME + " ("
+ COLUMN_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, "
+ COLUMN_NAME + " TEXT, "
+ COLUMN_AGE + " INTEGER)";
db.execSQL(createTable); // Execute the SQL statement
}

// onUpgrade: Updates the table if the database version changes

@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAME); // Delete old table
onCreate(db); // Create the new table
}
}

Step 2: Use the Database

Now, let’s learn how to perform basic operations like inserting, reading, updating, and deleting data.
a. Insert Data
public void insertUser(String name, int age) {
SQLiteDatabase db = this.getWritableDatabase();
ContentValues values = new ContentValues();
values.put("name", name);
values.put("age", age);
db.insert("users", null, values);
db.close();
}
b. Read Data
public Cursor getAllUsers() {
SQLiteDatabase db = this.getReadableDatabase();
return db.rawQuery("SELECT * FROM users", null);
}
c. Update Data
public void updateUser(int id, String name, int age) {
SQLiteDatabase db = this.getWritableDatabase();
ContentValues values = new ContentValues();
values.put("name", name);
values.put("age", age);
db.update("users", values, "id = ?", new String[]{String.valueOf(id)});
db.close();
}
d. Delete Data
public void deleteUser(int id) {
SQLiteDatabase db = this.getWritableDatabase();
db.delete("users", "id = ?", new String[]{String.valueOf(id)});
db.close();
}

4. How to Use the Database in an Activity

Here’s how to use the helper class in your app.
Example: Insert and Display Users
MyDatabaseHelper dbHelper = new MyDatabaseHelper(this);

// Insert a user
dbHelper.insertUser("John Doe", 25);

// Read users
Cursor cursor = dbHelper.getAllUsers();
if (cursor.moveToFirst()) {
do {
int id = cursor.getInt(0); // Column 0: id
String name = cursor.getString(1); // Column 1: name
int age = cursor.getInt(2); // Column 2: age

// Display user info

Log.d("UserInfo", "ID: " + id + ", Name: " + name + ", Age: " + age);
} while (cursor.moveToNext());
}
cursor.close();
5. Advantages of SQLite
 No setup or server needed—it’s built into Android.
 Lightweight and fast.
 Simple to use for small to medium-sized data.

Let’s break down Performing CRUD Operations in SQLite for mobile applications step by step, focusing on
Create and Read operations.

1. What is SQLite?
 SQLite is a lightweight database built into Android.
 It’s used to store and retrieve structured data like a mini database system.
 CRUD stands for Create, Read, Update, and Delete operations.

2. Setting Up SQLite in Android

a. Create a Database Helper Class
 Use the SQLiteOpenHelper class to manage the database.
Example:
public class DatabaseHelper extends SQLiteOpenHelper {

// Database Name and Version

private static final String DATABASE_NAME = "my_database.db";
private static final int DATABASE_VERSION = 1;

// Table Name
public static final String TABLE_NAME = "users";

// Table Columns
public static final String COLUMN_ID = "id";
public static final String COLUMN_NAME = "name";
public static final String COLUMN_AGE = "age";

// Constructor
public DatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}

// Called when the database is created

@Override
public void onCreate(SQLiteDatabase db) {
// Create Table SQL
String CREATE_TABLE = "CREATE TABLE " + TABLE_NAME + " (" +
COLUMN_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " +
COLUMN_NAME + " TEXT, " +
COLUMN_AGE + " INTEGER)";
db.execSQL(CREATE_TABLE); // Execute SQL command
}

// Called when the database is updated

@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAME);
 onCreate(db); // Recreate table
}
}

3. Performing CRUD Operations

a. Create (Insert Data into the Database)
To insert data into the SQLite database, use the SQLiteDatabase's insert() method.
Example:
public void insertUser(String name, int age) {
SQLiteDatabase db = this.getWritableDatabase(); // Open database for writing
ContentValues values = new ContentValues();

// Add data
values.put(COLUMN_NAME, name);
values.put(COLUMN_AGE, age);

// Insert into table

db.insert(TABLE_NAME, null, values);
db.close(); // Close database connection
}
Usage:
DatabaseHelper dbHelper = new DatabaseHelper(context);
dbHelper.insertUser("John Doe", 25); // Insert a user named John Doe, aged 25

b. Read (Retrieve Data from the Database)

To fetch data, use the query() or rawQuery() method of SQLiteDatabase.
Example:
public List<String> getAllUsers() {
List<String> userList = new ArrayList<>();
SQLiteDatabase db = this.getReadableDatabase(); // Open database for reading

// SQL query to select all rows from the table

String SELECT_QUERY = "SELECT * FROM " + TABLE_NAME;

Cursor cursor = db.rawQuery(SELECT_QUERY, null);

// Loop through the results

if (cursor.moveToFirst()) {
do {
String name = cursor.getString(cursor.getColumnIndex(COLUMN_NAME));
userList.add(name); // Add user name to the list
} while (cursor.moveToNext());
}

cursor.close(); // Close the cursor

db.close(); // Close the database
return userList;
}
Usage:
DatabaseHelper dbHelper = new DatabaseHelper(context);
List<String> users = dbHelper.getAllUsers(); // Get all user names
for (String user : users) {
 Log.d("User", user); // Print each user name
}

4. Example: Simple User App

Here’s how the app would work:
1. Insert User:
o Use a form with a name and age field.
o On clicking "Save," call insertUser() to add the data.
2. Display Users:
o Fetch data using getAllUsers() and display it in a list or recycler view.

Sure! Let’s go step by step to understand how to perform CRUD operations (Update and Delete) in SQLite
for an Android application. I'll keep it simple and beginner-friendly!

1. What is SQLite?
 SQLite is a lightweight database used in Android to store data locally on the device.
 It allows you to perform basic CRUD operations:
o Create: Insert new data.
o Read: Retrieve data.
o Update: Modify existing data.
o Delete: Remove data.

2. Setting Up SQLite in Android

To work with SQLite, you usually need to create a DatabaseHelper class that extends SQLiteOpenHelper. This
class manages the database creation, version management, and CRUD operations.
Here’s an example of setting up the database:
public class DatabaseHelper extends SQLiteOpenHelper {
// Database name and version
private static final String DATABASE_NAME = "Student.db";
private static final int DATABASE_VERSION = 1;

// Table name and columns

public static final String TABLE_NAME = "students";
public static final String COLUMN_ID = "id";
public static final String COLUMN_NAME = "name";
public static final String COLUMN_AGE = "age";

// Constructor
public DatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}

// Create table
@Override
public void onCreate(SQLiteDatabase db) {
String CREATE_TABLE = "CREATE TABLE " + TABLE_NAME + "("
+ COLUMN_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, "
+ COLUMN_NAME + " TEXT, "
+ COLUMN_AGE + " INTEGER)";
db.execSQL(CREATE_TABLE);
}
 // Upgrade database
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAME);
onCreate(db);
}
}

3. Updating Data (U in CRUD)

To update data in SQLite, we use the update() method of the SQLiteDatabase class.
Example: Updating a Student's Name by ID
public boolean updateStudent(int id, String name, int age) {
SQLiteDatabase db = this.getWritableDatabase();

ContentValues values = new ContentValues();

values.put(COLUMN_NAME, name); // Update name
values.put(COLUMN_AGE, age); // Update age

int result = db.update(TABLE_NAME, values, COLUMN_ID + " = ?", new String[]{String.valueOf(id)});

db.close();

return result > 0; // Returns true if update was successful

}
How it Works:
1. ContentValues: Used to store the new values for the columns you want to update.
2. Condition (WHERE): COLUMN_ID + " = ?" specifies which row to update.
3. new String[]{String.valueOf(id)}: Passes the ID dynamically.

4. Deleting Data (D in CRUD)

To delete data, we use the delete() method of the SQLiteDatabase class.
Example: Deleting a Student by ID
public boolean deleteStudent(int id) {
SQLiteDatabase db = this.getWritableDatabase();

int result = db.delete(TABLE_NAME, COLUMN_ID + " = ?", new String[]{String.valueOf(id)});

db.close();

return result > 0; // Returns true if delete was successful

}
How it Works:
1. Condition (WHERE): COLUMN_ID + " = ?" specifies which row to delete.
2. new String[]{String.valueOf(id)}: Passes the ID dynamically.

5. Full Example in an Activity

Let’s say you want to update and delete data from a button click.
Activity Example:
public class MainActivity extends AppCompatActivity {
DatabaseHelper dbHelper;

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

dbHelper = new DatabaseHelper(this);

// Example: Update a student

findViewById(R.id.updateButton).setOnClickListener(v -> {
boolean isUpdated = dbHelper.updateStudent(1, "John Doe", 22);
if (isUpdated) {
Toast.makeText(this, "Student updated!", Toast.LENGTH_SHORT).show();
} else {
Toast.makeText(this, "Update failed!", Toast.LENGTH_SHORT).show();
}
});

// Example: Delete a student

findViewById(R.id.deleteButton).setOnClickListener(v -> {
boolean isDeleted = dbHelper.deleteStudent(1);
if (isDeleted) {
Toast.makeText(this, "Student deleted!", Toast.LENGTH_SHORT).show();
} else {
Toast.makeText(this, "Delete failed!", Toast.LENGTH_SHORT).show();
}
});
}
}

6. Testing the Operations

1. Add a Button for Each Action:
Add buttons in your activity_main.xml file:
2. <Button
3. android:id="@+id/updateButton"
4. android:layout_width="wrap_content"
5. android:layout_height="wrap_content"
6. android:text="Update Student" />
7.
8. <Button
9. android:id="@+id/deleteButton"
10. android:layout_width="wrap_content"
11. android:layout_height="wrap_content"
12. android:text="Delete Student" />
13. Run the App:
o Click the Update button to modify an existing student.
o Click the Delete button to remove a student.
Sure! Here's a simple explanation of how to link an SQLite Database with the Android UI step by step.

1. What is SQLite?
 SQLite is a lightweight database built into Android.
 It's used to store data locally on the device (e.g., storing user details, notes, or app settings).
 Data is stored in tables (just like in MySQL or any other database).

2. Steps to Link SQLite Database with Android UI

We'll go step by step:
Step 1: Set Up the Database
You need to create and manage your SQLite database. Android provides the SQLiteOpenHelper class to make
this easier.
Create a Database Helper Class
This class will help create, read, update, and delete data from the database.
Example:
public class DatabaseHelper extends SQLiteOpenHelper {

// Database name and version

private static final String DATABASE_NAME = "MyDatabase.db";
private static final int DATABASE_VERSION = 1;

// Table and columns

public static final String TABLE_NAME = "Users";
public static final String COLUMN_ID = "id";
public static final String COLUMN_NAME = "name";
public static final String COLUMN_AGE = "age";

// Constructor
public DatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}

// Called when the database is first created

@Override
public void onCreate(SQLiteDatabase db) {
String CREATE_TABLE = "CREATE TABLE " + TABLE_NAME + " ("
+ COLUMN_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, "
+ COLUMN_NAME + " TEXT, "
+ COLUMN_AGE + " INTEGER)";
db.execSQL(CREATE_TABLE);
}

// Called when the database version is upgraded

@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAME);
onCreate(db);
}
}

Step 2: Insert Data into the Database

Add methods in your DatabaseHelper class to insert data.
Example:
public void insertUser(String name, int age) {
SQLiteDatabase db = this.getWritableDatabase();
ContentValues values = new ContentValues();
values.put(COLUMN_NAME, name);
values.put(COLUMN_AGE, age);

db.insert(TABLE_NAME, null, values);

 db.close();
}

Step 3: Retrieve Data from the Database

Add methods to fetch data from the database.
Example:
public Cursor getAllUsers() {
SQLiteDatabase db = this.getReadableDatabase();
return db.rawQuery("SELECT * FROM " + TABLE_NAME, null);
}

Step 4: Design the UI

Design your app's user interface using XML. For example:
activity_main.xml:
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:padding="16dp">

<EditText
android:id="@+id/editTextName"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="Enter Name" />

<EditText
android:id="@+id/editTextAge"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="Enter Age"
android:inputType="number" />

<Button
android:id="@+id/buttonSave"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Save" />

<Button
android:id="@+id/buttonShow"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Show Data" />

<ListView
android:id="@+id/listViewUsers"
android:layout_width="match_parent"
android:layout_height="wrap_content" />

</LinearLayout>
Step 5: Link UI with Database in MainActivity
Write code to connect the SQLite database with the UI.
Example:
public class MainActivity extends AppCompatActivity {

DatabaseHelper dbHelper;
EditText editTextName, editTextAge;
Button buttonSave, buttonShow;
ListView listViewUsers;

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

// Initialize database helper

dbHelper = new DatabaseHelper(this);

// Link UI components
editTextName = findViewById(R.id.editTextName);
editTextAge = findViewById(R.id.editTextAge);
buttonSave = findViewById(R.id.buttonSave);
buttonShow = findViewById(R.id.buttonShow);
listViewUsers = findViewById(R.id.listViewUsers);

// Save button listener

buttonSave.setOnClickListener(view -> {
String name = editTextName.getText().toString();
int age = Integer.parseInt(editTextAge.getText().toString());

// Insert data into the database

dbHelper.insertUser(name, age);
Toast.makeText(MainActivity.this, "Data Saved", Toast.LENGTH_SHORT).show();

// Clear input fields

editTextName.setText("");
editTextAge.setText("");
});

// Show button listener

buttonShow.setOnClickListener(view -> {
Cursor cursor = dbHelper.getAllUsers();
ArrayList<String> userList = new ArrayList<>();

if (cursor.moveToFirst()) {
do {
String user = "ID: " + cursor.getInt(0) +
", Name: " + cursor.getString(1) +
", Age: " + cursor.getInt(2);
userList.add(user);
} while (cursor.moveToNext());
 }

// Display data in the ListView

ArrayAdapter<String> adapter = new ArrayAdapter<>(
MainActivity.this, android.R.layout.simple_list_item_1, userList);
listViewUsers.setAdapter(adapter);
});
}
}

6. Final Output
 Save Button: Adds data to the SQLite database.
 Show Button: Retrieves data and displays it in the ListView.

Firebase Setup and Introduction for Mobile Applications

Firebase is a platform developed by Google that provides a suite of cloud services for app development.
It offers a wide range of tools and services that make it easier to build high-quality apps, including real-
time databases, authentication, analytics, push notifications, and more.

Let’s go through the steps to set up Firebase and integrate it into your mobile app.

1. Create a Firebase Project

Before you can use Firebase in your mobile app, you need to create a Firebase project:

Step-by-Step:

1. Go to the Firebase Console.

2. Click on the Add Project button.
3. Follow the on-screen instructions to create your project. It may ask you for:
o Project name: Choose a unique name.
o Google Analytics: You can choose to enable it or skip.
4. Once your project is created, you will be directed to the Firebase dashboard.

2. Add Firebase to Your Mobile Application

Firebase works with Android, iOS, and even web apps. Here, I’ll focus on Android as an example, but
the process for iOS is quite similar.

For Android:

1. Register Your App with Firebase:

o In the Firebase Console, click on the Android icon to add an Android app.
o You will need to provide your app’s package name (this is a unique identifier for your app,
usually found in your app's AndroidManifest.xml file).
2. Download the google-services.json File:
 o Firebase will generate a configuration file called google-services.json specific to your app.
o Download this file and place it in your Android project’s app/ directory.
3. Add Firebase SDK to Your Android App:
o Open your Android project in Android Studio.
o Open the build.gradle files (both project-level and app-level).
o In the project-level build.gradle file, add the classpath to the Firebase services plugin:
4. buildscript {
5. repositories {
6. google()
7. mavenCentral()
8. }
9. dependencies {
10. classpath 'com.google.gms:google-services:4.3.10' // Firebase plugin
11. }
12. }
o In the app-level build.gradle file, apply the plugin at the bottom:
13. apply plugin: 'com.google.gms.google-services'
o Then, add Firebase dependencies in the dependencies section. For example, to use Firebase
Authentication:
14. dependencies {
15. implementation 'com.google.firebase:firebase-auth:21.0.1'
16. }
17. Sync Your Project:
o Once you’ve added the necessary dependencies, click Sync Now in Android Studio to download
the required libraries.

3. Using Firebase Services

Now that Firebase is set up, you can start using its services. Here are a few key services you might use:

Firebase Authentication (Login & Sign-up)

Firebase Authentication allows you to easily add user sign-up and sign-in features to your app.

 To use Firebase Authentication, make sure the firebase-auth dependency is added (as shown above).
 In your app code, initialize FirebaseAuth and set up user sign-in methods like email/password, Google,
Facebook, etc.

Example of Email/Password authentication:

FirebaseAuth mAuth = FirebaseAuth.getInstance();

public void signUp(String email, String password) {

mAuth.createUserWithEmailAndPassword(email, password)

.addOnCompleteListener(this, task -> {

 if (task.isSuccessful()) {

// Sign-up success

FirebaseUser user = mAuth.getCurrentUser();

} else {

// If sign-up fails, display a message to the user.

});

Firebase Realtime Database

Firebase provides a Realtime Database to store and sync data across all users in real-time. The data is
stored in a NoSQL format.

 You can set up a database in Firebase Console under the Database section.
 Add the necessary Firebase Realtime Database dependency.

Example to store and read data:

DatabaseReference mDatabase = FirebaseDatabase.getInstance().getReference();

public void writeData(String userId, String name) {

mDatabase.child("users").child(userId).setValue(name);

public void readData(String userId) {

mDatabase.child("users").child(userId).get().addOnCompleteListener(task -> {

if (task.isSuccessful()) {

String name = task.getResult().getValue(String.class);

});

}
 Firebase Cloud Messaging (Push Notifications)

Firebase Cloud Messaging (FCM) is a service that allows you to send notifications to users.

 Add firebase-messaging to your dependencies.

Example to receive a message:

FirebaseMessaging.getInstance().getToken().addOnCompleteListener(task -> {

if (task.isSuccessful()) {

String token = task.getResult();

});

4. Testing and Debugging Firebase Integration

After setting up Firebase, you can test it by running your app in the emulator or on a physical device.
Firebase provides real-time debugging tools, such as Firebase Crashlytics, which lets you track and
resolve crashes easily.

 Go to the Firebase Console, navigate to the Analytics section to view events.

 Use the Logcat in Android Studio to monitor logs.

5. Firebase Pricing

Firebase offers a free tier for most services, which is ideal for testing and small projects. However, as
your app grows, you may need to upgrade to a paid plan depending on your usage, such as more
database storage or higher request limits.

Firebase Authentication (Login & Registration) in Mobile Apps

Firebase Authentication is a service that can help you easily implement login and registration systems in
your mobile applications. It supports email/password authentication, as well as authentication via social
providers like Google, Facebook, Twitter, etc.

Here's a simple breakdown of how Firebase Authentication works for login and registration:

Step-by-Step Explanation:

1. Set up Firebase:
o Create a Firebase project: First, you need to create a project in the Firebase Console.
 o Integrate Firebase SDK into your app: Add Firebase to your Android app (or iOS) using the
Firebase SDK. You can follow the steps in the Firebase Console to set this up (this typically
involves adding your app’s package name and downloading the google-services.json file).
2. Enable Firebase Authentication:
o In the Firebase Console, go to the Authentication section and enable the authentication methods
you want to use (for example, Email/Password).
o You can also enable third-party providers like Google or Facebook if you want users to log in
using those services.
3. Creating the Registration Screen:
o To register a new user, you’ll collect the user’s email and password.
o Firebase provides an easy-to-use method createUserWithEmailAndPassword to register a user.

Example:

FirebaseAuth mAuth = FirebaseAuth.getInstance();

// Get email and password from input fields

String email = "[email protected]";

String password = "userPassword";

mAuth.createUserWithEmailAndPassword(email, password)

.addOnCompleteListener(this, task -> {

if (task.isSuccessful()) {

// Registration success

FirebaseUser user = mAuth.getCurrentUser();

// Proceed to the next screen

} else {

// Registration failed

Toast.makeText(this, "Authentication failed.", Toast.LENGTH_SHORT).show();

});

4. Creating the Login Screen:

o For logging in, you can use the signInWithEmailAndPassword method provided by Firebase.
 Example:

FirebaseAuth mAuth = FirebaseAuth.getInstance();

// Get email and password from input fields

String email = "[email protected]";

String password = "userPassword";

mAuth.signInWithEmailAndPassword(email, password)

.addOnCompleteListener(this, task -> {

if (task.isSuccessful()) {

// Login success

FirebaseUser user = mAuth.getCurrentUser();

// Proceed to the main screen

} else {

// Login failed

Toast.makeText(this, "Authentication failed.", Toast.LENGTH_SHORT).show();

});

5. Handling Errors:
o Firebase provides various error messages when authentication fails. You can handle them by
checking the error code and displaying appropriate messages.
o Example of common error codes:
 ERROR_INVALID_CREDENTIAL: Invalid email or password.
 ERROR_USER_NOT_FOUND: No user with this email exists.
 ERROR_WRONG_PASSWORD: The password entered is incorrect.
6. Checking If a User is Logged In:
o After a successful login, you can check if the user is still logged in by checking
FirebaseAuth.getInstance().getCurrentUser().

Example:

FirebaseUser user = FirebaseAuth.getInstance().getCurrentUser();

 if (user != null) {

// User is logged in

} else {

// User is not logged in

7. Logging Out:
o Firebase also makes it easy to log out the user with a single method signOut().

Example:

FirebaseAuth.getInstance().signOut();

Key Points to Remember:

 Firebase Authentication handles all the backend authentication tasks for you, so you don’t need to
manage user passwords or authentication details.
 It supports multiple authentication methods, including email/password, phone number, and third-party
providers (Google, Facebook, etc.).
 Firebase Authentication provides easy-to-use APIs to manage user registration, login, and logout in
mobile apps.
 After login, you can access user information such as their email, UID, etc., using FirebaseUser.

Firebase Authentication Flow:

1. User Registration:
o The user enters their email and password.
o Firebase creates a new account for them using createUserWithEmailAndPassword.
2. User Login:
o The user enters their credentials (email and password).
o Firebase verifies them and, if correct, logs the user in.
3. Session Management:
o Firebase keeps track of the user's session. Once logged in, the app can maintain the session
unless the user logs out.

Working with Firebase Realtime Database for data insertion in mobile applications involves several key steps.
Firebase Realtime Database is a NoSQL cloud database that stores and syncs data in real-time across all clients.
In this explanation, we'll focus on inserting data into Firebase Realtime Database from a mobile application.

Here’s a simple, step-by-step guide:

Step 1: Set Up Firebase in Your Mobile Application

1. Create a Firebase Project:

o Go to the Firebase Console.
o Click on Create a Project, give it a name, and follow the setup process.
2. Add Firebase to Your Mobile App:
 o For Android, you need to download the google-services.json file from Firebase and place it
in the app/ directory of your project.
o For iOS, you will need to download the GoogleService-Info.plist and integrate it into your
Xcode project.
3. Add Firebase SDK Dependencies:
o For Android: Open your build.gradle (Project-level) and add the following classpath in the
dependencies block:
o classpath 'com.google.gms:google-services:4.3.15'

Then, in your app-level build.gradle file, apply the plugin and add the Firebase Realtime
Database dependency:

apply plugin: 'com.google.gms.google-services'

dependencies {
implementation 'com.google.firebase:firebase-database:20.0.5'
}

o Sync your project.

Step 2: Initialize Firebase in Your App

In your application, initialize Firebase in the onCreate() method of your MainActivity (or equivalent entry
point):

import com.google.firebase.database.FirebaseDatabase;

public class MainActivity extends AppCompatActivity {

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

// Initialize Firebase
FirebaseDatabase database = FirebaseDatabase.getInstance();
}
}

Step 3: Create a Model Class (Optional but Recommended)

You can create a model class to define the structure of the data you want to insert. For example, if you're
inserting user data:

public class User {

String name;
String email;

// Constructor, getters, and setters

public User(String name, String email) {
this.name = name;
this.email = email;
}

public String getName() {

return name;
}
 public String getEmail() {
return email;
}
}

Step 4: Insert Data into Firebase Realtime Database

To insert data into Firebase Realtime Database, use the DatabaseReference class.

Here’s how you insert data into a specific location in your Firebase Realtime Database.

1. Get Database Reference: To get a reference to your Firebase Realtime Database:

2. FirebaseDatabase database = FirebaseDatabase.getInstance();
3. DatabaseReference myRef = database.getReference("users");
4. Insert Data: To insert a single piece of data:
5. myRef.setValue("Hello, World!");

To insert an object (like the User object we created earlier):

User newUser = new User("John Doe", "[email protected]");

myRef.push().setValue(newUser);

o push() generates a unique key for each child under the users node.
o setValue() sets the data at that location.

Step 5: Test Data Insertion

Once you've added the code to insert data, run your application. You should see the data appear in your Firebase
Realtime Database console under the path you specified (e.g., users).

 In the Firebase Console, navigate to the Realtime Database section.

 You should see the data (such as users) inserted under the corresponding node.

Step 6: Handling Errors and Success

It's good practice to add success and failure listeners when inserting data. Here's how you can do it:

myRef.push().setValue(newUser)
.addOnSuccessListener(new OnSuccessListener<Void>() {
@Override
public void onSuccess(Void aVoid) {
// Data was successfully inserted
Log.d("Firebase", "Data insertion successful!");
}
})
.addOnFailureListener(new OnFailureListener() {
@Override
public void onFailure(@NonNull Exception e) {
// Handle failure
Log.d("Firebase", "Data insertion failed: " + e.getMessage());
}
});

Fetching and updating data in Firebase involves interacting with Firebase's Realtime Database or Firestore. Let
me break it down into simple steps for you:
1. Setting Up Firebase in Your Android Project

To begin using Firebase, you'll first need to set up Firebase in your Android project. This involves:

 Creating a Firebase project on the Firebase Console.

 Adding your Android app to the Firebase project.
 Downloading the google-services.json file from Firebase and adding it to your Android project's
app directory.
 Adding Firebase dependencies in the build.gradle files.

2. Using Firebase Realtime Database

Firebase offers two main databases: Firebase Realtime Database and Firebase Firestore. We will focus on
Firebase Realtime Database here.

a. Fetching Data

Fetching data from Firebase involves reading data from the database.

Here's an example of how to fetch data from Firebase Realtime Database:

1. Database Structure (Example):

2. {
3. "users": {
4. "user1": {
5. "name": "John",
6. "age": 30
7. },
8. "user2": {
9. "name": "Jane",
10. "age": 25
11. }
12. }
13. }
14. Add Firebase Database Dependencies: Add the following dependencies in your build.gradle file:
15. implementation 'com.google.firebase:firebase-database:20.0.5'
16. Fetching Data in Code: To read data, use the DatabaseReference and ValueEventListener.
17. DatabaseReference database = FirebaseDatabase.getInstance().getReference("users");
18.
19. // Fetching data for 'user1'
20. database.child("user1").addValueEventListener(new ValueEventListener() {
21. @Override
22. public void onDataChange(DataSnapshot dataSnapshot) {
23. // Fetching the user data
24. String name = dataSnapshot.child("name").getValue(String.class);
25. int age = dataSnapshot.child("age").getValue(Integer.class);
26. Log.d("TAG", "Name: " + name + ", Age: " + age);
27. }
28.
29. @Override
30. public void onCancelled(DatabaseError databaseError) {
31. Log.w("TAG", "loadPost:onCancelled", databaseError.toException());
32. }
33. });

b. Updating Data
To update data, you use the updateChildren() method, which allows you to modify specific fields.

1. Updating a User's Information: Here's how to update the age of user1:

2. DatabaseReference database = FirebaseDatabase.getInstance().getReference("users");
3.
4. // Updating the 'age' of 'user1'
5. database.child("user1").child("age").setValue(31);

If you want to update multiple fields, you can use updateChildren():

Map<String, Object> updates = new HashMap<>();

updates.put("users/user1/name", "John Doe");
updates.put("users/user1/age", 32);

FirebaseDatabase.getInstance().getReference().updateChildren(updates);

3. Using Firebase Firestore (Optional)

Firebase Firestore is another powerful database offered by Firebase, which allows for more flexible and scalable
data management.

a. Fetching Data in Firestore

FirebaseFirestore db = FirebaseFirestore.getInstance();

db.collection("users")
.document("user1")
.get()
.addOnSuccessListener(documentSnapshot -> {
String name = documentSnapshot.getString("name");
Long age = documentSnapshot.getLong("age");
Log.d("TAG", "Name: " + name + ", Age: " + age);
})
.addOnFailureListener(e -> Log.d("TAG", "Error getting document", e));

b. Updating Data in Firestore

FirebaseFirestore db = FirebaseFirestore.getInstance();

Map<String, Object> userUpdates = new HashMap<>();

userUpdates.put("age", 31);

db.collection("users")
.document("user1")
.update(userUpdates)
.addOnSuccessListener(aVoid -> Log.d("TAG", "User updated successfully"))
.addOnFailureListener(e -> Log.d("TAG", "Error updating document", e));

4. Best Practices

 Use Real-time Listeners: For fetching data, it is helpful to use ValueEventListener to get updates in
real time.
 Limit Data Loads: When querying large datasets, always use orderByChild() or limitToFirst() to
avoid fetching too much data.
 Use Firebase Security Rules: Protect your data by setting up Firebase security rules to control who can
read or write to the database.
Integrating Firebase with an Android app involves connecting your app to Firebase services such as
Authentication, Firestore Database, Realtime Database, Cloud Storage, and more. Below is a step-by-step
explanation of how you can integrate Firebase with an Android app in a simple method:

Step 1: Create a Firebase Project

1. Go to Firebase Console:
o Open your web browser and navigate to the Firebase Console.
o Sign in with your Google account.
2. Create a New Project:
o Click on "Add Project."
o Follow the setup wizard and give your project a name.
o Agree to the terms and conditions, then create the project.
3. Enable Firebase for Your App:
o After the project is created, click on "Add App" and select Android.
4. Register Your App:
o Enter the package name of your Android app (you can find it in AndroidManifest.xml).
o Optionally, provide the app’s SHA-1 certificate (for authentication features like Google Sign-In).
o Click Register App.
5. Download the google-services.json file:
o Firebase will generate a google-services.json file that you will need to add to your Android
project.
o Download the file and place it inside the app/ directory of your Android project.

Step 2: Set Up Firebase SDK in Your Android Project

1. Add Firebase SDK dependencies:

o Open your project-level build.gradle file and make sure the following is added in the
buildscript section:
2. buildscript {
3. repositories {
4. google()
5. mavenCentral()
6. }
7. dependencies {
8. classpath 'com.google.gms:google-services:4.3.15' // Ensure this is the
latest version
9. }
10. }
o Open your app-level build.gradle file and add the following at the bottom:
11. apply plugin: 'com.google.gms.google-services'
12. Add Firebase dependencies:
o In the same build.gradle file (inside the dependencies section), add the necessary Firebase
libraries. For example, if you want to use Firebase Authentication:
13. implementation 'com.google.firebase:firebase-auth:21.0.6' // Use the latest
version
14. implementation 'com.google.firebase:firebase-database:20.0.5' // If using Firebase
Realtime Database
15. implementation 'com.google.firebase:firebase-firestore:24.0.0' // If using
Firestore
o Sync your project to download and integrate the Firebase SDK.
Step 3: Initialize Firebase in Your App

1. Initialize Firebase in MainActivity.java or MainActivity.kt:

o In your MainActivity, initialize Firebase by calling the FirebaseApp.initializeApp(this)
method (typically done automatically).
o For example:
2. import com.google.firebase.database.FirebaseDatabase;
3.
4. public class MainActivity extends AppCompatActivity {
5. @Override
6. protected void onCreate(Bundle savedInstanceState) {
7. super.onCreate(savedInstanceState);
8. setContentView(R.layout.activity_main);
9.
10. // Initialize Firebase
11. FirebaseDatabase database = FirebaseDatabase.getInstance();
12. }
13. }

This code initializes Firebase in your app, allowing you to interact with Firebase services.

Step 4: Use Firebase Services (Example: Firebase Authentication)

Let’s integrate Firebase Authentication for signing up and signing in users.

1. Create Sign-Up Form:

o Add an email, password input, and a sign-up button to your activity_main.xml:
2. <EditText
3. android:id="@+id/emailInput"
4. android:layout_width="match_parent"
5. android:layout_height="wrap_content"
6. android:hint="Email" />
7.
8. <EditText
9. android:id="@+id/passwordInput"
10. android:layout_width="match_parent"
11. android:layout_height="wrap_content"
12. android:hint="Password"
13. android:inputType="textPassword" />
14.
15. <Button
16. android:id="@+id/signUpButton"
17. android:layout_width="wrap_content"
18. android:layout_height="wrap_content"
19. android:text="Sign Up" />
20. Write Code for Firebase Authentication:
o In MainActivity.java, use Firebase Authentication to sign up a user:
21. import com.google.firebase.auth.FirebaseAuth;
22. import com.google.firebase.auth.AuthResult;
23. import android.widget.EditText;
24. import android.widget.Button;
25.
26. public class MainActivity extends AppCompatActivity {
27. private FirebaseAuth mAuth;
 28. private EditText emailInput, passwordInput;
29. private Button signUpButton;
30.
31. @Override
32. protected void onCreate(Bundle savedInstanceState) {
33. super.onCreate(savedInstanceState);
34. setContentView(R.layout.activity_main);
35.
36. mAuth = FirebaseAuth.getInstance();
37. emailInput = findViewById(R.id.emailInput);
38. passwordInput = findViewById(R.id.passwordInput);
39. signUpButton = findViewById(R.id.signUpButton);
40.
41. signUpButton.setOnClickListener(v -> {
42. String email = emailInput.getText().toString();
43. String password = passwordInput.getText().toString();
44.
45. mAuth.createUserWithEmailAndPassword(email, password)
46. .addOnCompleteListener(this, task -> {
47. if (task.isSuccessful()) {
48. // User signed up successfully
49. Toast.makeText(MainActivity.this, "Sign Up Successful!",
Toast.LENGTH_SHORT).show();
50. } else {
51. // Sign-up failed
52. Toast.makeText(MainActivity.this, "Sign Up Failed!",
Toast.LENGTH_SHORT).show();
53. }
54. });
55. });
56. }
57. }
58. Test the Sign-Up:
o Run the app, enter an email and password, and click "Sign Up." If everything is set up correctly,
the app will create a new user using Firebase Authentication.

Step 5: Firebase Database (Example: Storing User Data)

1. Add Firestore/Realtime Database SDK:

o For Firestore, add this dependency in build.gradle:
2. implementation 'com.google.firebase:firebase-firestore:24.0.0'
3. Store Data:
o After user sign-up, you can store additional information, such as the user’s name or other profile
details, in Firestore:
4. FirebaseFirestore db = FirebaseFirestore.getInstance();
5.
6. Map<String, Object> user = new HashMap<>();
7. user.put("email", email);
8.
9. db.collection("users").document(mAuth.getCurrentUser().getUid())
10. .set(user)
11. .addOnSuccessListener(aVoid -> {
12. // Data saved successfully
13. Toast.makeText(MainActivity.this, "Data Saved!",
Toast.LENGTH_SHORT).show();
14. })
15. .addOnFailureListener(e -> {
16. // Error saving data
 17. Toast.makeText(MainActivity.this, "Error Saving Data!",
Toast.LENGTH_SHORT).show();
18. });

Step 6: Debugging and Testing

 Check Firebase Console: Go to Firebase Console to see if the data is being saved.
 Test Different Scenarios: Test sign-up, sign-in, data retrieval, and any Firebase services you're using.

Final Notes:

 Firebase offers many features beyond Authentication and Databases, like Cloud Storage, Notifications,
Analytics, and more.
 Make sure you have internet access while testing Firebase features.
 Always use the latest Firebase SDK versions for better performance and security.

Data Filtering and Querying in Firebase for Mobile Applications

In Firebase, data is stored in a NoSQL database called Cloud Firestore or Realtime Database, depending on
your choice. When working with Firebase in mobile apps, you may need to filter or query data in order to
retrieve specific information that meets certain criteria (for example, fetching data based on a user's preferences
or displaying results based on a specific condition). This process is called data filtering and querying.

Here’s a simple explanation of how to filter and query data in Firebase:

1. Querying Data in Firebase:

To retrieve data from Firebase, you can use queries. A query allows you to fetch data based on specific
conditions (like values that match or range conditions). The general approach to querying in Firebase is:

 Fetching all data: To get all records from a collection.

 Filtering: You can filter data based on specific conditions such as "where a field equals a value", or
"where a field is greater than or equal to another value."

Example with Firestore:

Assuming you have a collection of users and want to filter based on age:

FirebaseFirestore db = FirebaseFirestore.getInstance();
CollectionReference usersRef = db.collection("users");

// Query to get all users where age is greater than 18

Query query = usersRef.whereGreaterThan("age", 18);

query.get()
.addOnSuccessListener(queryDocumentSnapshots -> {
// Process your data here
for (DocumentSnapshot document : queryDocumentSnapshots) {
Log.d("UserData", document.getString("name"));
}
})
.addOnFailureListener(e -> {
Log.d("Error", "Error fetching data", e);
});
  whereGreaterThan("age", 18): This filters the users where the age field is greater than 18.
 get(): This function fetches the results.

2. Data Filtering with Multiple Conditions:

You can apply multiple filters to query data based on more than one condition. This can be useful when you
need to narrow down results.

Example:

Filter users where age is greater than 18 and their name is "John":

Query query = usersRef.whereGreaterThan("age", 18)

.whereEqualTo("name", "John");

query.get()
.addOnSuccessListener(queryDocumentSnapshots -> {
// Process the data
})
.addOnFailureListener(e -> {
// Handle error
});

 whereEqualTo("name", "John"): This adds another condition to match users with the name "John".

3. Sorting Data:

You can also sort the data returned by your query. For example, if you want to sort users by age in descending
order:

Query query = usersRef.orderBy("age", Query.Direction.DESCENDING);

query.get()
.addOnSuccessListener(queryDocumentSnapshots -> {
// Process sorted data
})
.addOnFailureListener(e -> {
// Handle error
});

 orderBy("age", Query.Direction.DESCENDING): This sorts the data based on the age field in
descending order.

4. Limit the Number of Results:

If you only want a certain number of results (for example, displaying just 10 users at a time), you can limit the
query.

Query query = usersRef.limit(10);

query.get()
.addOnSuccessListener(queryDocumentSnapshots -> {
// Handle the first 10 users here
})
.addOnFailureListener(e -> {
// Handle error
});
  limit(10): This restricts the query to only return 10 users.

5. Pagination (Loading More Data):

Firebase provides a way to handle large data sets efficiently by paginating data. Pagination allows you to load
more data when the user reaches the end of the list.

Example:

To paginate through data, you need to keep track of the last document retrieved and use it to fetch the next set
of results:

Query firstPage = usersRef.orderBy("age").limit(10);

firstPage.get()
.addOnSuccessListener(queryDocumentSnapshots -> {
// Get the last document snapshot
DocumentSnapshot lastVisible = queryDocumentSnapshots.getDocuments()
.get(queryDocumentSnapshots.siz
e() - 1);

// Use lastVisible in the next query for pagination

});

6. Realtime Database Querying:

The Firebase Realtime Database works similarly to Firestore, but with some differences. Here's an example of
filtering data in Realtime Database:

DatabaseReference ref = FirebaseDatabase.getInstance().getReference("users");

// Query to get all users where age is greater than 18

Query query = ref.orderByChild("age").startAt(18);

query.addListenerForSingleValueEvent(new ValueEventListener() {
@Override
public void onDataChange(DataSnapshot dataSnapshot) {
// Handle the data here
for (DataSnapshot snapshot : dataSnapshot.getChildren()) {
String name = snapshot.child("name").getValue(String.class);
Log.d("UserData", name);
}
}

@Override
public void onCancelled(DatabaseError databaseError) {
// Handle possible errors
}
});

 orderByChild("age"): This orders the data by the age field.

 startAt(18): This filters data to show users with an age greater than or equal to 18.

Summary:

 Querying: Retrieve data based on specific conditions.

 Filtering: Use whereEqualTo, whereGreaterThan, whereLessThan to filter data.
  Sorting: Use orderBy to sort data by a specific field.
 Limiting: Use limit to restrict the number of records returned.
 Pagination: Load more data as needed by using document snapshots to track the last retrieved record.

(Short Version)
Introduction to Fragments (Static, Dynamic)
Fragments are reusable components within an activity that enable modular design and
dynamic UI. A fragment is a part of an activity, which has its own lifecycle and can handle its own events.

 Static Fragments:
o Declared in the XML layout of an activity.
o Their lifecycle is tied to the activity's lifecycle.
o Cannot be added or removed dynamically at runtime.
o Example:
o <fragment
o android:id="@+id/staticFragment"
o android:name="com.example.MyFragment"
o android:layout_width="match_parent"
o android:layout_height="match_parent" />
 Dynamic Fragments:
o Added, replaced, or removed at runtime using FragmentManager.
o Provide flexibility for dynamic UI updates.
o Example:

FragmentManager fragmentManager = getSupportFragmentManager();

FragmentTransaction transaction = fragmentManager.beginTransaction();
MyFragment fragment = new MyFragment();
transaction.add(R.id.fragment_container, fragment);
transaction.commit();

Lifecycle of Fragments and Communication

Fragment Lifecycle:

1. onAttach: Called when the fragment is attached to its activity.

2. onCreate: Initialize fragment components (non-UI-related).
3. onCreateView: Inflate the fragment's layout.
4. onActivityCreated: Fragment’s activity is fully created.
5. onStart: Fragment becomes visible.
6. onResume: Fragment is active and interacting with the user.
7. onPause: Fragment is no longer interacting with the user.
8. onStop: Fragment is not visible.
9. onDestroyView: Cleanup views created in onCreateView.
10. onDestroy: Final cleanup.
11. onDetach: Fragment is detached from its activity.
Communication Between Fragments:

 Use a shared ViewModel or implement an interface in the host activity to facilitate

communication between fragments.

Example using an interface:

public interface FragmentCommunication {

void sendData(String data);
}

Creating a Tabbed Activity

A tabbed activity provides navigation between different sections using tabs.
Steps:

1. Create a new Tabbed Activity in Android Studio.

2. Use TabLayout and ViewPager to handle tabs.
3. Define fragments for each tab.

Example:

<com.google.android.material.tabs.TabLayout
android:id="@+id/tabLayout"
android:layout_width="match_parent"
android:layout_height="wrap_content" />

<androidx.viewpager.widget.ViewPager
android:id="@+id/viewPager"
android:layout_width="match_parent"
android:layout_height="match_parent" />

Setting Up Tabs with ViewPager

 Add tabs dynamically using TabLayout.
 Use FragmentPagerAdapter or FragmentStatePagerAdapter to manage
fragment pages.

Example:

ViewPager viewPager = findViewById(R.id.viewPager);

TabLayout tabLayout = findViewById(R.id.tabLayout);
viewPager.setAdapter(new MyPagerAdapter(getSupportFragmentManager()));
tabLayout.setupWithViewPager(viewPager);
Calling Built-in Applications Using Intents
Intents allow you to start activities or services within your app or other apps.
Example:

Intent intent = new Intent(Intent.ACTION_VIEW);

intent.setData(Uri.parse("https://www.google.com"));
startActivity(intent);

Working with Built-in and Implicit Intents

 Built-in Intents:

Predefined intents to perform standard actions like sending emails or opening URLs .

 Implicit Intents:

Specify an action to be performed without defining the component.

Example of Implicit Intent:

Intent intent = new Intent(Intent.ACTION_DIAL);

intent.setData(Uri.parse("tel:1234567890"));
startActivity(intent);

Introduction to Content Providers

Content Providers manage shared app data (e.g., contacts, media).
They use a URI (Uniform Resource Identifier) for interaction.

Example:
Cursor cursor = getContentResolver().query(ContactsContract.Contacts.CONTENT_URI, null, null, null, null);

Accessing Data Using Content Providers

Use ContentResolver to query, insert, update, or delete data.

Example:

ContentValues values = new ContentValues();

values.put(ContactsContract.RawContacts.DISPLAY_NAME, "John Doe");
getContentResolver().insert(ContactsContract.RawContacts.CONTENT_URI, values);
SQLite Basics: Creating and Managing a Database
SQLite is a lightweight database embedded in Android.

Example:

public class MyDatabaseHelper extends SQLiteOpenHelper {

public MyDatabaseHelper(Context context) {
super(context, "MyDatabase", null, 1);
}

@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)");
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("DROP TABLE IF EXISTS users");
onCreate(db);
}
}

Performing CRUD Operations in SQLite

Create and Read:

SQLiteDatabase db = dbHelper.getWritableDatabase();
ContentValues values = new ContentValues();
values.put("name", "John");
db.insert("users", null, values);
Cursor cursor = db.query("users", null, null, null, null, null, null);

Update and Delete:

db.update("users", values, "id=?", new String[]{"1"});
db.delete("users", "id=?", new String[]{"1"});

Linking SQLite Database with Android UI

Use adapters to bind
database data to UI components like ListView or
RecyclerView.

Example:
Cursor cursor = db.query("users", null, null, null, null, null, null);
SimpleCursorAdapter adapter = new SimpleCursorAdapter(context,
R.layout.list_item, cursor, new String[]{"name"}, new int[]{R.id.textView}, 0);
listView.setAdapter(adapter);
Firebase Setup and Introduction
Firebase is a cloud platform providing backend services like authentication, databases, and
analytics.

Steps:

1. Add Firebase to your Android project using the Firebase Console.

2. Integrate Firebase SDK.

Firebase Authentication (Login, Registration)

 Use Firebase Authentication for user management.

Example:
FirebaseAuth auth = FirebaseAuth.getInstance();

// Registration
auth.createUserWithEmailAndPassword(email, password)
.addOnCompleteListener(task -> {
if (task.isSuccessful()) {
// User registered
}
});

// Login
auth.signInWithEmailAndPassword(email, password)
.addOnCompleteListener(task -> {
if (task.isSuccessful()) {
// User logged in
}
});

Working with Firebase Realtime Database (Data Insertion)

DatabaseReference database = FirebaseDatabase.getInstance().getReference("Users");
database.child("user1").setValue(new User("John", 25));

Fetching and Updating Data in Firebase

Fetching:
database.child("user1").addListenerForSingleValueEvent(new ValueEventListener() {
@Override
 public void onDataChange(DataSnapshot snapshot) {
User user = snapshot.getValue(User.class);
}

@Override
public void onCancelled(DatabaseError error) {
}
});

Updating:

database.child("user1").child("name").setValue("Jane");

Integrating Firebase with Android App (Practical)

1. Add Firebase dependencies in build.gradle .

2. Use Firebase services like Authentication and Realtime Database in your app.

Data Filtering and Querying in Firebase

Query query = database.orderByChild("age").equalTo(25);
query.addListenerForSingleValueEvent(new ValueEventListener() {
@Override
public void onDataChange(DataSnapshot snapshot) {
for (DataSnapshot child : snapshot.getChildren()) {
User user = child.getValue(User.class);
}
}
@Override
public void onCancelled(DatabaseError error) {
}
});