firebase/quickstart-android

This repository is a collection of reference Android applications designed to demonstrate the integration of various Firebase and Google services. It provides concrete examples for features such as authentication, real-time and cloud data storage, cloud functions, analytics, crash reporting, and advertising. The samples are implemented in both Java and Kotlin, often utilizing modern Android development practices like Jetpack Compose and ViewBinding to serve as practical learning resources for developers.

25 changes.

This period established the foundational structure of the Firebase Android Quickstarts repository, including build infrastructure, documentation, and licensing. It focused on populating the project with initial quickstart samples for core Firebase services such as Auth, Database, Storage, Analytics, and Crashlytics, alongside their corresponding ProGuard configurations and UI test suites.

30 changes.

This period focused on expanding the quickstart library with new samples for services like Firestore, Data Connect, and In-App Messaging, while systematically migrating existing Java samples to Kotlin. The work standardized modern Android development practices across all apps by adopting ViewBinding, the Jetpack Navigation Component, and updated Firebase SDK APIs, alongside implementing internal lint checks to enforce Kotlin coding standards.

16 changes.

This period focused on expanding the repository with comprehensive quickstart samples for Firebase App Distribution, Data Connect, and Firebase AI, demonstrating features like multimodal generation, hybrid inference, and database integration. It also included internal maintenance such as migrating the chooser module to AndroidX and implementing a script to ensure consistency between Java and Kotlin code snippets.

Introduces the AdMob by Google Android quickstart sample, which demonstrates displaying banner and interstitial ads using AdRequest, AdView, and InterstitialAd. The addition includes the necessary build infrastructure (Gradle wrapper scripts and configuration) and documentation (README) to guide users through configuring their AdMob app ID and running the sample on an Android device or emulator.

admob · high confidence

Introduces a new quickstart application for Firebase App Distribution, providing reference implementations in both Java and Kotlin. The app demonstrates how to integrate the Firebase App Distribution SDK to check for and update to new releases, including handling progress and failure events. It includes a launcher activity to choose between the Java or Kotlin implementation, along with the necessary UI layouts, resources, and instrumented tests to verify the integration.

appdistribution/app · high confidence

Introduces a new Android application sample for Firebase Data Connect. This includes the core UI components (such as review cards, error displays, and loading screens), a Material 3 theme with dark mode support, and the necessary Android manifest and resource files to run the demo.

dataconnect/app · high confidence

This change introduces the Android UI components for the Firebase Data Connect quickstart. The MoviesScreen and MoviesViewModel now fetch and display a list of top-rated and latest movies using the MoviesConnector, while the ActorDetailViewModel retrieves and shows specific actor information by ID. These additions enable users to browse movie listings and view detailed actor profiles within the app.

dataconnect/app/src/main/java/com/google/firebase/example/dataconnect/feature/actordetail, dataconnect/app/src/main/java/com/google/firebase/example/dataconnect/feature/movies · high confidence

Introduces a new quickstart sample for Firebase Data Connect, featuring a movie review app that demonstrates integration with a Cloud SQL for PostgreSQL database. The addition includes the necessary project scaffolding, such as Gradle wrapper scripts, a .gitignore file for generated artifacts, and a firebase.json configuration, along with initial Android navigation code for a search feature.

dataconnect · high confidence

The functions/functions directory now includes a sample implementation using the firebase-functions/v2 API. It provides two callable functions: addNumbers, which sums two numeric inputs, and addMessage, which saves a sanitized message to the Realtime Database and optionally sends an FCM push notification. The addMessage function includes input validation, authentication checks, and content moderation via a sanitizer that replaces swearwords and normalizes shouting.

functions/functions · high confidence

This change introduces a new Java-based quickstart application for Firebase Cloud Functions. The app demonstrates calling callable functions (such as adding numbers and sending messages) and includes a new FunctionsMessagingService to handle incoming FCM messages. It specifically implements Android 13+ (API level 33) notification permission handling using ActivityResultLauncher and creates notification channels for API 26+, ensuring notifications are displayed correctly on modern Android versions.

functions/app/src/main/java/com/google/samples/quickstart/functions/java · high confidence

