firebase/FirebaseUI-Android

This system is the FirebaseUI Android library, providing pre-built UI components and adapters for integrating Firebase Authentication, Realtime Database, Cloud Firestore, and Storage into Android applications. It enables developers to implement secure sign-in flows, including multi-factor authentication and credential linking, while efficiently displaying paginated and real-time data in RecyclerViews. The library also offers utilities for loading images from Firebase Storage and includes a comprehensive demo app for testing these features against local emulators.

12 changes.

This period focused on modernizing the project's build infrastructure, including a major Gradle upgrade and the introduction of a version catalog, while overhauling repository documentation. Significant development effort was directed at rewriting the authentication module for Jetpack Compose with Material 3 and Credential Manager support, alongside adding lifecycle-aware features to database adapters and new image loading capabilities for Firebase Storage.

12 changes.

This period focused on introducing FirebaseUI support for Cloud Firestore, including new RecyclerView adapters, data binding components, and comprehensive instrumentation tests. The team also migrated the Realtime Database to AndroidX Paging 3, enhancing pagination with improved lifecycle management and error handling. Supporting infrastructure was strengthened through automated build scripts, translation resource cleanup tools, and stricter lint checks for adapter lifecycle and layout IDs.

13 changes.

The project refactored the authentication library to a Jetpack Compose-based architecture with per-step Navigation 3 destinations, enabling robust state management and modular provider handling. This period introduced comprehensive Multi-Factor Authentication flows, a new Kotlin DSL for configuration, and customizable string providers, while updating the demo app to Material 3 and local emulator integration.

8 changes.

This period focused on expanding the FirebaseUI Android demo application with new Compose-based authentication, storage, and database paging activities, alongside a script to automate its launch. Concurrently, the library itself introduced dedicated Compose screens and navigation destinations for multi-factor authentication and reauthentication flows, improving UI customization and state management.

The demo app now includes a new StorageDemoActivity that demonstrates loading images from Firebase Storage using Glide. It supports two approaches: loading directly via a gs:// URL string and loading via a StorageReference, with clear status feedback for success or error states.

app/src/main/java/com/firebaseui/android/demo/storage · high confidence

The e2eTest directory now includes configuration files (.firebaserc, firebase.json, database.rules.json) to set up local Firebase emulators for authentication, Firestore, and Realtime Database during end-to-end testing. The emulators are configured to run on specific ports (9099, 8080, 8199) with the UI enabled, and the database rules allow unrestricted read/write access for the test environment.

e2eTest · high confidence

A new shell script, run-demo.sh, has been added to the app/scripts directory. This tool automates the process of building, installing, and launching the FirebaseUI Android demo application. It provides an interactive menu allowing developers to either use an already connected Android device or emulator, or to automatically start a new emulator instance from available AVDs, handling device detection and boot-waiting in the background.

app/scripts · high confidence

Added a suite of Python and shell scripts in scripts/translations to automate the processing of Android string resources. These tools standardize translation files by adding a 'fui\_' prefix to string names, fixing typography issues such as ellipsis spacing and quote characters, removing non-translatable strings, and exporting cleaned resources with calculated character limits.

scripts/translations · high confidence

The database adapters (FirebaseListAdapter and FirebaseRecyclerAdapter) now integrate with the Android Architecture Components Lifecycle. By accepting a LifecycleOwner in their configuration options, the adapters automatically start listening for database changes on lifecycle start and stop listening on lifecycle stop, preventing memory leaks and ensuring the UI stays in sync with the data without manual management.

database/src/main/java/com/firebase/ui/database · high confidence

Added the README documentation for FirebaseUI for Cloud Firestore, detailing how to use FirestoreRecyclerAdapter and FirestorePagingAdapter to bind data to RecyclerViews, along with a ProGuard rules file to suppress warnings for the paging package.

firestore · high confidence

Adds a new set of classes in the Firestore module to bind Firebase Firestore queries to Android RecyclerViews. This includes FirestoreRecyclerAdapter for real-time UI updates, FirestoreArray to expose query results as an observable list, and supporting classes like FirestoreRecyclerOptions, SnapshotParser, and CachingSnapshotParser to handle data parsing and lifecycle-aware listening.

