Gestión de errores de autenticación

What Happens When Things Go Wrong?

Why Handle Authentication Errors?

Introducing FirebaseAuthException

Basic Error Catching

public class Main {
    // Dummy FirebaseAuthException for demonstration
    static class FirebaseAuthException extends Exception {
        private String errorCode;
        public FirebaseAuthException(String errorCode, String message) {
            super(message);
            this.errorCode = errorCode;
        }
        public String getErrorCode() { return errorCode; }
    }

    public static void main(String[] args) {
        System.out.println("Attempting a sign-in operation...");
        try {
            // In a real app, this would be a Firebase method call.
            // For this example, we'll simulate an error.
            boolean shouldFail = true; // Set to false to simulate success
            if (shouldFail) {
                throw new FirebaseAuthException("wrong-password", "The password is invalid.");
            }
            System.out.println("Sign-in successful!");
        } catch (FirebaseAuthException e) {
            System.out.println("Caught specific Firebase Auth Error!");
            System.out.println("Error Code: " + e.getErrorCode());
            System.out.println("Error Message: " + e.getMessage());
        } catch (Exception e) {
            System.out.println("Caught a general error: " + e.getMessage());
        }
    }
}

Common Authentication Error Codes

Mapping Codes to User-Friendly Messages

public class Main {
    // Dummy FirebaseAuthException for demonstration
    static class FirebaseAuthException extends Exception {
        private String errorCode;
        public FirebaseAuthException(String errorCode, String message) {
            super(message);
            this.errorCode = errorCode;
        }
        public String getErrorCode() { return errorCode; }
    }

    public static String getFriendlyErrorMessage(String errorCode) {
        switch (errorCode) {
            case "user-not-found":
                return "No account found with this email.";
            case "wrong-password":
                return "Incorrect password. Please try again.";
            case "invalid-email":
                return "The email address is badly formatted.";
            case "email-already-in-use":
                return "This email is already registered.";
            default:
                return "An unknown error occurred. Please try again.";
        }
    }

    public static void main(String[] args) {
        // Simulate an error: user enters wrong password
        String simulatedErrorCode = "wrong-password";
        try {
            throw new FirebaseAuthException(simulatedErrorCode, "The password is invalid.");
        } catch (FirebaseAuthException e) {
            String userMessage = getFriendlyErrorMessage(e.getErrorCode());
            System.out.println("Display to user: " + userMessage);
        }
        
        System.out.println("\nSimulating another error: invalid email");
        simulatedErrorCode = "invalid-email";
        try {
            throw new FirebaseAuthException(simulatedErrorCode, "The email address is badly formatted.");
        } catch (FirebaseAuthException e) {
            String userMessage = getFriendlyErrorMessage(e.getErrorCode());
            System.out.println("Display to user: " + userMessage);
        }
    }
}

Example: Handling Registration Errors

public class Main {
    // Dummy FirebaseAuthException for demonstration
    static class FirebaseAuthException extends Exception {
        private String errorCode;
        public FirebaseAuthException(String errorCode, String message) {
            super(message);
            this.errorCode = errorCode;
        }
        public String getErrorCode() { return errorCode; }
    }

    public static String getFriendlyErrorMessage(String errorCode) {
        switch (errorCode) {
            case "email-already-in-use":
                return "This email is already registered. Try logging in or resetting your password!";
            case "invalid-email":
                return "Please enter a valid email address.";
            case "weak-password":
                return "Password should be at least 6 characters long.";
            default:
                return "Registration failed. Please try again.";
        }
    }

    public static void registerUser(String email, String password) {
        System.out.println("Attempting to register: " + email);
        try {
            // Simulate FirebaseAuth.getInstance().createUserWithEmailAndPassword(email, password);
            if (email.equals("existing@example.com")) {
                throw new FirebaseAuthException("email-already-in-use", "The email address is already in use.");
            } else if (password.length() < 6) {
                throw new FirebaseAuthException("weak-password", "Password too short.");
            }
            System.out.println("User registered successfully: " + email);
        } catch (FirebaseAuthException e) {
            System.out.println("Registration Error: " + getFriendlyErrorMessage(e.getErrorCode()));
        } catch (Exception e) {
            System.out.println("General error during registration: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        registerUser("newuser@example.com", "strongpass");
        System.out.println("");
        registerUser("existing@example.com", "anypass");
        System.out.println("");
        registerUser("short@example.com", "123");
    }
}

Beyond Simple Messages: Actionable Feedback

Best Practice: Logging Errors

Error Handling Check

Recap: Handling Auth Errors