Firebase SDK Authentication

📖 Theory

Doing it yourself

FirebaseUI gives you login for free but with its own screens. Sometimes you want your own login screen, matching your app's design exactly, and your own control over the flow. For that, you call the Firebase Authentication SDK directly.

You build the login and registration layouts yourself, then invoke FirebaseAuth methods when the user taps your buttons. This lesson shows the core methods and the callback pattern Firebase uses. It is more code than FirebaseUI, but it is how you get complete control, and it makes clear what FirebaseUI was doing for you.

📖 Theory

The core auth methods

With your own UI, three FirebaseAuth methods do the work:

• createUserWithEmailAndPassword(email, password): register a new user.
• signInWithEmailAndPassword(email, password): log an existing user in.
• signOut(): sign the current user out.

Because these talk to Firebase over the network, they are asynchronous: each returns a Task that completes later, success or failure. You attach listeners to react when it finishes, rather than getting an immediate result. So the pattern is always: call the method, then handle the Task's outcome.

⌨️ Practical

Registering and logging in with the SDK

val auth = Firebase.auth

// Register a new user (from your own registration screen)
auth.createUserWithEmailAndPassword(email, password)
    .addOnCompleteListener { task ->
        if (task.isSuccessful) {
            val user = auth.currentUser        // now signed in
            // navigate to the main screen
        } else {
            // show task.exception?.message on your UI
        }
    }

// Log an existing user in
auth.signInWithEmailAndPassword(email, password)
    .addOnCompleteListener { task -> /* same success/failure handling */ }

✏️ Formula

Async: handle the Task, do not expect an instant result

These methods do not return the user immediately. They start a network request and return a Task; the result arrives later in a listener. So you never write val user = auth.signIn(...), you call the method and put your 'what to do next' inside addOnCompleteListener (or success/failure listeners).

Inside, check task.isSuccessful: if true, the user is signed in (auth.currentUser is set) and you proceed; if false, read task.exception to show the error. This asynchronous, callback-driven style is how all networked Firebase calls work, so getting comfortable with it here pays off across the whole subject.

🧩 Quiz

Using the Firebase SDK directly, which method registers a brand-new user with an email and password?

1. signInWithEmailAndPassword(email, password), because it signs them in
2. createUserWithEmailAndPassword(email, password), which registers a new user account
3. signOut(), because it resets the account
4. currentUser, because it creates the user

💭 Think first

Why are these auth calls asynchronous with Tasks instead of returning a result directly?

Why does signInWithEmailAndPassword return a Task you listen to, rather than just returning the user? Then tap.

✅ Summary

Key takeaways

• Firebase SDK authentication means building your own login UI and calling FirebaseAuth methods directly.
• createUserWithEmailAndPassword registers a new user; signInWithEmailAndPassword logs an existing user in; signOut ends the session.
• These are asynchronous: each returns a Task that completes later, not an immediate result.
• Attach a listener (addOnCompleteListener) and check task.isSuccessful; on failure read task.exception for the error.
• Benefit over FirebaseUI: full control of the UI and flow; cost: you write the screens and handle the states yourself.
• The calls are async because they hit the network, and blocking the UI thread would freeze the app.
• Memory hook: create to register, signIn to log in, handle the Task's success or failure in a listener.