firestore/src/main/java/com/firebase/ui/firestore · high confidence

This change adds a new pagination API for Firebase Realtime Database, allowing developers to efficiently load and display large datasets in RecyclerViews. The new \FirebaseRecyclerPagingAdapter\ integrates with AndroidX Paging, automatically handling background loading, lifecycle-aware observation, and diffing of data snapshots. It supports queries ordered by key, child values, or value, and provides a \LoadingState\ enum to track loading progress and errors, simplifying the implementation of infinite scroll for database-backed lists.

database/src/main/java/com/firebase/ui/database/paging · high confidence

Adds a new set of core classes in the common module to standardize how Firebase data is observed and parsed. This includes BaseObservableSnapshotArray, which exposes database snapshots as a reactive List with change listeners, and BaseCachingSnapshotParser, which caches parsed objects to avoid redundant processing. The change also introduces supporting interfaces and utilities like BaseChangeEventListener, ChangeEventType, and Preconditions to unify event handling and argument validation across the library.

common/src/main/java · high confidence

The auth library introduces a new set of Jetpack Compose UI components in the \ui.components\ package, replacing or supplementing the previous view-based implementation. This includes \AuthProviderButton\ for customizable provider sign-in buttons, \AuthTextField\ for input fields with built-in validation and keyboard handling, \CountrySelector\ for phone number country selection, \ErrorRecoveryDialog\ and \ReauthenticationDialog\ for user-facing error and re-auth flows, \QrCodeImage\ for TOTP setup, \TermsAndPrivacyForm\ for legal links, \TopLevelDialogController\ for centralized dialog management, and \VerificationCodeInputField\ for multi-digit code entry. These components provide a modern, customizable, and accessible foundation for the authentication UI.

auth/src/main/java/com/firebase/ui/auth/ui/components · high confidence

The auth demo app now includes a suite of new Compose-based activities to showcase FirebaseUI features. AuthChooserActivity serves as the entry point, launching demos for the High-Level API (FirebaseAuthScreen), Low-Level API (AuthFlowController), Custom Slots & Theming, and Credential Linking. These demos demonstrate modern UI patterns, including custom method pickers, shape customization, email/phone slot overrides, and credential linking workflows.

app/src/main/java/com/firebaseui/android/demo/auth · high confidence

The authentication library now provides a new Kotlin DSL (\authUIConfiguration\) and associated configuration classes (\AuthUIConfiguration\, \MfaConfiguration\, \PasswordRule\) to define auth behavior. Users can now configure multi-factor authentication factors and enrollment requirements, enforce password complexity rules (such as minimum length, uppercase/lowercase/digit/special character requirements, or custom regex), and customize UI transitions and credential linking settings through a structured builder pattern.

auth/src/main/java/com/firebase/ui/auth/configuration · high confidence

The MFA module now includes dedicated Compose screens and navigation destinations for both the MFA challenge (verification during sign-in) and MFA enrollment (setting up a second factor) flows. This adds the \MfaChallengeScreen\ and \MfaEnrollmentScreen\ composables, along with their default UI implementations (\MfaChallengeDefaults\, \MfaEnrollmentDefaults\) and navigation wiring (\MfaEnrollmentDestinations\). The enrollment flow is structured as a multi-step process (SelectFactor, ConfigureSms/Totp, VerifyFactor) with a shared \MfaEnrollmentFlowState\ to preserve data across step transitions, and both flows support custom UI rendering via a \content\ slot.

auth/src/main/java/com/firebase/ui/auth/ui/screens/mfa · high confidence