This change introduces a new Kotlin-based sample application for Cloud Functions. It demonstrates calling callable functions (addNumbers, addMessage) using the modern Firebase SDK initialization (Firebase.functions) and handles remote notifications via Firebase Cloud Messaging, including proper permission checks for Android 13+ and notification channel creation. The UI is implemented using ViewBinding instead of findViewById.

functions/app/src/main/java/com/google/samples/quickstart/functions/kotlin · high confidence

The app now includes a new EntryChoiceActivity that allows users to select between the Java and Kotlin implementations of the Firebase Realtime Database quickstart, routing to the respective MainActivity classes for each language.

database/app/src/main/java/com/google/firebase/quickstart/database · high confidence

The AdMob quickstart sample now includes a complete Kotlin implementation alongside the existing Java version. This new Kotlin sample demonstrates modern Android development practices, including the use of ViewBinding for UI references, the Jetpack Navigation Component for fragment transitions, and Kotlin-specific idioms such as property delegates and lambda listeners. Users can now choose between the Java and Kotlin samples to learn AdMob integration, with the Kotlin version providing a reference for current best practices in the language.

admob/app/src/main/java/com/google/samples/quickstart/admobexample/kotlin · high confidence

The Analytics quickstart now includes a complete Kotlin implementation alongside the existing Java version. Users can choose between the Java or Kotlin sample from the entry screen. The Kotlin version demonstrates modern Android practices, including ViewBinding for UI inflation, ViewPager2 with TabLayoutMediator for image browsing, and the Kotlin-specific Firebase Analytics extension functions (e.g., \analytics\ delegate and \logEvent\ builder) for logging events and user properties.

analytics/app/src/main/java · high confidence

The Performance Monitoring quickstart now includes a Kotlin implementation alongside the existing Java version. A new EntryChoiceActivity allows users to select between the Java and Kotlin samples, while the Kotlin-specific MainActivity demonstrates tracing app startup tasks, file I/O, and network requests using the modern Kotlin SDK (Firebase.performance) and coroutines.

perf/app/src/main/java · high confidence

The app now includes a new sample feature that demonstrates hybrid on-device inference using the Gemini 3.5 Flash-Lite model. This feature allows users to scan receipts to extract store names and prices, with the system automatically preferring on-device processing when the model is available and falling back to the cloud if necessary. The sample includes logic to check model status, handle downloads, and parse the resulting JSON data into expense entries.

firebase-ai/app/src/main/java/com/google/firebase/quickstart/ai/feature/hybrid · high confidence

The Data Connect Android quickstart now includes UI for submitting movie reviews and viewing user profiles. Users can submit a rating (1–10) and text (up to 280 characters) via the new UserReviews screen, which displays existing reviews. The profile area features an AuthScreen for signing up or signing in, and a ProfileScreen that displays the user's favorite movies and their submitted reviews.

dataconnect/app/src/main/java/com/google/firebase/example/dataconnect/feature/moviedetail, dataconnect/app/src/main/java/com/google/firebase/example/dataconnect/feature/profile · high confidence

This change introduces a new Firebase Crashlytics quickstart sample for Android. It includes the necessary build infrastructure, specifically the Gradle wrapper scripts (gradlew and gradlew.bat) and a .gitignore file to exclude build artifacts and sensitive configuration files like google-services.json. The sample also provides a README with setup instructions, screenshots, and support links to help developers integrate Crashlytics into their projects.

crash · high confidence

This change introduces a complete Firebase Data Connect quickstart example for a movie-rating application. It includes the Data Connect configuration (dataconnect.yaml) targeting the v1 spec, a GraphQL schema defining entities like Movie, User, and Review, and connector files (queries.gql, mutations.gql) that implement user authentication, movie listing, and review management. The entry also provides seed data (moviedata\_insert.gql) to populate the database with sample movie records.

dataconnect/dataconnect · high confidence

A new quickstart sample for Firebase In-App Messaging has been added to the inappmessaging directory. This includes a README with instructions for setting up a campaign in the Firebase console and triggering messages via a 'Trigger' button in the app, along with the necessary Gradle wrapper scripts and a .gitignore file to support running the sample.

