1. Introduction

Firebase is a platform provided by Google that helps developers build applications with backend services.

With Firebase, Android developers can add features such as:

• User registration and login.

• Cloud database storage.

• Real-time data synchronization.

• File storage.

• Push notifications.

• Analytics and crash reporting.

In this tutorial, we will understand three important Firebase services:

1. Firebase Authentication

2. Firebase Realtime Database

3. Cloud Firestore

We will also create a practical Firebase Student App using Android Studio and Java.

2. What Is Firebase?

Firebase is a Backend-as-a-Service (BaaS) platform.

It provides ready-made backend services, so developers do not always need to create and manage their own PHP or Node.js server.

For example, instead of creating a complete login system using PHP and MySQL, you can use Firebase Authentication.

Similarly, instead of managing your own database server, you can use Firebase Realtime Database or Cloud Firestore.

Important Firebase Services

Firebase Authentication: Manages user registration, login and authentication.

Realtime Database: Stores data in a JSON-like structure and synchronizes changes in real time.

Cloud Firestore: Stores data in collections and documents with flexible queries.

Firebase Storage: Stores files such as images, videos and documents.

Firebase Cloud Messaging: Sends notifications to Android devices.

3. Firebase Authentication

Firebase Authentication allows users to create accounts and log in securely.

It supports different authentication methods, including:

• Email and Password

• Phone Number

• Google Sign-In

• Apple Sign-In

• Other supported identity providers

In this tutorial, we will use Email and Password authentication.

How Authentication Works

1. The user enters an email and password.

2. The Android application sends the credentials to Firebase.

3. Firebase validates the request.

4. Firebase creates an account or signs in the existing user.

5. Firebase returns the authentication result.

You do not need to create your own password database for this authentication flow.

4. Firebase Realtime Database

Firebase Realtime Database is a cloud-hosted NoSQL database.

It stores data in a JSON-like tree structure.

Example:

{
    "students": {
        "student1": {
            "name": "Rahul Kumar",
            "email": "rahul@example.com"
        },
        "student2": {
            "name": "Amit Sharma",
            "email": "amit@example.com"
        }
    }
}

Important Features

• Stores data in a JSON-like structure.

• Synchronizes data across connected clients.

• Supports real-time listeners.

• Supports offline capabilities through its SDK.

• Uses database security rules to control access.

For example, when a value changes in the database, connected applications can receive the updated value through a listener.

5. Cloud Firestore

Cloud Firestore is another cloud-hosted NoSQL database provided by Firebase.

Unlike Realtime Database, Firestore organizes data into collections and documents.

Example structure:

students
    |
    |--- student1
    |       |
    |       |--- name: Rahul Kumar
    |       |--- email: rahul@example.com
    |
    |--- student2
            |
            |--- name: Amit Sharma
            |--- email: amit@example.com

Important Firestore Features

• Stores information in collections and documents.

• Supports flexible queries.

• Supports real-time listeners.

• Provides offline data support on Android.

• Supports database security rules.

Realtime Database vs Cloud Firestore

Realtime Database:

• Uses a JSON-like tree structure.

• Suitable for simple real-time synchronization.

• Organizes data using references and child nodes.

Cloud Firestore:

• Uses collections and documents.

• Supports flexible queries and structured data.

• Provides features useful for larger and more complex applications.

Both databases are useful. The right choice depends on your application's data structure and requirements.

6. Create a Firebase Project

Now we will connect Firebase with Android Studio.

Follow these steps:

1. Open your browser.

2. Visit:

https://console.firebase.google.com/

1. Sign in with your Google account.

2. Click Create a project.

3. Enter the project name:

ParamFirebaseApp

1. Follow the setup instructions.

2. Click Create Project.

Your Firebase project is now ready.

7. Connect Android Studio with Firebase

Create a new Android Studio project.

Follow these steps:

1. Open Android Studio.

2. Click New Project.

3. Select Empty Views Activity.

4. Enter the project name:

FirebaseStudentApp

1. Select Java as the programming language.

2. Click Finish.

Now connect the Android application to Firebase.