This update introduces a complete, step-by-step Multi-Factor Authentication (MFA) system for Firebase UI, allowing users to enroll in and verify SMS or TOTP (Time-based One-Time Password) factors. The \auth\ module now includes dedicated handlers (\SmsEnrollmentHandler\, \TotpEnrollmentHandler\) and state classes (\MfaEnrollmentContentState\, \MfaChallengeContentState\) that expose granular steps—such as selecting a factor, configuring SMS with country selection, setting up TOTP via QR code, and verifying codes—to the UI layer. This enables developers to build custom, navigable MFA experiences that are decoupled from the phone sign-in provider, supporting both enrollment and sign-in challenge flows with proper error mapping and loading states.

auth/src/main/java/com/firebase/ui/auth/mfa · high confidence

The repository now includes a set of shell scripts in the \scripts/\ directory to streamline development and release workflows. \build.sh\ automates the local build process by copying configuration files and running Gradle tasks for assembly, checkstyle, and unit tests. \compare.sh\ enables API compatibility checking between library versions using \japi-compliance-checker\, with results saved to \compat\_reports\. \start-firebase-emulator.sh\ provides a robust way to launch the Firebase Auth emulator with retry logic and health checks, supporting both local foreground and CI background execution. Additional utilities include \print\_build\_logs.sh\ for aggregating test and lint reports, and \exclude-annotations.txt\ to define annotations excluded from compatibility checks.

scripts · high confidence

The app now includes new demo activities for email authentication, phone authentication, and database paging. The email demo allows users to sign in with email and password, with options to require a display name and enforce password rules. The phone demo supports phone number authentication with verification code entry. The database demo showcases paginated lists using FirebaseRecyclerPagingAdapter with Firestore and Realtime Database, allowing users to seed and refresh data.

app/src · high confidence

The demo application now uses a new MainActivity that serves as the central entry point, featuring a Compose-based UI for navigating to Auth, Database, Firestore, and Storage demo modules. This activity automatically configures Firebase Auth, Firestore, and Realtime Database to connect to their respective local emulators (on 10.0.2.2) when the app starts, ensuring developers can test against local services immediately. It also handles deep-linking for email sign-in links by passing them through to the HighLevelApiDemoActivity.

app/src/main/java/com/firebaseui/android/demo · high confidence

The lint module now includes custom checks that warn developers if a FirestoreRecyclerAdapter is used without calling startListening, or if startListening is called without a corresponding stopListening. These warnings help prevent data synchronization issues and potential memory leaks in RecyclerViews by ensuring proper adapter lifecycle handling.

lint · high confidence

The auth library introduces \AuthUIStringProvider\, a new interface and \CompositionLocal\ that allows developers to fully customize all user-facing strings in the authentication UI. This change replaces hardcoded strings with a centralized provider, enabling complete localization and branding customization (e.g., custom button text, error messages, and loading states) without modifying the library's source code.

_auth/src/main/java/com/firebase/ui/auth/configuration/string\provider · high confidence

Added a suite of utility classes in the auth library to support improved user experience and robust session handling. This includes CredentialPersistenceManager and SignInPreferenceManager to track saved credentials and last-used sign-in methods for faster re-authentication, PasswordCredentialHandler to integrate with Android's Credential Manager for password storage and retrieval, and EmailLinkParser/EmailLinkPersistenceManager to handle email link sign-in sessions and linking flows. Additional utilities like CountryUtils and PhoneNumberUtils improve country selection and phone number validation, while ContinueUrlBuilder and SessionUtils support state management in cross-device flows.

auth/src/main/java/com/firebase/ui/auth/util · high confidence

The storage module now includes a FirebaseImageLoader that allows Glide to load images directly from Firebase Storage using plain gs:// URL strings, in addition to StorageReference objects. This new capability introduces a StringLoader and its Factory, enabling developers to pass a gs:// URL string to Glide's load() method without first resolving it to a StorageReference. The implementation handles URL validation and delegates to the existing storage fetcher, with corresponding unit tests verifying correct handling of valid and invalid gs:// URLs.

storage/src · high confidence

The app module now includes a .gitignore file to exclude build artifacts and a proguard-rules.pro file containing default configuration comments for code shrinking and obfuscation, ensuring the build process works correctly without manual cleanup of generated files.

app · high confidence