inappmessaging · high confidence

A new quickstart application for Firebase Performance has been added to the perf directory. This sample demonstrates how to measure the performance of activities in an Android application. The addition includes the necessary project scaffolding, such as a .gitignore file, a README with setup instructions, and the Gradle wrapper scripts (gradlew and gradlew.bat) required to build and run the sample on Android devices or emulators.

perf · high confidence

The config location now includes a README.md explaining how to use Firebase Remote Config to override in-app default values, specifically highlighting the \fetchAndActivate\ method for immediately applying fetched parameter values. Additionally, the Gradle wrapper scripts (gradlew and gradlew.bat) have been added to enable building the sample project.

config · high confidence

A new EntryChoiceActivity has been added to the crash quickstart application, allowing users to select between running the Firebase Crash integration in either Java or Kotlin. This activity serves as the launcher screen, presenting two choices that navigate to the respective Java and Kotlin MainActivity implementations.

crash/app/src/main/java/com/google/samples/quickstart/crash · high confidence

The app now includes a new EntryChoiceActivity that allows users to select between the Java and Kotlin versions of the Firebase Functions quickstart, with the Kotlin option launching the corresponding MainActivity.

functions/app/src/main/java/com/google/samples/quickstart/functions · high confidence

The analytics directory now includes a new Google Analytics for Firebase Quickstart sample application. This addition provides a .gitignore file, a README explaining how to run the sample and view logged events (such as user properties and SELECT\_CONTENT events) in Firebase, and the standard Gradle wrapper scripts (gradlew, gradlew.bat) required to build and run the Android project.

analytics, messaging · high confidence

A new \scripts/checksnippets.py\ tool has been added to automatically verify that Java and Kotlin source files in the \src\ directories have matching snippet region tags. This script ensures that every Java file with snippet markers has a corresponding Kotlin file with identical \\[START\]\ and \\[END\]\ tags, helping maintain consistency between language-specific documentation snippets.

scripts · high confidence

A new Firebase App Distribution quickstart sample has been added to the repository. This includes a README explaining how to use the App Distribution SDK to display in-app alerts to testers for new builds, along with the necessary Gradle wrapper scripts (gradlew, gradlew.bat) and a .gitignore file to support building and running the sample Android application.

appdistribution · high confidence

The Firebase Cloud Messaging quickstart application now includes a Kotlin-based implementation alongside the existing Java version. Users can choose between the two language variants via the new EntryChoiceActivity, which launches either the Java or Kotlin MainActivity depending on selection.

admob/app/src/main/java/com/google/samples/quickstart/admobexample, messaging/app/src/main/java/com/google/firebase/quickstart/fcm · high confidence

The Firestore quickstart application now provides two distinct entry points, allowing users to choose between a Java or a Kotlin implementation of the FireEats sample app. This change introduces an \EntryChoiceActivity\ that routes users to the respective \MainActivity\ for each language. Both implementations have been modernized to use the Android Navigation Component for screen transitions, replacing previous navigation patterns, and utilize ViewBinding for UI interactions. The app structure now clearly separates the language-specific logic into \java\ and \kotlin\ packages, each containing their own activities, fragments, adapters, and view models.

firestore/app/src · high confidence

This change introduces the \database\ directory containing a Firebase Database quickstart application for Android. It includes the project build scripts (Gradle wrapper), a \.gitignore\ file, and a \README.md\ that documents the data model (users, posts, user-posts, post-comments) and the specific Firebase Database security rules required to run the sample.

database, functions · high confidence

This change introduces the initial version of the Cloud Storage for Firebase Quickstart application. It includes the necessary project scaffolding, such as the Gradle wrapper scripts (gradlew, gradlew.bat) for building the Android app, a .gitignore file to exclude build artifacts and sensitive service account keys, and a README.md providing setup instructions and screenshots. The app is configured to use anonymous authentication for Firebase.

storage · high confidence