Step 1: Register Your Android App

1. Open your Firebase project.

2. Click Add App.

3. Select the Android icon.

4. Enter your Android package name.

For example:

com.example.firebasestudentapp

Make sure this package name exactly matches your Android application ID.

1. Register the application.

Step 2: Download google-services.json

Firebase will provide a configuration file:

google-services.json

Download this file.

Place it inside your Android project's app folder:

FirebaseStudentApp/
    app/
        google-services.json

Do not place it inside the src or res folder.

Step 3: Add Google Services Plugin

Open the project-level Gradle file.

For Groovy projects, add the Google Services plugin to the existing plugins block:

plugins {
    id 'com.android.application' version 'YOUR_EXISTING_AGP_VERSION' apply false

    id 'com.google.gms.google-services' version '4.5.0' apply false
}

Keep your existing Android Gradle Plugin version. Do not replace it with the example placeholder.

Step 4: Configure the App-Level Gradle File

Open:

app/build.gradle

Add the Google Services plugin:

plugins {
    id 'com.android.application'
    id 'com.google.gms.google-services'
}

Add the Firebase dependencies inside the existing dependencies block:

dependencies {

    implementation platform('com.google.firebase:firebase-bom:35.1.0')

    implementation 'com.google.firebase:firebase-auth'

    implementation 'com.google.firebase:firebase-database'

    implementation 'com.google.firebase:firebase-firestore'

}

The Firebase BoM manages compatible versions of the Firebase libraries.

Now click Sync Now.

Wait until Gradle synchronization completes.

8. Enable Firebase Authentication

Open your Firebase Console.

Follow these steps:

1. Select your Firebase project.

2. Open Authentication.

3. Click Get Started if required.

4. Open the Sign-in method tab.

5. Select Email/Password.

6. Enable Email/Password.

7. Click Save.

Now your Firebase project supports email and password authentication.

9. Design the Registration and Login Screen

Open:

app > res > layout > activity_main.xml

Replace the existing layout with:

<?xml version="1.0" encoding="utf-8"?>

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

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="vertical"
        android:padding="20dp">

        <TextView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Firebase Student App"
            android:textSize="25sp"
            android:textStyle="bold"
            android:gravity="center"
            android:layout_marginBottom="25dp" />

        <EditText
            android:id="@+id/edtEmail"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="Enter Email"
            android:inputType="textEmailAddress" />

        <EditText
            android:id="@+id/edtPassword"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="Enter Password"
            android:inputType="textPassword"
            android:layout_marginTop="12dp" />

        <Button
            android:id="@+id/btnRegister"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Create Account"
            android:layout_marginTop="20dp" />

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

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

        <EditText
            android:id="@+id/edtStudentName"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="Enter Student Name"
            android:layout_marginTop="25dp" />

        <Button
            android:id="@+id/btnSave"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Save Student to Firestore" />

        <TextView
            android:id="@+id/txtResult"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Firebase result will appear here"
            android:textSize="16sp"
            android:layout_marginTop="20dp" />

    </LinearLayout>

</ScrollView>

This screen contains:

• Email input.

• Password input.

• Create Account button.

• Login button.

• Logout button.

• Student Name input.

• Firestore Save button.

• Result TextView.

10. Implement Firebase Authentication in Java

Open:

app > java > your_package_name > MainActivity.java

Replace the existing code with:

package com.example.firebasestudentapp;

import android.os.Bundle;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

import androidx.appcompat.app.AppCompatActivity;

import com.google.firebase.auth.FirebaseAuth;
import com.google.firebase.auth.FirebaseUser;

public class MainActivity extends AppCompatActivity {

    EditText edtEmail, edtPassword, edtStudentName;

    Button btnRegister, btnLogin, btnLogout, btnSave;

    TextView txtResult;

    FirebaseAuth mAuth;

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

        edtEmail = findViewById(R.id.edtEmail);
        edtPassword = findViewById(R.id.edtPassword);
        edtStudentName = findViewById(R.id.edtStudentName);