A new placeholder class, FirebaseUI, has been added to the library to ensure the Android Gradle plugin correctly generates an AAR artifact. This class serves as a minimal code anchor, addressing issues where publishing a POM-only monolith was not respected by the build toolchain.

library/src/main/java · high confidence

The authentication UI has been refactored to use Jetpack Navigation 3, where each step of the sign-in, phone verification, and multi-factor enrollment flows is now a distinct, serializable navigation destination. This change enables robust back-stack management, allowing the library to preserve user input (such as typed email addresses) across configuration changes and process death. The main entry point, FirebaseAuthScreen, now orchestrates these individual screens, while the method picker and reauthentication flows have been decoupled to support this new navigation model.

auth/src/main/java/com/firebase/ui/auth/ui/screens · high confidence

The demo application now uses a modern UI theme based on Material 3. This introduces a new color palette (purple, purple-grey, and pink shades) and typography settings. The theme logic automatically applies dynamic colors on Android 12+ devices, while falling back to the defined light and dark color schemes on older versions, providing a more contemporary look for the demo.

app/src/main/java/com/firebaseui/android/demo/ui · high confidence

The database module's README has been updated to reflect the migration to Paging 3, introducing the \FirebaseRecyclerPagingAdapter\ for handling large, static datasets with pagination while noting that real-time events are not supported by this adapter. Additionally, a new \proguard-rules.pro\ file has been added to suppress warnings for the \com.firebase.ui.database.paging\ package, ensuring compatibility with code shrinking and obfuscation tools.

database · high confidence

The email sign-in, sign-up, password reset, and email-link sign-in steps are now implemented as distinct navigation destinations within the Android Navigation 3 system. This change replaces the previous single-screen mode-switching approach with a real back stack, allowing each step to be navigated to independently while preserving the typed email address across transitions. The email flow now supports deeper linking and more robust state management, with each mode (SignIn, SignUp, ResetPassword, EmailLinkSignIn) mapped to its own route and UI component.

auth/src/main/java/com/firebase/ui/auth/ui/screens/email · high confidence

The auth module has been completely rewritten for Compose, introducing \AuthFlowController\ to manage the authentication lifecycle and \AuthFlowScope\ to scope provider logic to individual flows. The new \AuthState\ sealed class distinguishes between operation-level cancellations (\Cancelled\) and full flow aborts (\Aborted\), while \AuthException\ provides a structured hierarchy for error handling. This change replaces the previous imperative activity-based flow with a declarative, coroutine-backed model that improves state management and error reporting.

auth/src/main/java/com/firebase/ui/auth · high confidence

The auth module has been updated to version 10.0.0-beta05, introducing a complete transition to a modern, Jetpack Compose-based authentication UI built on Material Design 3. This change replaces the legacy view-based implementation, providing drop-in Compose screens and controllers that integrate seamlessly with modern Android apps. The update also adds support for Android Credential Manager, enabling automatic credential saving and one-tap sign-in, while maintaining support for 12+ authentication methods including email, phone, and various OAuth providers. Documentation has been updated to reflect the new Compose-first API, and a new proguard configuration file has been added to handle optional third-party provider dependencies.

auth · high confidence

The Firestore UI paging implementation has been migrated to the AndroidX Paging 3 library. This introduces a new architecture with dedicated classes like FirestorePagingSource, FirestorePagingOptions, and FirestorePagingAdapter, replacing the previous paging mechanism. Users benefit from better lifecycle management through automatic start/stop listening based on the LifecycleOwner, and more robust error handling that now properly catches and reports ExecutionException and InterruptedException during data loading. The diff also adds a DefaultSnapshotDiffCallback for efficient list updates and a PageKey class to manage pagination boundaries using DocumentSnapshots.

firestore/src/main/java/com/firebase/ui/firestore/paging · high confidence

A new internal lint rule, NonGlobalIdInLayout, has been added to the FirebaseUI Android lint module. This check detects the use of non-global IDs (e.g., @id/...) in layout XML files and flags them as errors, recommending the use of global IDs (@+id/...) instead to ensure compatibility with aapt1. The change includes the implementation of the detector, its registration in the issue registry, and corresponding unit tests.