Adds the Firestore Quickstart sample application, a restaurant recommendation app named Friendly Eats. This entry includes the necessary configuration files for the Android build (Gradle wrapper, gitignore), the application's security rules for Firestore, and an index specification file to support compound queries. It also provides a test setup script to initialize the development environment by clearing the restaurants collection and importing test user accounts.

firestore · high confidence

This change introduces the complete Firebase Authentication Quickstart sample for Android, providing a reference implementation for integrating various sign-in methods. The included application and documentation demonstrate setup and usage for Google Sign-In, Facebook Login, Email/Password, Passwordless (Email Link), Phone Authentication, and Custom Authentication (via a web-based token generator). It also supports Generic OAuth providers such as Microsoft, Apple, Yahoo, and Twitter, as well as Multi-Factor Authentication (noting that MFA requires Google Cloud Identity Platform). The entry includes the necessary Gradle build scripts, a .gitignore file, and the web-based custom token generator interface.

auth · high confidence

The repository is initialized with the foundational structure for the Firebase Android Quickstarts. This includes a README listing available samples (such as Admob, Analytics, Auth, Crashlytics, and Data Connect), a CONTRIBUTING guide, and an Apache 2.0 license. Build infrastructure is established via Gradle wrapper scripts (gradlew, gradlew.bat) and a \.editorconfig\ enforcing a 120-character line length. To support local development and CI without real credentials, a \mock-google-services.json\ file is provided, along with shell scripts (\build\_pull\_request.sh\, \copy\_mock\_google\_services\_json.sh\) to automate mock configuration and selective module builds.

(repo-wide) · high confidence

Adds a new Firebase AI Quickstart sample app that demonstrates various AI capabilities through a unified navigation interface. The app includes screens for text chat, SVG generation, server-side prompt templates, bidirectional audio/video streaming, and hybrid on-device inference, along with a camera view component for real-time frame capture.

firebase-ai/app · high confidence

The inappmessaging/app/src location now provides a complete quickstart application for Firebase In-App Messaging (FIAM). This includes an EntryChoiceActivity that lets users select between a Java or Kotlin implementation, both of which demonstrate core FIAM features such as automatic data collection, message suppression control, and triggering analytics events to display in-app messages. The app also displays the Firebase Installation ID and includes instrumented tests to verify that campaigns display correctly on foreground and contextual triggers.

inappmessaging/app/src · high confidence

The Crashlytics quickstart now includes Kotlin versions of the main activity and custom key samples alongside the existing Java code. This provides developers with idiomatic Kotlin examples for setting custom keys, tracking network state, and reporting non-fatal exceptions using the modern Firebase BoM initialization pattern (Firebase.crashlytics).

crash/app/src/main/java/com/google/samples/quickstart/crash/kotlin · high confidence

A new Kotlin-based Firebase Remote Config quickstart is now available, allowing users to run the sample in Kotlin alongside the existing Java version. The implementation uses ViewBinding for UI handling and the modern Firebase BoM APIs (such as \Firebase.remoteConfig\ and \fetchAndActivate\) to fetch and activate remote configuration values, including a welcome message that can be toggled to uppercase.

config/app/src/main/java/com/google/samples/quickstart/config/kotlin · high confidence

A new Android sample application has been added to demonstrate Firebase AI Logic capabilities. The app includes a comprehensive set of features such as text translation, SVG generation, image creation and editing using Nano Banana models, multimodal understanding (audio/video summarization), function calling, live API streaming, and hybrid inference. It also provides examples for the Agent Platform and server prompt templates, along with the necessary project scaffolding like .gitignore and Gradle wrapper scripts.

firebase-ai · high confidence

The Firebase AI quickstart app now includes a comprehensive set of new sample ViewModels in the text feature area, demonstrating the capabilities of the Gemini 3.5 Flash-Lite and Nano Banana image models. These samples cover diverse use cases including audio summarization and translation, video summarization and hashtag generation, document comparison, and image blog creation. The update also introduces samples for function calling (with both manual and auto-declaration patterns), Google Search grounding, server-side prompt templates, and system instruction-based chatbots. All samples utilize the \ChatViewModel\ base class for consistent UI state management and message handling.