        btnRegister = findViewById(R.id.btnRegister);
        btnLogin = findViewById(R.id.btnLogin);
        btnLogout = findViewById(R.id.btnLogout);
        btnSave = findViewById(R.id.btnSave);

        txtResult = findViewById(R.id.txtResult);

        mAuth = FirebaseAuth.getInstance();

        btnRegister.setOnClickListener(v -> registerUser());

        btnLogin.setOnClickListener(v -> loginUser());

        btnLogout.setOnClickListener(v -> logoutUser());

        btnSave.setOnClickListener(v -> saveStudent());
    }

    private boolean validateInput() {

        String email = edtEmail.getText().toString().trim();

        String password = edtPassword.getText().toString().trim();

        if (email.isEmpty() || password.isEmpty()) {

            Toast.makeText(
                    this,
                    "Enter email and password",
                    Toast.LENGTH_SHORT
            ).show();

            return false;
        }

        if (password.length() < 6) {

            Toast.makeText(
                    this,
                    "Password must contain at least 6 characters",
                    Toast.LENGTH_SHORT
            ).show();

            return false;
        }

        return true;
    }

    private void registerUser() {

        if (!validateInput()) {
            return;
        }

        String email = edtEmail.getText().toString().trim();

        String password = edtPassword.getText().toString().trim();

        mAuth.createUserWithEmailAndPassword(email, password)
                .addOnCompleteListener(this, task -> {

                    if (task.isSuccessful()) {

                        txtResult.setText(
                                "Account created successfully"
                        );

                        Toast.makeText(
                                this,
                                "Registration successful",
                                Toast.LENGTH_SHORT
                        ).show();

                    } else {

                        txtResult.setText(
                                "Registration failed"
                        );

                        Toast.makeText(
                                this,
                                task.getException().getMessage(),
                                Toast.LENGTH_LONG
                        ).show();
                    }
                });
    }

    private void loginUser() {

        if (!validateInput()) {
            return;
        }

        String email = edtEmail.getText().toString().trim();

        String password = edtPassword.getText().toString().trim();

        mAuth.signInWithEmailAndPassword(email, password)
                .addOnCompleteListener(this, task -> {

                    if (task.isSuccessful()) {

                        txtResult.setText(
                                "Login successful"
                        );

                        Toast.makeText(
                                this,
                                "Welcome!",
                                Toast.LENGTH_SHORT
                        ).show();

                    } else {

                        Toast.makeText(
                                this,
                                "Login failed: " +
                                        task.getException().getMessage(),
                                Toast.LENGTH_LONG
                        ).show();
                    }
                });
    }

    private void logoutUser() {

        mAuth.signOut();

        txtResult.setText("User logged out");

        Toast.makeText(
                this,
                "Logout successful",
                Toast.LENGTH_SHORT
        ).show();
    }

    private void saveStudent() {

        FirebaseUser user = mAuth.getCurrentUser();

        if (user == null) {

            Toast.makeText(
                    this,
                    "Please login first",
                    Toast.LENGTH_SHORT
            ).show();

            return;
        }

        saveStudentToFirestore(user);
    }
}

Understanding Important Authentication Methods

FirebaseAuth.getInstance()

mAuth = FirebaseAuth.getInstance();

Initializes Firebase Authentication.

Create Account

mAuth.createUserWithEmailAndPassword(email, password);

Creates a new Firebase user account.

Login

mAuth.signInWithEmailAndPassword(email, password);

Authenticates an existing user.

Logout

mAuth.signOut();

Signs out the currently authenticated user.

Current User

FirebaseUser user = mAuth.getCurrentUser();

Returns the currently signed-in user, or null if nobody is signed in.

11. Configure Cloud Firestore

Now we will save student information in Cloud Firestore.

Open Firebase Console.

Follow these steps:

1. Select your Firebase project.

2. Open Firestore Database.

3. Click Create Database.

4. Select a database location.

5. Complete the database creation process.

For this tutorial, we will use Cloud Firestore to save student details.

Understand the Firestore Structure

We will create a collection named:

students

Each student will be stored as a document.

Example:

students
    |
    |--- AUTO_DOCUMENT_ID
            |
            |--- name: Rahul Kumar
            |--- email: rahul@example.com
            |--- userId: FIREBASE_USER_UID

The document ID can be generated automatically.

12. Save Student Data in Cloud Firestore

Add the following imports to MainActivity.java:

import com.google.firebase.firestore.FirebaseFirestore;

import java.util.HashMap;
import java.util.Map;

Now add this method inside the MainActivity class:

private void saveStudentToFirestore(FirebaseUser user) {

    String name = edtStudentName.getText().toString().trim();

    if (name.isEmpty()) {

        Toast.makeText(
                this,
                "Enter student name",
                Toast.LENGTH_SHORT
        ).show();

        return;
    }

    FirebaseFirestore db = FirebaseFirestore.getInstance();

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

    student.put("name", name);

    student.put("email", user.getEmail());

    student.put("userId", user.getUid());

    db.collection("students")
            .add(student)
            .addOnSuccessListener(documentReference -> {

                txtResult.setText(
                        "Student saved successfully"
                );

                Toast.makeText(
                        this,
                        "Data saved in Firestore",
                        Toast.LENGTH_SHORT
                ).show();

                edtStudentName.setText("");

            })
            .addOnFailureListener(e -> {

                Toast.makeText(
                        this,
                        "Error: " + e.getMessage(),
                        Toast.LENGTH_LONG
                ).show();
            });
}

Understanding the Firestore Code

Initialize Firestore

FirebaseFirestore db = FirebaseFirestore.getInstance();

Creates an instance of the Firestore database.

Create a Data Map

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

Creates a collection of key-value pairs.

Add Student Information

student.put("name", name);

student.put("email", user.getEmail());

student.put("userId", user.getUid());

Adds student information to the Map.

Save Data

db.collection("students").add(student);

Creates a new document inside the students collection with an automatically generated document ID.

13. Read Student Data from Firestore

Now we will retrieve student information from Firestore.

Add this method inside MainActivity:

private void readStudents() {

    FirebaseUser user = mAuth.getCurrentUser();

    if (user == null) {
        return;
    }

    FirebaseFirestore db = FirebaseFirestore.getInstance();

    db.collection("students")
            .whereEqualTo("userId", user.getUid())
            .get()
            .addOnSuccessListener(queryDocumentSnapshots -> {

                StringBuilder result = new StringBuilder();

                if (queryDocumentSnapshots.isEmpty()) {

                    txtResult.setText("No student records found");

                    return;
                }

                for (com.google.firebase.firestore.QueryDocumentSnapshot document
                        : queryDocumentSnapshots) {

                    String name = document.getString("name");

                    String email = document.getString("email");

                    result.append("Name: ")
                            .append(name)
                            .append("\n");

                    result.append("Email: ")
                            .append(email)
                            .append("\n\n");
                }

                txtResult.setText(result.toString());

            })
            .addOnFailureListener(e -> {

                txtResult.setText(
                        "Error: " + e.getMessage()
                );
            });
}

You can add another button to the layout with the ID btnRead and call readStudents() from its click listener.

Important Firestore Methods

• collection() selects a collection.

• add() creates a document with an automatic ID.

• document() selects a specific document.

• get() retrieves data.

• whereEqualTo() filters records.

• addOnSuccessListener() handles successful operations.

• addOnFailureListener() handles errors.

14. Understand Firebase Realtime Database

Now let's learn how to store and retrieve data using Realtime Database.

Open Firebase Console.

Follow these steps:

1. Select your project.

2. Open Realtime Database.

3. Click Create Database.

4. Select the database location.

5. Complete the setup.

For this example, we will store a student's name and email under their authenticated user ID.

Save Data in Realtime Database

Add these imports:

import com.google.firebase.database.DatabaseReference;
import com.google.firebase.database.FirebaseDatabase;

import java.util.HashMap;
import java.util.Map;

Add this method inside MainActivity:

private void saveStudentToRealtimeDatabase() {

    FirebaseUser user = mAuth.getCurrentUser();

    if (user == null) {
        return;
    }

    String name = edtStudentName.getText().toString().trim();

    if (name.isEmpty()) {

        Toast.makeText(
                this,
                "Enter student name",
                Toast.LENGTH_SHORT
        ).show();

        return;
    }

    DatabaseReference reference =
            FirebaseDatabase.getInstance()
                    .getReference("students");

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

    student.put("name", name);

    student.put("email", user.getEmail());

    reference.child(user.getUid())
            .setValue(student)
            .addOnSuccessListener(unused -> {

                txtResult.setText(
                        "Saved in Realtime Database"
                );

            })
            .addOnFailureListener(e -> {

                txtResult.setText(
                        "Error: " + e.getMessage()
                );
            });
}

Understanding the Code

Get Database Reference

FirebaseDatabase.getInstance()
        .getReference("students");

Selects the students node in Realtime Database.

Select User Node

reference.child(user.getUid());

Creates a location based on the authenticated user's unique ID.

Save Data

.setValue(student);

Writes the student information to the selected database location.

15. Read Data from Realtime Database

Add this method inside MainActivity:

private void readStudentFromRealtimeDatabase() {

    FirebaseUser user = mAuth.getCurrentUser();

    if (user == null) {
        return;
    }

    DatabaseReference reference =
            FirebaseDatabase.getInstance()
                    .getReference("students")
                    .child(user.getUid());

    reference.addListenerForSingleValueEvent(
            new com.google.firebase.database.ValueEventListener() {

                @Override
                public void onDataChange(
                        com.google.firebase.database.DataSnapshot snapshot
                ) {

                    if (snapshot.exists()) {

                        String name =
                                snapshot.child("name")
                                        .getValue(String.class);

                        String email =
                                snapshot.child("email")
                                        .getValue(String.class);

                        txtResult.setText(
                                "Name: " + name +
                                "\nEmail: " + email
                        );

                    } else {

                        txtResult.setText(
                                "No student data found"
                        );
                    }
                }

                @Override
                public void onCancelled(
                        com.google.firebase.database.DatabaseError error
                ) {

                    txtResult.setText(
                            "Error: " + error.getMessage()
                    );
                }
            }
    );
}

Understanding the Read Operation

• getReference() selects the database location.

• child() selects a child node.

• addListenerForSingleValueEvent() reads the current value once.

• onDataChange() receives the retrieved data.

• onCancelled() handles database read errors.

If you want to keep receiving updates whenever the database changes, use addValueEventListener() instead.

16. Configure Firebase Security Rules

Database security is very important.

Do not leave your database publicly readable and writable in a real application.

Because our examples store student data under the authenticated user's UID, we can use authentication-based rules.

Realtime Database Rules

Open Realtime Database > Rules and use:

{
  "rules": {
    "students": {
      "$uid": {
        ".read": "auth != null && auth.uid === $uid",
        ".write": "auth != null && auth.uid === $uid"
      }
    }
  }
}

These rules allow authenticated users to access only their own student node.

Cloud Firestore Rules

Open Firestore Database > Rules and use:

rules_version = '2';

service cloud.firestore {

    match /databases/{database}/documents {

        match /students/{studentId} {

            allow read, write:
                if request.auth != null
                && request.auth.uid == resource.data.userId;
        }
    }
}

Important: The Firestore rule above is appropriate for reading and updating existing documents, but it does not permit creating a new document because resource.data does not exist during creation.

For the add() operation used in this tutorial, use the following complete rule instead:

rules_version = '2';

service cloud.firestore {

    match /databases/{database}/documents {

        match /students/{studentId} {

            allow create:
                if request.auth != null
                && request.resource.data.userId == request.auth.uid;

            allow read, update, delete:
                if request.auth != null
                && resource.data.userId == request.auth.uid;
        }
    }
}

These rules ensure that users can create records for themselves and access only records belonging to their own UID.

17. Run and Test the Application

Now test your Firebase Student App.

Step 1: Start the Application

Run the project on an Android Emulator or a real Android device.

Step 2: Create an Account