internal/lint · high confidence

The authentication library has been refactored to use a new provider-based configuration model. Instead of the previous monolithic approach, sign-in logic for each provider (Google, Facebook, Email, Phone, OAuth, and Anonymous) is now encapsulated in dedicated implementation files within the \auth\_provider\ package. This change introduces a structured \AuthProvider\ hierarchy and specific handlers (such as \rememberGoogleSignInHandler\ and \rememberSignInWithFacebookLauncher\) that manage the UI state and credential flow for each method individually, improving modularity and separation of concerns in the authentication process.

_auth/src/main/java/com/firebase/ui/auth/configuration/auth\provider · high confidence

The phone sign-in and SMS multi-factor enrollment flows have been refactored so that each step (entering the phone number and entering the verification code) is a distinct navigation destination rather than a single screen with internal state switches. This change ensures that system back-press correctly returns to the previous step and that asynchronous verification attempts (such as auto-retrieval timeouts) survive navigation between steps by sharing a long-lived flow state. Host applications must now provide navigation support for these multi-step screens, and the previous sign-in controls that were redundant with this new navigation model have been removed.

auth/src/main/java/com/firebase/ui/auth/ui/screens/phone · high confidence

The reauthentication flow for sensitive operations (like account deletion or password change) has been refactored to use a dedicated navigation destination and its own scoped state machine, decoupling it from the shared FirebaseAuthUI state. This change introduces a new \ReauthContentState\ data class and a \reauthContent\ slot in \FirebaseAuthScreen\, allowing developers to provide a custom UI (such as a dialog or modal sheet) for the provider chooser while the library manages the credential exchange. The reauthentication steps are now real navigation destinations within a single back stack, ensuring proper lifecycle management and state preservation during Activity recreation.

auth/src/main/java/com/firebase/ui/auth/ui/screens/reauth · high confidence

The repository has been restructured with new documentation files (AGENTS.md, CLAUDE.md, GETTING\_STARTED.md) and a comprehensive CONTRIBUTING.md guide that specifies JDK 21 and Android SDK API level 21 as minimum requirements. The project has migrated its build system to Gradle 9.6.1 (wrapper updated from 8.14.5) and updated the FirebaseUI Auth library version to 10.0.0-beta05. Additionally, the release notes have been moved from the local CHANGELOG.md to the GitHub Releases page, and the .gitignore has been updated to exclude generated files like .kotlin/ and crashlytics build properties.

(repo-wide) · high confidence

Added Android instrumented tests for FirebaseArray and FirebaseIndexArray; Added Robolectric configuration for Android SDK 28; Added instrumentation tests for FirestoreArray; Added tests for DatabasePagingSource pagination with orderByChild; Added unit tests for FirestorePagingSource; Added unit tests for the auth library core components; New e2e test infrastructure and coverage for FirebaseUI Auth screens.

This release updates the project to version 10.0.0-beta05, upgrading the Android Gradle Plugin to 9.4.0 and Kotlin to 2.4.20. It introduces a comprehensive version catalog (libs.versions.toml) to manage dependencies, including the Firebase BOM 34.19.0, Compose BOM 2026.09.00, and various AndroidX libraries. The auth module now uses Navigation 3 and the Credential Manager API, while the build system enforces stricter linting and configures Gradle Develocity for build scans.

(dependencies) · high confidence

The Gradle wrapper configuration has been updated to use Gradle 9.7.1. This ensures that builds are executed with the specified version of the Gradle build tool, providing consistency across development environments and leveraging any improvements or bug fixes included in this release.

gradle · high confidence

The build configuration has been updated to version 10.0.0-beta05. The compile SDK level is now set to 37, the target SDK to 36, and the minimum SDK remains at 23. The list of submodules included in the build is defined as auth, common, firestore, database, and storage.