firebase-ai/app/src/main/java/com/google/firebase/quickstart/ai/feature/text · high confidence

Added a new Data Connect quickstart sample application that demonstrates integrating Firebase Data Connect with a modern Android UI built using Jetpack Compose. The app features a movie catalog with navigation between movie details, actor profiles, and user profiles, utilizing Data Connect for data retrieval and mutations (such as adding reviews and toggling favorites). It includes full authentication flows via Firebase Auth and implements a clean architecture with ViewModels and UI state management.

app · high confidence

The Live AI quickstart app now includes dedicated ViewModels for bidirectional streaming scenarios. A new BidiViewModel base class provides shared logic for starting/stopping audio conversations and sending video frames. Two concrete implementations are added: StreamAudioViewModel, which connects to the gemini-2.5-flash-native-audio-preview-09-2025 model with audio response modality and integrates a weather function-calling tool, and StreamVideoViewModel, which connects to the same model for video input with audio responses. These changes enable users to explore real-time, two-way interactions involving both audio and video within the sample app.

firebase-ai/app/src/main/java/com/google/firebase/quickstart/ai/feature/live · high confidence

The functions sample app now includes ProGuard configuration files to support release builds. The main proguard-rules.pro file preserves inner classes and enclosing methods, and suppresses warnings for FirebaseUI Auth to prevent build failures. A separate test-proguard-rules.pro file disables obfuscation and suppresses warnings for the org.xmlpull package during testing.

functions/app · high confidence

A new ProGuard rules file has been added to the app configuration to manage code shrinking and obfuscation. The file includes standard comments explaining how to customize the rules and explicitly preserves the EnclosingMethod and InnerClasses attributes, which are necessary for maintaining correct class structure during the build process.

config/app · high confidence

The auth/app module now includes a proguard-rules.pro file to configure code shrinking and obfuscation. This configuration preserves essential annotations and class structures required for the application's functionality and specifically includes rules to suppress warnings and keep classes related to Twitter Authentication (including dependencies like OkHttp, Retrofit, and RxJava), ensuring the login feature operates correctly after minification.

auth/app · high confidence

The storage/app module now includes a proguard-rules.pro file to configure code shrinking and obfuscation. This file preserves specific Java attributes (Signature, Annotations, EnclosingMethod, InnerClasses) and is designed to append to the default Android SDK ProGuard rules, ensuring that critical metadata and class structures are retained during the build process.

storage/app · high confidence

The Crash quickstart application now includes dedicated ProGuard rules to manage code shrinking and obfuscation. These rules preserve inner classes and enclosing methods, and specifically prevent warnings or errors related to the org.xmlpull package by keeping its classes and members intact. A separate test configuration is also provided to disable obfuscation and warnings during testing.

crash/app · high confidence

The AdMob quickstart app now includes a dedicated proguard-rules.pro file to configure code shrinking and obfuscation. This file appends specific keep rules, such as preserving EnclosingMethod and InnerClasses attributes, to the default Android ProGuard configuration, helping to reduce warnings and optimize the final build output.

admob/app, analytics/app · high confidence

The app now includes a proguard-rules.pro file that explicitly keeps all classes in the viewholder package and all class members in the Java and Kotlin models packages. This ensures that these components are not obfuscated or removed during release builds, preventing runtime crashes related to missing classes or fields.

database/app · high confidence

The app now includes dedicated ProGuard configuration files (proguard-rules.pro and test-proguard-rules.pro) to ensure correct behavior in release builds. These rules preserve custom model classes for both Java and Kotlin implementations, suppress warnings for Okio and Retrofit dependencies, and maintain necessary classes for Firebase Auth and RecyclerView, addressing issues arising from the Java/Kotlin code split.

firestore/app · high confidence

The internal linting infrastructure now includes two new detectors to enforce code quality in Kotlin files. The \InvalidImportDetector\ flags imports from the \java\ package when used within a \kotlin\ package, helping to prevent accidental collisions between Java and Kotlin standard library classes. The \HungarianNotationDetector\ reports an error when fields in Kotlin files use Hungarian notation (identifiers starting with 'm' followed by a capital letter), encouraging consistent naming conventions. These checks are registered in the \QuickstartIssueRegistry\ and apply to Java file scopes.