Enter:

Email: rahul@example.com

Password: Rahul@123

Click Create Account.

Firebase should create a new user account.

Step 3: Login

Enter the registered email and password.

Click Login.

You should see a successful login message.

Step 4: Save Student Data

Enter:

Student Name: Rahul Kumar

Click Save Student to Firestore.

The student data should be saved in your Cloud Firestore database.

Step 5: Check Firebase Console

Open Firebase Console.

Select:

Firestore Database > Data

Open the students collection.

You should see the student document and its fields.

Step 6: Test Realtime Database

Call the saveStudentToRealtimeDatabase() method from a button click listener.

Open:

Realtime Database > Data

You should see the student data stored under the user's UID.

18. Common Firebase Errors

Error 1: google-services.json Missing

Problem: Firebase configuration file is missing.

Solution: Download the correct file and place it inside the app folder.

Error 2: Firebase App Not Initialized

Problem: Firebase configuration or Google Services plugin is not configured correctly.

Solution: Verify the package name, JSON file and Gradle configuration.

Error 3: Authentication Failed

Problem: Email/password provider is not enabled or the credentials are invalid.

Solution: Enable Email/Password in Firebase Authentication and check the entered details.

Error 4: Permission Denied

Problem: Firebase security rules do not allow the requested operation.

Solution: Check the database rules and confirm that the user is authenticated.

Error 5: Data Not Appearing in Firestore

Problem: The write operation failed or the wrong Firebase project is connected.

Solution: Check the Firebase project, Firestore console and failure listener error message.

Error 6: Database URL Configuration Problem

Problem: Realtime Database is initialized with an incorrect database instance or URL.

Solution: Confirm the Realtime Database URL in Firebase Console and use the correct instance configuration.

19. Firebase Security Best Practices

Follow these practices when building real applications:

1. Never leave database rules open to everyone.

2. Require authentication for private user data.

3. Use Firebase Authentication to identify users.

4. Restrict database access using user UID.

5. Validate data through security rules.

6. Do not store plain-text passwords in Realtime Database or Firestore.

7. Never trust the Android application alone to enforce access control.

8. Use Firebase App Check where appropriate to help protect backend resources.

9. Monitor Firebase usage and configure budget alerts.

10. Test security rules before publishing your application.

20. Conclusion

In this tutorial, we learned how to integrate Firebase with Android Studio using Java.

We covered three important Firebase services:

• Firebase Authentication

• Firebase Realtime Database

• Cloud Firestore

We also learned how to:

• Create a Firebase project.

• Connect Android Studio with Firebase.

• Register and log in users.

• Sign out users.

• Save student information in Firestore.

• Read student records from Firestore.

• Save data in Realtime Database.

• Retrieve data from Realtime Database.

• Configure authentication-based security rules.

Firebase makes it easier to build Android applications that require authentication and cloud-based data storage without managing a traditional backend server.

21. Frequently Asked Questions

Q1. What is Firebase in Android development?

Firebase is a backend platform that provides services such as authentication, databases, storage, notifications and analytics.

Q2. What is Firebase Authentication?

Firebase Authentication manages user identity and provides login and registration methods.

Q3. What is Firebase Realtime Database?

It is a cloud-hosted NoSQL database that stores data in a JSON-like tree and synchronizes updates in real time.

Q4. What is Cloud Firestore?

Cloud Firestore is a NoSQL cloud database that stores data in collections and documents.

Q5. What is the difference between Realtime Database and Firestore?

Realtime Database uses a JSON-like tree structure, while Firestore uses collections and documents with more flexible querying capabilities.

Q6. Do we need PHP to use Firebase?

No. Firebase provides backend services that Android applications can access directly through Firebase SDKs. You may still use your own backend when your application requires custom server-side processing.

Q7. Is Firebase free?

Firebase offers no-cost usage limits for eligible services, but some features and higher usage levels require a paid plan. Always check the current pricing and usage limits before deploying a production application.

Q8. Can Firebase work with Java in Android Studio?

Yes. Firebase provides Android SDKs that can be used with Java applications.