buildSrc · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 50 → 74 (+24.4)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 92 → 88 (-4.9)
• Architecture 94 → 89 (-5.1)
• Maturity 61 → 67 (+6.1)
• Readiness 25 → 77 (+52.0)
• Security 75 → 81 (+6.2)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• Duplicated block (10 lines × 2) (auth/src/main/java/com/firebase/ui/auth/ui/screens/FirebaseAuthScreen.kt)
• Duplicated block (12 lines × 2) (auth/src/main/java/com/firebase/ui/auth/configuration/auth_provider/EmailAuthProvider+FirebaseAuthUI.kt)
• Duplicated block (12 lines × 2) (auth/src/main/java/com/firebase/ui/auth/configuration/auth_provider/EmailAuthProvider+FirebaseAuthUI.kt)
• Duplicated block (12 lines × 3) (auth/src/main/java/com/firebase/ui/auth/configuration/auth_provider/PhoneAuthProvider+FirebaseAuthUI.kt)
• Duplicated block (126 lines × 2) (auth/src/main/java/com/firebase/ui/auth/configuration/auth_provider/EmailAuthProvider+FirebaseAuthUI.kt)
• Duplicated block (13 lines × 2) (app/src/main/java/com/firebaseui/android/demo/storage/StorageDemoActivity.kt)
• Duplicated block (13 lines × 2) (auth/src/main/java/com/firebase/ui/auth/ui/components/AuthProviderButton.kt)
• Duplicated block (13 lines × 2) (auth/src/main/java/com/firebase/ui/auth/ui/screens/MfaEnrollmentScreen.kt)
• Duplicated block (14 lines × 2) (app/src/main/java/com/firebaseui/android/demo/auth/EmailAuthSlotDemoActivity.kt)
• Duplicated block (14 lines × 2) (auth/src/main/java/com/firebase/ui/auth/ui/screens/MfaChallengeScreen.kt)
• Duplicated block (17 lines × 2) (auth/src/main/java/com/firebase/ui/auth/ui/screens/MfaChallengeScreen.kt)
• Duplicated block (17 lines × 3) (app/src/main/java/com/firebaseui/android/demo/MainActivity.kt)
• Duplicated block (18 lines × 3) (app/src/main/java/com/firebaseui/android/demo/auth/AuthChooserActivity.kt)
• Duplicated block (20 lines × 2) (app/src/main/java/com/firebaseui/android/demo/auth/EmailAuthSlotDemoActivity.kt)
• Duplicated block (20 lines × 2) (auth/src/main/java/com/firebase/ui/auth/configuration/auth_provider/EmailAuthProvider+FirebaseAuthUI.kt)
• Duplicated block (30 lines × 2) (auth/src/main/java/com/firebase/ui/auth/ui/screens/MfaEnrollmentDefaults.kt)
• Duplicated block (73 lines × 2) (auth/src/main/java/com/firebase/ui/auth/FirebaseAuthUI.kt)
• Leaked secret: gcp-api-key (library/google-services.json)
• …and 9 more