internal · high confidence

The Firebase Auth quickstart application has been restructured to provide distinct, parallel implementations for authentication flows in both Java and Kotlin. Users can now choose between the Java or Kotlin version from a new EntryChoiceActivity launcher screen. This change includes a complete rewrite of the Java-side UI components to use ViewBinding and Jetpack Navigation, while the Kotlin side mirrors these capabilities. The app also introduces passwordless sign-in support and updates the Google Sign-In flow to use Google Identity Services via Credential Manager.

auth/app/src · high confidence

The Java implementation of the Firebase Database quickstart has been refactored to use AndroidX Navigation Component for screen transitions and View Binding for UI access. This change replaces the previous navigation and view-inflation mechanisms, resulting in a more modern and type-safe codebase for the app's fragments and activities.

database/app/src/main/java/com/google/firebase/quickstart/database/java · high confidence

The Database quickstart application has been fully converted from Java to Kotlin. This update introduces ViewBinding for type-safe view access across all fragments and activities, replacing manual findViewById calls. It also adopts the Jetpack Navigation Component for managing app flow and fragment transitions, and utilizes ViewPager2 for the main content tabs. These changes modernize the codebase while maintaining the existing user experience for signing in, posting, and browsing database entries.

database/app/src/main/java/com/google/firebase/quickstart/database/kotlin · high confidence

The FCM Quickstart sample has been rewritten in Kotlin and updated to use the new FCM v1 registration API. The main activity now uses the \Firebase.messaging.register()\ method to obtain the Firebase Installation ID (FID) instead of legacy token-based registration, and the \MyFirebaseMessagingService\ implements the new \onRegistered\ and \onUnregistered\ callbacks to handle FID lifecycle events. The app also adds support for Android 13 (API level 33) by requesting the \POST\_NOTIFICATIONS\ permission at runtime and creates notification channels for Android 8.0+, while retaining WorkManager for handling long-running background tasks.

messaging/app/src/main/java/com/google/firebase/quickstart/fcm/kotlin · high confidence

The Java FCM quickstart sample has been updated to use the new FirebaseMessaging.getInstance().register() method for obtaining registration tokens, replacing previous approaches. It also implements ViewBinding for the main layout and adds explicit handling for the POST\_NOTIFICATIONS permission required on Android 13 (API level 33) to ensure notifications can be posted. Additionally, the sample now includes a WorkManager worker class (MyWorker) to demonstrate background task execution.

messaging/app/src/main/java/com/google/firebase/quickstart/fcm/java · high confidence

The Database Quickstart now uses dedicated Kotlin ViewHolders (CommentViewHolder and PostViewHolder) to render list items. CommentViewHolder binds author and text fields, while PostViewHolder handles post title, author, star count, body, and a star toggle button with state management. This replaces previous view-binding approaches with explicit findViewById calls in Kotlin, improving type safety and maintainability for the list UI.

database/app/src/main/java/com/google/firebase/quickstart/database/kotlin/viewholder · high confidence

The Java quickstart sample for Firebase Remote Config has been updated to use the modern \fetchAndActivate\ API, which combines fetching and activating config values into a single call, and now utilizes ViewBinding for UI interactions instead of \findViewById\.

config/app/src/main/java/com/google/samples/quickstart/config/java · high confidence

The internal chooser module has been updated to use AndroidX libraries and Material Components, replacing legacy support library dependencies. This includes migrating the base activity to extend AppCompatActivity, implementing the choice list UI with RecyclerView and MaterialCardView, and updating layout resources to use AndroidX constraint layouts and Material button styles.

internal/chooserx · high confidence

The internal linting tool now includes two new checks to enforce Kotlin best practices. It flags the use of Hungarian notation (e.g., \mVariableName\) in Kotlin files as an error, and it detects accidental imports from the \java\ package when writing Kotlin code, which often indicates a naming collision with the standard \java.\*\ library. These rules are registered in the \QuickstartIssueRegistry\ and are supported by corresponding unit tests.

internal/lint · high confidence

The Firebase Storage quickstart app now provides distinct entry points for Java and Kotlin, allowing users to choose which language sample to run. A new EntryChoiceActivity presents a menu to launch either the Java or Kotlin version. The Java implementation uses the standard Firebase SDK with explicit class references, while the Kotlin version utilizes the new Firebase KTX libraries (e.g., Firebase.auth, Firebase.storage) and Kotlin-specific features like destructuring declarations for task snapshots. Both implementations share a common base service for notification management but are implemented separately to demonstrate language-specific best practices.

storage/app/src/main/java · high confidence

The messaging app now includes a dedicated proguard-rules.pro file that explicitly preserves EnclosingMethod and InnerClasses attributes. This change ensures that these specific Java/Kotlin class structures are not stripped or obfuscated during the release build process, which can help prevent runtime issues related to reflection or inner class access in the final APK.

messaging/app · high confidence

Added Android UI tests for the Functions Quickstart app; Added Espresso UI tests for the Storage quickstart sample; Added Espresso test for crash-triggering UI interaction; Added UI tests for FCM quickstart activity; Added UI tests for the Analytics Quickstart activity; Added instrumentation test for Remote Config fetch flow.

The perf module now includes a dedicated Gradle wrapper configuration, establishing a specific build environment for this location. The diff introduces a new \gradle-wrapper.properties\ file that pins the Gradle distribution to version 9.7.1, ensuring consistent builds for the performance testing application. Additionally, a \.gitignore\ file is added to exclude build artifacts, and a \proguard-rules.pro\ file is included to allow for project-specific code shrinking and obfuscation rules, supporting the module's build and release processes.

perf/gradle · high confidence

The Firebase AI quickstart project has been configured to use Gradle 9.7.1 via the wrapper, ensuring consistent build environments across development and CI. This change updates the underlying build tool version to align with the recent Android Gradle Plugin upgrade to 9.0.0 mentioned in the commit history, though the diff specifically confirms the Gradle distribution version change.

firebase-ai/gradle · high confidence

The Gradle wrapper configuration in the messaging module has been updated to use Gradle version 9.7.1. This ensures that builds for this module will consistently use this specific Gradle distribution, potentially bringing new features, performance improvements, or compatibility changes associated with this version.

(repo-wide) · high confidence

The Gradle wrapper configuration has been updated to use Gradle 9.7.1. This ensures that builds for the Data Connect module will consistently use this specific version of the Gradle build tool, aligning with the broader project upgrade to the Gradle 9.x series.

dataconnect/gradle · high confidence

This update introduces a suite of new Android quickstart applications demonstrating core Firebase services. The AdMob sample integrates the AdMob SDK (25.4.0) with Firebase Analytics and uses the Firebase BoM (34.19.0). Analytics, Config, and Crash samples showcase their respective SDKs, with Crash also integrating the Crashlytics plugin. The Auth sample demonstrates authentication flows using Firebase UI (9.1.1), Google Identity Services, and the Facebook Login SDK. Database and Firestore samples illustrate data persistence with FirebaseUI (9.1.1) and standard SDKs. Data Connect and Firebase AI samples utilize Kotlin Multiplatform/Compose patterns, with Firebase AI leveraging the Firebase AI SDK and CameraX. Functions and App Distribution samples demonstrate cloud functions and beta distribution workflows. All samples are configured with compileSdk 37, minSdk 24, and Java 17 (or 11 for Compose-based samples), and share common internal linting and build configurations.

(dependencies) · high confidence

The Gradle wrapper configuration in the auth module has been updated to use Gradle 9.7.1. This ensures that builds for this module will consistently use this specific Gradle distribution, aligning with the broader project upgrades to Gradle 9.0.0 and AGP 9.0.0 mentioned in recent commits.

auth/gradle, functions/gradle · high confidence

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

• CAI 45 → 41 (-3.4)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 99 (-0.4)
• Architecture 96 → 96 (+0.3)
• Maturity 47 → 52 (+5.0)
• Readiness 22 → 21 (-1.1)
• Security 71 → 70 (-0.8)
• Accessibility 49 (new)