• AuthException.from (cognitive 18) (auth/src/main/java/com/firebase/ui/auth/AuthException.kt)
• AuthException.from (cyclomatic 21) (auth/src/main/java/com/firebase/ui/auth/AuthException.kt)
• AuthProviderButtonKt.resolveProviderLabel (cognitive 39) (auth/src/main/java/com/firebase/ui/auth/ui/components/AuthProviderButton.kt)
• AuthProviderButtonKt.resolveProviderLabel (cyclomatic 26) (auth/src/main/java/com/firebase/ui/auth/ui/components/AuthProviderButton.kt)
• BaseStringScript.ProcessFile (cognitive 19) (scripts/translations/base_string_script.py)
• ClassTooLong: AuthProvider (auth/src/main/java/com/firebase/ui/auth/configuration/auth_provider/AuthProvider.kt)
• DatabasePagingSource.loadSingle (cognitive 29) (database/src/main/java/com/firebase/ui/database/paging/DatabasePagingSource.java)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: contradicts the code (docs/upgrade-to-9.0.md)
• Documentation: hard to navigate (docs/compat_reports/firebase-ui-database/3.3.1_to_4.0.0/compat_report.html)
• Documentation: written for insiders (docs/internal/releasing.md)
• Documentation: written for insiders (docs/internal/translations.md)
• Duplicated block (10 lines × 12) (auth/src/main/java/com/firebase/ui/auth/configuration/auth_provider/AnonymousAuthProvider+FirebaseAuthUI.kt)
• Duplicated block (11 lines × 2) (auth/src/main/java/com/firebase/ui/auth/ui/screens/mfa/MfaEnrollmentDefaults.kt)
• Duplicated block (11–12 lines × 3) (auth/src/main/java/com/firebase/ui/auth/configuration/auth_provider/AnonymousAuthProvider+FirebaseAuthUI.kt)
• Duplicated block (12 lines × 2) (auth/src/main/java/com/firebase/ui/auth/ui/components/AuthProviderButton.kt)
• Duplicated block (12–15 lines × 2) (app/src/main/java/com/firebaseui/android/demo/auth/AuthFlowControllerDemoActivity.kt)
• Duplicated block (13 lines × 2) (app/src/main/java/com/firebaseui/android/demo/auth/EmailAuthSlotDemoActivity.kt)
• Duplicated block (13 lines × 2) (auth/src/main/java/com/firebase/ui/auth/ui/screens/email/SignInUI.kt)
• Duplicated block (13 lines × 3) (auth/src/main/java/com/firebase/ui/auth/configuration/auth_provider/AnonymousAuthProvider+FirebaseAuthUI.kt)
• …and 74 more

• 85 commits — 60 feature/other, 25 fixes

• auth/src — 53 commits
• gradle/libs.versions.toml — 13 commits
• e2eTest/src — 6 commits
• (root) — 5 commits
• .github/workflows — 3 commits
• gradle/wrapper — 2 commits
• app/src — 1 commit
• auth/README.md — 1 commit
• docs/upgrade-to-10.0.md — 1 commit

• fix: fix(auth)!: add an Android Lint workflow and gate the Kotlin modules on it (#2498)
• fix: fix(auth)!: remove non-functional MFA recovery codes (#2457)
• fix: fix(auth)!: remove the sign-in controls made redundant by per-step navigation (#2482)
• fix: fix(auth): clear MFA enrollment flow state on every entry (#2473)
• fix: fix(auth): clear the reauthentication handover state however the retry ends
• fix: fix(auth): complete MFA challenge sign-in navigation and success callback (#2458)
• fix: fix(auth): decline a reauthentication request that is never presented
• fix: fix(auth): decline the outstanding request when an abort finds no phase to end
• fix: fix(auth): don't reset MFA enrollment state when already in the flow (#2477)
• fix: fix(auth): don't strand phone-only users on email verification after reload (#2474)
• fix: fix(auth): fix "Already resumed" crash in phone auth SMS auto-verification (#2447)
• fix: fix(auth): log diagnostic warning when Google sign-in NoCredentialException fallback exhausts
• fix: fix(auth): only exit auth flow on AuthState.Aborted, not per-provider Cancelled (#2440)
• fix: fix(auth): pre-fill email when "Continue as" button is tapped (#2423) (#2425)
• fix: fix(auth): prevent MFA code input from triggering password manager save (#2405) (#2421)
• fix: fix(auth): read a user's email once when deciding what their sign-in means
• fix: fix(auth): report Google/Facebook/OAuth/Anonymous sign-in failures via onSignInFailure (#2433)
• fix: fix(auth): report a failed retry as an error instead of a stale success
• fix: fix(auth): show the link-sent confirmation on anonymous upgrade, with e2e tests (#2484)
• fix: fix(auth): stale one-off AuthState no longer leaks across screen instances (#2415)
• …and 65 more

• Containers 0 added · 0 removed · contexts 7 added · 0 removed · edges 3 added · 0 removed

• app
• auth
• common
• database
• firestore
• lint
• storage

• app → auth
• database → common
• firestore → common

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

firebase/FirebaseUI-Android was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.