• Coverage not measured — test suite did not build
• Critical CVE: [GHSA redacted] (functions/functions/package-lock.json)
• Dimension evaluation failed
• Duplicated block (15 lines × 2) (auth/app/src/main/java/com/google/firebase/quickstart/auth/kotlin/EmailPasswordFragment.kt)
• Duplicated block (17 lines × 2) (database/app/src/main/java/com/google/firebase/quickstart/database/kotlin/SignInFragment.kt)
• High CVE: [GHSA redacted] (functions/functions/package-lock.json)
• High CVE: [GHSA redacted] (functions/functions/package-lock.json)
• High CVE: [GHSA redacted] (functions/functions/package-lock.json)
• Low CVE: [GHSA redacted] (functions/functions/package-lock.json)
• Medium CVE: [GHSA redacted] (functions/functions/package-lock.json)
• Medium CVE: [GHSA redacted] (functions/functions/package-lock.json)
• Medium CVE: [GHSA redacted] (functions/functions/package-lock.json)
• Medium CVE: [GHSA redacted] (functions/functions/package-lock.json)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• …and 14 more

• Critical CVE: [GHSA redacted] (functions/functions/package-lock.json)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (auth/app/src/main/java/com/google/firebase/quickstart/auth/kotlin/FirebaseUIFragment.kt)
• Duplicated block (13 lines × 3) (functions/app/src/main/java/com/google/samples/quickstart/functions/kotlin/MainActivity.kt)
• Duplicated block (16 lines × 2) (dataconnect/app/src/main/java/com/google/firebase/example/dataconnect/ui/theme/Theme.kt)
• Duplicated block (17 lines × 2) (firebase-ai/app/src/main/java/com/google/firebase/quickstart/ai/ui/ServerPromptScreen.kt)
• Duplicated block (20 lines × 2) (auth/app/src/main/java/com/google/firebase/quickstart/auth/kotlin/AnonymousAuthFragment.kt)
• Duplicated block (6 lines × 2) (admob/app/src/main/java/com/google/samples/quickstart/admobexample/kotlin/MainActivity.kt)
• Further sole-owners (lower concentration)
• High CVE: [GHSA redacted] (functions/functions/package-lock.json)
• High CVE: [GHSA redacted] (functions/functions/package-lock.json)
• Leaked secret: high-entropy-secret (firestore/accounts.json)
• Low CVE: [GHSA redacted] (functions/functions/package-lock.json)
• Medium CVE: [GHSA redacted] (functions/functions/package-lock.json)
• Medium CVE: [GHSA redacted] (functions/functions/package-lock.json)
• Medium CVE: [GHSA redacted] (functions/functions/package-lock.json)
• Medium CVE: [GHSA redacted] (functions/functions/package-lock.json)
• Medium CVE: [GHSA redacted] (functions/functions/package-lock.json)
• Medium: security finding (details withheld)
• …and 21 more

• 14 commits — 13 feature/other, 1 fixes

• gradle/libs.versions.toml — 5 commits
• (root) — 3 commits
• firebase-ai/app — 3 commits
• admob/app — 2 commits
• admob/gradle — 1 commit

• fix: revert the AGP version pin (#2835)
• change: Auto-update dependencies.
• change: Auto-update dependencies. (#2826)
• change: Auto-update dependencies. (#2829)
• change: Auto-update dependencies. (#2833)
• change: Auto-update dependencies. (#2837)
• change: Auto-update dependencies. (#2839)
• change: Auto-update dependencies. (#2841)
• change: Auto-update dependencies. (#2842)
• change: Auto-update dependencies. (#2843)
• change: Use Agent Platform (#2830)
• change: chore: pin ktlint version
• change: refactor(firebase-ai): use Gemini 3.7 Flash instead of 3.6 Flash (#2831)
• change: refactor(firebase-ai): use Gemini 3.8 Flash for SVG generation (#2840)

• Containers 0 added · 0 removed · contexts 1 added · 0 removed · edges 0 added · 0 removed

• app

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

firebase/quickstart-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.