Skip to content
CAI
Software that uses CAICheck a score

duckduckgo/Android

52.4

Adequate · 13 November 2026

455.5k

lines of production code

Kotlin

primary language

6

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

The AMP links feature has been implemented to detect and handle Accelerated Mobile Pages (AMP) links. This includes extracting canonical URLs from AMP links, identifying cloaked AMP links via keywords, and validating destination URLs. The feature supports configuration through remote settings, allowing for customizable link formats and keywords, and respects user allowlists and exceptions.

privacy-config/privacy-config-impl/src/main/java/com/duckduckgo/privacy/config/impl/features/amplinks · high confidence

Ad-click module dependency injection setup

The ad-click implementation now includes a Dagger module that configures the necessary dependencies for ad attribution and exemption tracking. This setup provides the Room databases for storing ad click data and exemptions, along with the repositories and data classes that manage these records, ensuring they are scoped to the application lifecycle and initialized only in the main process.

ad-click/ad-click-impl/src/main/java/com/duckduckgo/adclick/impl/di · high confidence

Add DRM exception support to privacy config store

This change introduces a new data layer for managing DRM (Digital Rights Management) exceptions within the privacy configuration system. It adds a Room-based DAO (DrmDao) and a repository (RealDrmRepository) that persists DRM exception entities to a local database and loads them into memory. The repository is designed to load these exceptions only in the main process and keeps an in-memory list of FeatureExceptions, allowing the application to handle DRM-related privacy rules defined in the remote config.

privacy-config/privacy-config-store/src/main/java/com/duckduckgo/privacy/config/store/features/drm · high confidence

Add DaxMessage composable for consistent messaging UI

The design system now includes a new \DaxMessage\ composable that serves as the shared primitive for rendering message cards. This component standardizes the appearance of banners, notify views, and remote messages by providing a card layout with a title, body, optional top content slot, and a restricted set of action row variants (right-aligned, center-aligned, full-width single, or small single). It also supports optional dismiss controls, ensuring visual consistency across all message-related interfaces in the app.

design-system · high confidence

Add Mac waitlist screen with share and Windows redirect options

The Android app now includes a Mac waitlist screen that allows users to join the Mac waitlist by sharing a download link and optionally includes an origin parameter for tracking. Users can also navigate to the Windows client settings from this screen. The feature includes translations in multiple languages and tracks user interactions via pixels.

macos/macos-impl · high confidence

Add Message Bridge and Navigator Interface feature support

This change introduces the implementation for the Message Bridge and Navigator Interface features within the content-scope-scripts module. It adds dedicated plugins that register these features with the ContentScope configuration system and the Privacy Feature store. Each feature includes its own local Room database, repository, and dependency-injection module to persist and serve configuration data, enabling the application to store and retrieve specific settings for these capabilities.

content-scope-scripts/content-scope-scripts-impl/src/main/java/com/duckduckgo/contentscopescripts/impl/features/messagebridge, content-scope-scripts/content-scope-scripts-impl/src/main/java/com/duckduckgo/contentscopescripts/impl/features/navigatorinterface · high confidence

Add detectorPerf and browserUiLock content scope privacy features

The implementation module now registers two new content scope privacy features: \detectorPerf\ and \browserUiLock\. These are defined as interfaces annotated with \@ContentScopePrivacyFeature\, linking them to their respective names in the remote privacy configuration.

content-scope-privacy-features/content-scope-privacy-features-impl · high confidence

Add internal Theme Preview feature to the design system

An internal feature plugin has been added to the Android design system that exposes a Theme Preview option. When selected, this feature launches the AppComponentsActivity, allowing users to view and interact with the design system's theme components and demos directly within the app.

android-design-system/design-system-internal/src/main/java/com/duckduckgo/common/ui/internal · high confidence

Add internal design-system button showcase fragments

The design-system internal module now includes dedicated showcase fragments for button and interactive component variants. ComponentButtonsFragment renders a comprehensive set of DaxButton styles (Primary, Secondary, Destructive, Ghost, and Icon buttons) in both small and large sizes, with support for leading icons, disabled states, and brand-design spacing adjustments. ComponentInteractiveElementsFragment registers related interactive components (Switch, RadioButton, Checkbox, Slider, SearchBar) for display in the internal design-system viewer.

android-design-system/design-system-internal/src/main/java/com/duckduckgo/common/ui/internal/ui/component/buttons · high confidence

Add internal system app exclusion list UI

An internal settings screen has been added that allows users to view and toggle the exclusion status of system applications for Network Protection. The new NetPSystemAppsExclusionListActivity lists all installed system apps and lets users enable or disable them in the exclusion list, with changes automatically triggering a restart of the Network Protection service. The implementation uses a safe method to retrieve the application list to prevent potential crashes when many apps are installed and supports edge-to-edge display.

_network-protection/network-protection-internal/src/main/java/com/duckduckgo/networkprotection/internal/feature/system\apps · high confidence

Add local storage for web compatibility data

This change introduces a new local persistence layer for web compatibility settings within the app. It adds a Room database schema (WebCompatDatabase) and a corresponding DAO (WebCompatDao) to store a single JSON configuration entity in a 'web\_compat' table. A repository (RealWebCompatRepository) manages this data, loading the configuration into memory on initialization and providing methods to update and retrieve the stored JSON payload, ensuring the app can maintain web compatibility preferences locally.

web-compat/web-compat-store · high confidence

Add runtime checks module implementation

This change introduces the implementation for the new runtime checks feature. It adds a \RuntimeChecksFeaturePlugin\ to store privacy configuration data into a local Room database and a \RuntimeChecksContentScopeConfigPlugin\ to expose that stored configuration to the content scope scripts. The module includes the necessary dependency injection bindings and unit tests to verify the storage and configuration retrieval logic.

runtime-checks/runtime-checks-impl · high confidence

Added DialogsFragment showcase for Android design system components

A new DialogsFragment has been added to the internal design system module to serve as a comprehensive showcase and testing ground for various dialog and bottom-sheet UI components. This fragment demonstrates the integration of both legacy View-based dialogs (such as TextAlertDialogBuilder and RadioListAlertDialogBuilder) and new Jetpack Compose-based components (including DaxAlertDialog, DaxTextAlertDialog, DaxRadioOptions, and various bottom sheets like DaxActionBottomSheetDialog). It allows developers and designers to preview and verify the behavior of these interactive elements, including button states, radio selections, and dismiss actions, within the app's theming system.

android-design-system/design-system-internal/src/main/java/com/duckduckgo/common/ui/internal/ui/dialogs · high confidence

Added HTTPS upgrade store with Room database for Bloom filter specs and false positives

This change introduces a new local storage layer for the HTTPS upgrade feature, implemented using Android Room. It adds database entities and DAOs to persist Bloom filter specifications (including bit count, error rate, and SHA-256 hash) and lists of false-positive domains. The store supports inserting, replacing, querying, and clearing these records, with corresponding unit tests verifying the data access operations.

httpsupgrade/httpsupgrade-store · high confidence

Added Maestro performance benchmarking flows for page load metrics

New Maestro test flows have been added to the \.maestro/performance\ directory to benchmark cold and warm page load performance. These flows automate the process of loading a predefined list of websites (including foxnews.com, stackoverflow.com, etc.) multiple times, measuring metrics for both cold starts (clearing app state and HTTP cache) and warm loads (reusing the HTTP cache). This enables the collection of stable performance distributions for these specific page load scenarios.

.maestro/performance · high confidence

Added VPN service heartbeat monitoring

A new VpnServiceHeartbeat component has been introduced to the VPN implementation to track the status of the VPN connection. This service periodically sends heartbeat signals to the local database every 7 minutes while the VPN is active and records a final 'stopped' status upon normal shutdown, revocation, or restart, ensuring accurate state logging for the App Tracking Protection feature.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/heartbeat · high confidence

Added breakage reporting database entity

A new Room entity, BreakageReportingEntity, has been introduced to persist breakage reporting data. It stores a primary key ID and a JSON string field, providing the underlying storage structure for the breakage reporting feature.

breakage-reporting-impl · high confidence

Added data store support for Network Protection geoswitching, exclusion lists, and egress servers

This change introduces the local data storage layer for Network Protection features. It adds a repository for managing user-preferred geoswitching locations and available server locations, database entities for tracking manually excluded apps and auto-excluded incompatible apps, and storage for remote configuration toggles and egress server details (including public keys, hostnames, and selected server state).

network-protection-store · high confidence

Added database entity for runtime checks storage

A new Room entity, RuntimeChecksEntity, has been introduced to persist runtime check data. This entity defines a 'runtime\_checks' table with a single-row primary key (id) and a JSON string field to store the check configuration, establishing the local storage foundation for this feature.

runtime-checks-store · high confidence

Added database entity for tracking blocked web trackers

A new Room database entity, WebTrackerBlocked, has been introduced to store records of web trackers that have been blocked. This entity captures the tracker's URL, the associated company, and a timestamp of when the block occurred, providing the underlying data structure for the App Tracking Protection feature.

app-store · high confidence

Added debug receiver to clear tracked data

A new debug receiver has been added to the App Tracking Protection module, allowing developers to manually delete all previously seen trackers via an ADB command. This feature is intended for internal testing and debugging purposes, enabling quick resets of tracker state without needing to reinstall the app or clear all app data.

app-tracking-protection/vpn-internal/src/main/java/com/duckduckgo/vpn/internal/feature/trackers · high confidence

Added download entity model for local storage

A new DownloadEntity data class has been introduced in the downloads-store module to represent download records in the local database. This entity defines the schema for the 'downloads' table, including fields for the download ID, status, file name, content length, file path, and creation timestamp, serving as the foundational data model for the downloads feature.

downloads-store · high confidence

Added internal component showcase for DaxTextField

An internal demonstration fragment has been added to the design system to showcase the new DaxTextField Compose component. This file provides a visual and interactive reference for various text input states, including single-line, multi-line, and form-mode configurations, as well as error handling and end-icon actions, allowing developers to preview the component's behavior within the app's theme.

android-design-system/design-system-internal/src/main/java/com/duckduckgo/common/ui/internal/ui/component/textinput · high confidence

Added internal developer settings for Duck.ai URL and usage warnings

Internal developer settings have been added to the Duck.ai chat interface, allowing developers to configure a custom Duck.ai host URL and manage usage-limit warning states. The new settings include a screen to set or reset the custom URL (triggering an app restart) and a debug screen to view and reset dismissal records for high-usage model notices and usage limit warnings. Also in this area: Migration of codegen annotations and processors from Anvil to KSP.

duckchat-internal · high confidence

Added internal settings screen with edge-to-edge support

A new internal settings activity (RMFInternalSettingsActivity) has been added to the remote-messaging-internal module. This screen implements edge-to-edge display behavior using the common EdgeToEdgeHandler and dynamically populates its content by aggregating views from registered RmfSettingPlugin instances, providing a plugin-based interface for internal configuration.

remote-messaging-internal · high confidence

Added internal typography preview fragment

An internal TypographyFragment has been added to the design system to display and verify the appearance of various text styles (such as Title, H1-H5, Body1/2, and Button) in both light and dark themes. This component serves as a visual reference for developers to check how the new typography definitions render within the app.

android-design-system/design-system-internal/src/main/java/com/duckduckgo/common/ui/internal/ui/typography · high confidence

Added internal unsafe Wi-Fi detection feature

Users with Android 12 (API level 31) or higher will now see a new toggle in the Network Protection settings to enable or disable unsafe Wi-Fi detection. This internal feature introduces a network observer that monitors Wi-Fi connectivity status and a corresponding settings view that allows users to control the detection capability, which is gated by the OS version.

network-protection-internal · high confidence

Added local storage for element-hiding rules

A new Room database entity, ElementHidingEntity, has been introduced to persist element-hiding configuration locally. This entity stores the hiding rules as a JSON string within the 'element\_hiding' table, providing the underlying data layer for the feature.

element-hiding-store · high confidence

Added local storage for web compatibility data

A new database entity, WebCompatEntity, has been introduced to persist web compatibility information locally using Room. This entity stores a JSON string representation of compatibility data in a table named 'web\_compat', providing the foundational storage layer for the web compatibility feature.

web-compat-store · high confidence

Added storage and parsing for full installer package IDs

The installation module now includes a new data store and JSON parser to track and persist the full package IDs of installers. This implementation introduces \InstallSourceFullPackageStore\ to manage the list of included packages via Android DataStore and \InstallSourceFullPackageListJsonParser\ to deserialize the package list from JSON, supporting the feature flag for sending full installer package IDs.

installation-impl · high confidence

Always-On Lockdown mode now displays a dedicated notification

Users on Android devices with Always-On VPN Lockdown enabled will now see a persistent notification in the status bar. This notification, managed by the new AlwaysOnLockDownDetector, dynamically updates its text and action intent based on whether App Tracking Protection and Network Protection are active, providing a direct way to manage these settings from the notification itself.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/ui/alwayson · high confidence

App Tracking Protection VPN feature management and analytics

The VPN implementation now includes a dedicated registry for App Tracking Protection features, allowing features to be registered, unregistered, and snoozed with automatic VPN service restarts. A new pixel sender tracks the percentage of unprotected apps to bucket and report retention metrics, while a broadcast receiver ensures the VPN process restarts after app updates.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn · high confidence

App Tracking Protection adds CPU monitoring and connectivity health checks

The App Tracking Protection module now includes built-in health monitoring for the VPN process. A new CPU monitor periodically measures the VPN process's CPU usage and sends alerts when usage exceeds defined thresholds (30%, 20%, 10%, or 5%). Additionally, a network connectivity health handler actively probes the VPN and device network paths every 15 seconds to detect connectivity loss, reporting errors via pixels and notifying listeners when the VPN or device network becomes unreachable.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/health · high confidence

App Tracking Protection blocklist updates are now scheduled periodically

The App Tracking Protection module now includes a background worker that automatically downloads and applies app tracker blocklist updates every 12 hours. This new implementation introduces a dedicated downloader service, a database update worker with retry logic, and a lifecycle-based scheduler to ensure the blocklist remains current without manual intervention.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/blocklist · high confidence

App Tracking Protection cohort assignment and pixel tracking

App Tracking Protection now assigns a user cohort when the VPN feature is enabled or reconfigured, storing the assignment date in shared preferences. This cohort is automatically attached to App Tracking Protection analytics pixels via a new interceptor, allowing for time-based segmentation (weekly, monthly, quarterly, half-yearly, or single-year) of usage data, while specific internal and experimental pixels are excluded from this parameter.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/cohort · high confidence

App Tracking Protection core logic and connectivity handling

This change introduces the core implementation for the App Tracking Protection feature within the VPN module. It adds a new connectivity loss listener that automatically restarts or stops App Tracking Protection if VPN connectivity is lost multiple times, controlled by a remote feature flag. It also implements the App Tracker Detector to identify and block third-party trackers based on exclusion lists and user settings, and provides the matching attribute logic to integrate App Tracking Protection onboarding status with the remote messaging system for targeted user guidance.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/app · high confidence

App Tracking Protection now displays Privacy Pro upsell banners and messages

Users will now see targeted Privacy Pro subscription offers within the App Tracking Protection interface. This change introduces a new plugin-based message system that displays a Privacy Pro upsell banner when the VPN is enabled, and specific upsell messages when the VPN is disabled by the system, revoked, or stopped by the user. The content of these messages can be updated remotely, and a new feature toggle allows for A/B testing of free-trial-specific copy.

_app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/ui/tracker\activity/view/message · high confidence

App Tracking Protection onboarding state now drives remote messaging targeting

The VPN implementation now exposes the App Tracking Protection onboarding status as a remote messaging matching attribute. A new \AppTPRMFMatchingAttribute\ plugin evaluates the \atpOnboarded\ key by checking \AppTrackingProtection.isOnboarded()\, allowing remote message campaigns to target users based on whether they have completed the App Tracking Protection onboarding flow.

vpn-impl · high confidence

The Autoconsent feature is now available to automatically handle cookie consent pop-ups on websites. This implementation introduces a new API and backend module that injects JavaScript into web views to detect and manage consent dialogs. Users benefit from an improved browsing experience as the app can automatically opt out of tracking or accept necessary cookies based on user preferences and remote configuration. The feature includes settings to enable or disable autoconsent, manage click-accept behaviors, and view detailed results of consent actions, including handling cosmetic pop-ups and detecting reload loops.

autoconsent/autoconsent-impl · high confidence

Autofill implementation module and service registration

The autofill-impl module is now fully registered with its own AndroidManifest, declaring the AutofillService and several new activities including ImportPasswordsActivity, EmailProtectionInContextSignupActivity, and the Google Passwords/Bookmarks import web flows. The implementation introduces a capability-checking system that gates credential injection, saving, and password generation on secure storage availability, user configuration, and feature flags, while also adding a dialog suppressor to prevent fireproof prompts from overlapping with autofill interactions.

autofill/autofill-impl · high confidence

Automated boilerplate generation for Content Scope privacy features

A new KSP (Kotlin Symbol Processing) processor has been added to automatically generate the repository, plugin, and configuration plugin classes required for Content Scope privacy features. By annotating an interface with @ContentScopePrivacyFeature, developers can now have the build system generate the necessary boilerplate code for storing and retrieving feature configuration data, reducing manual implementation effort.

content-scope-privacy-features/content-scope-privacy-features-ksp · high confidence

Automated code formatting and linting on commit

A new pre-commit hook has been added to automatically enforce code quality standards before changes are committed. When a commit is made, the hook runs Spotless to format Kotlin code via Gradle and executes an npm lint fix within the PixelDefinitions directory to resolve schema lint issues, ensuring consistent code style and fixing minor errors automatically.

.githooks · high confidence

Automatic App Tracking Protection removal after VPN disable

The App Tracking Protection feature now automatically removes itself if the VPN is disabled by the user for seven days. This is implemented via a new state listener that schedules a background worker when the VPN stops manually; the worker then clears all VPN trackers, cancels related notifications and reminders, and resets the onboarding state, while re-enabling the feature if the VPN is started again.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/feature/removal · high confidence

Automatic fireproofing for login detection

The app now automatically detects login pages and prompts users to 'fireproof' sites to prevent the browser from clearing their session data. This feature introduces a new login detection system that identifies login forms via JavaScript injection and URL patterns (including OAuth, SSO, and 2FA flows). When a login is detected, users are presented with a dialog to automatically save the site as fireproof, ensuring they stay logged in on subsequent visits.

app/src/main/java/com/duckduckgo/app/browser/logindetection · high confidence

Breakage reporting feature implementation added

This change introduces the backend implementation for the breakage reporting feature. It adds a local Room database to persist feature configuration as JSON, a repository to manage this data, and plugins to integrate the feature into the privacy configuration system and handle JavaScript messages from content scope scripts.

breakage-reporting/breakage-reporting-impl · high confidence

Broken site prompt implementation and refresh detection logic

This change introduces the implementation for the broken site prompt feature within the broken-site-impl module. It adds a new UI layout (prompt\_broken\_site.xml) with localized strings for multiple languages, and implements the backend logic to manage prompt visibility. This includes a new DataStore for persisting dismissal streaks and cooldown settings, an in-memory store for detecting rapid page refresh patterns (double/triple refreshes), and a remote configuration feature to control these settings. The RealBrokenSitePrompt class ties these together, checking refresh patterns and cooldowns before showing the prompt, while a periodic worker handles cleanup of old report data.

broken-site/broken-site-impl · high confidence

Browser API module exposes core browser interfaces and models

The browser-api module now provides a comprehensive set of public interfaces and data models that define the browser's core capabilities. This includes URL detection and classification (DuckDuckGoUrlDetector, SpecialUrlDetector, UriString), site privacy and tracking data (Site, SiteFactory, PrivacyShield), and browser UI state management (OmnibarType, BrowserViewMode, BrowserMenuHighlight). It also exposes plugin points for extensibility, such as WebView capability checks, menu highlights, and notification channels, effectively establishing the contract between the browser engine and the rest of the application.

browser-api · high confidence

Browser mode implementation and availability checks

This change introduces the core implementation for the browser mode feature within the \browser-mode-impl\ module. It adds \RealBrowserModeStateHolder\ to manage the current mode (Regular or Fire) via a state flow, and \RealFireModeAvailability\ to determine if Fire Mode is supported by checking for Android WebView features like \MULTI\_PROFILE\ and \DELETE\_BROWSING\_DATA\. Additionally, \RealWebViewModeInitializer\ handles binding WebViews to specific profiles, ensuring that profile binding only occurs when the underlying WebView supports it. The entry also includes comprehensive unit tests for these components to verify state transitions, availability logic, and profile binding behavior.

browser-mode/browser-mode-impl · high confidence

Comprehensive pixel definition registry for telemetry tracking

The PixelDefinitions directory now contains a structured registry of telemetry pixel definitions across numerous feature areas, including ad blocking, autocomplete, autofill, broken site reports, and browser feature state. This change introduces standardized JSON5/JSON schemas that define pixel names, descriptions, owners, triggers, suffixes, and parameters, enabling consistent validation and documentation of user interaction metrics. The registry covers a wide range of user-facing features such as YouTube ad blocking settings, Duck.ai unified input interactions, cookie consent management, and app startup performance, ensuring that all new and existing telemetry events are properly defined and tracked.

PixelDefinitions · high confidence

DNS resolution and external VPN detection implementation

The VPN module now includes concrete implementations for system DNS retrieval and external VPN detection. DnsProviderImpl provides access to the device's default DNS servers, search domains, and Private DNS settings, enabling DNS-based blocking capabilities. RealExternalVpnDetector checks for active third-party VPN connections by querying the system's ConnectivityManager, ensuring the app can distinguish its own VPN traffic from external ones.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/network · high confidence

Element Hiding feature implementation

The Element Hiding feature is now available, allowing the app to hide specific elements on web pages to improve privacy and user experience. This update introduces the core implementation components, including a feature plugin that stores configuration data, a content scope config plugin that supplies this configuration to the browser engine, and a local database module to persist these settings. Tests have been added to verify the correct storage and retrieval of the element hiding configuration.

element-hiding/element-hiding-impl · high confidence

Enable verbose debug logging in VPN process

The VPN implementation now supports verbose debug logging via Android Logcat when the internal debug setting is enabled. A new lifecycle observer registers the logcat logger in both the main and VPN processes, allowing developers to capture detailed logs for troubleshooting app tracking protection issues.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/logging · high confidence

Enhanced ANR and crash data collection with app version and context

The ANR and crash reporting infrastructure now captures additional context for each event, specifically the app version, WebView version, and whether the crash occurred in a standard browser or a custom tab. This is implemented via new data models (Anr, Crash, AnrEntity, ExceptionEntity) in the anrs-api and anrs-store modules, ensuring that backend reports include these details to better distinguish and diagnose issues.

anrs-store, anrs/anrs-api · high confidence

Feedback feature extracted into a separate module

The feedback functionality has been extracted from the main app into a dedicated \feedback/feedback-impl\ module. This change introduces a new \FeedbackActivity\ and associated UI fragments to handle the user feedback flow, including positive and negative feedback submission. It also adds a \FeedbackLauncher\ interface and implementation to allow other parts of the app to launch the feedback screen, along with a \FeedbackService\ and \FeedbackSubmitter\ to handle the actual submission of feedback data to the backend.

feedback/feedback-impl · high confidence

Implement Unprotected Temporary exceptions feature

The Unprotected Temporary feature is now implemented via RealUnprotectedTemporary, which checks if a URL matches any domain in the temporary exceptions list. This allows users to temporarily exempt specific sites from privacy protections, with the list of exceptions sourced from UnprotectedTemporaryRepository.

privacy-config/privacy-config-impl/src/main/java/com/duckduckgo/privacy/config/impl/features/unprotectedtemporary · high confidence

Initial HTTPS Upgrade module architecture and data models

This change introduces the foundational structure for the new HTTPS Upgrade feature. The API module defines core interfaces for managing the upgrade lifecycle, including \HttpsUpgrader\ for determining and performing URI upgrades, \HttpsUpgradeDataDownloader\ for fetching necessary data, and \HttpsEmbeddedDataPersister\ for local storage. The store module adds the corresponding Room database entities, specifically \HttpsBloomFilterSpec\ for storing bloom filter parameters and \HttpsFalsePositiveDomain\ for tracking domains that should not be upgraded, establishing the data layer required for the feature to function.

httpsupgrade-store, httpsupgrade/httpsupgrade-api · high confidence

Initial fastlane automation setup for Android releases

This change introduces the initial fastlane configuration for the Android app, establishing the infrastructure for automated releases. It includes a Fastfile with lanes to deploy AABs to the Play Store (with a minimal initial rollout percentage of 0.0001%), update Play Store and GitHub release notes, and distribute builds via Firebase and internal app sharing. The setup also adds necessary plugins (property\_file\_read, firebase\_app\_distribution) and default release note metadata for multiple locales to support the release workflow.

fastlane · high confidence

Initial open-source release of the DuckDuckGo Android browser codebase

The repository is now open for community contributions, providing the full source code for the DuckDuckGo Android browser. This release includes the core application logic, build configuration (Gradle, Kotlin, Android SDK), and essential documentation such as the README, contributing guidelines, and style guide. It also introduces infrastructure for community translation improvements via Smartling and establishes the project's Apache 2.0 licensing terms.

(repo-wide) · high confidence

Integrate Privacy Dashboard via Hybrid WebView Activity

The Privacy Dashboard is now integrated into the Android app as a hybrid WebView screen (\PrivacyDashboardHybridActivity\). This change introduces the core implementation files that render the dashboard UI, handle user interactions (such as toggling protections, submitting broken site reports, and opening settings), and map internal app state (site data, protection status, cookie consent) to the dashboard's view model. It also establishes the API contracts (\PrivacyDashboardOpenedPlugin\, \PrivacyProtectionTogglePlugin\) and data structures (\PrivacyDashboardHybridScreenParams\) used to launch the dashboard from various entry points like the menu or breakage forms.

privacy-dashboard/privacy-dashboard-impl · high confidence

Internal Network Protection settings and debugging tools

This change introduces a dedicated internal module for Network Protection, providing a hidden 'NetP dev settings' screen and supporting infrastructure for internal builds. The new settings activity allows developers to override the VPN staging environment URL, manually configure the MTU size, force re-keys via ADB, and export PCAP network traces for debugging. It also includes toggles to enable PCAP recording, exclude system apps from the VPN tunnel, and view real-time connection quality and device IP information.

network-protection/network-protection-internal · high confidence

Internal Remote Messaging Settings for Config Source Override

An internal developer settings screen has been added to allow overriding the Remote Messaging Framework (RMF) configuration source. This feature introduces a new internal activity and a plugin-based UI that lets users select the config mode (Production, Staging, PR number, or Custom URL) and immediately download the configuration. An API interceptor automatically rewrites production RMF requests to the selected staging or custom endpoint based on these local preferences, enabling developers to test remote messaging behavior against non-production environments.

remote-messaging/remote-messaging-internal · high confidence

Internal Saved Sites Settings and Test Seeding

This change introduces an internal settings screen for managing saved sites, accessible via the new InternalSavedSitesFeature plugin. The SavedSitesInternalSettingsActivity allows users to import bookmarks from Google Takeout (including a pre-import dialog option), import local HTML bookmark files, and clear Google cookies for testing purposes. Additionally, new test seeder plugins (AddBookmarksSeederPlugin and AddFavoritesSeederPlugin) have been added to programmatically insert bookmarks and favorites for E2E testing, with corresponding unit tests verifying URL normalization and error handling.

saved-sites/saved-sites-internal · high confidence

Internal app startup tracing capability added

The traces-impl module now includes an internal feature that captures method-trace data during the app's startup phase. This is implemented via a ContentProvider (AppStartUpTracer) that initializes early in the process lifecycle and, when enabled via internal preferences, uses Android's Debug API to record sampling traces up to 50MB. The RealStartupTraces class manages the enable/disable state for this tracing, allowing developers to diagnose startup performance issues.

traces/traces-impl · high confidence

Internal color palette preview screen added

An internal ColorPaletteFragment has been added to the design system to display the app's theme color values. This screen uses new internal Compose widgets (DaxColorAttributeListItem, DaxColorDot) and legacy Android views (ColorAttributeView, ColorDotView) to visualize attributes such as background, surface, container, destructive, lines, accent colors, and text/icon colors in both light and dark modes.

android-design-system/design-system-internal/src/main/java/com/duckduckgo/common/ui/internal/ui/palette, android-design-system/design-system-internal/src/main/java/com/duckduckgo/common/ui/internal/ui/widget · high confidence

Internal component showcase app added to the Android Design System

An internal demonstration app has been added to the Android Design System to display and preview available UI components. This feature introduces a new set of internal Fragments (such as ComponentFragment, ComponentMessagingFragment, and ComponentLayoutsFragment) and a RecyclerView-based adapter that renders a comprehensive list of design system elements—including buttons, top app bars, cards, scaffolds, messaging components, and navigation items—allowing developers to visually verify component behavior and styling in both light and dark themes.

android-design-system/design-system-internal/src/main/java/com/duckduckgo/common/ui/internal/ui/component · high confidence

Internal developer settings for crash and ANR diagnostics

An internal settings screen has been added to the Android app, allowing developers to view and manage Application Not Responding (ANR) and crash data. This feature includes a new activity that lists available diagnostic capabilities via plugins, a minidump list view for inspecting, sharing, and deleting local crash reports collected by Crashpad, and a vitals adapter for displaying detailed ANR and crash stack traces. The underlying data is persisted using a new Room database schema containing entities for ANR and crash events.

anrs-internal · high confidence

Internal settings screen for switching subscription plans

The internal settings area now includes a dedicated screen that allows users with an active subscription to switch between available subscription plans (such as upgrading or downgrading between Plus and Pro tiers). This change introduces the \SubscriptionsInternalSettingsActivity\ which serves as the container for internal settings plugins, and adds specific UI components (\SwitchSubscriptionView\ and \SwitchSubscriptionProductView\) that enable plan selection via a dialog. Users can now manage their subscription tier directly from this internal interface, with feedback provided via toast messages for successful switches, failures, or cancellations.

subscriptions-internal · high confidence

Introduce API manipulation feature with local configuration caching

Adds the implementation for the 'apiManipulation' feature, including a repository that caches configuration JSON in local SharedPreferences and a plugin that exposes this configuration to ContentScopeScripts. This change enables the feature to be toggled via remote configuration while ensuring the config is prefetched and cached locally to prevent ANRs when accessing it.

content-scope-scripts/content-scope-scripts-impl/src/main/java/com/duckduckgo/contentscopescripts/impl/features/apimanipulation · high confidence

Introduce Android voice search implementation

This change adds the core implementation for the new Android voice search feature within the \voice-search-impl\ module. It introduces a structured permission flow that handles microphone access, including rationale dialogs and snackbar prompts, and integrates with the system's SpeechRecognizer for on-device recognition. The implementation also includes logic to verify device and language support, manages the voice search activity lifecycle, and tracks user interactions through analytics pixels.

voice-search/voice-search-impl · high confidence

Introduce App Tracking Protection database schema and stats repository

The vpn-store module now includes the database models, DAOs, and repository for the App Tracking Protection feature. This adds new SQLite tables to track blocked app trackers (vpn\_tracker), record service state and always-on status (vpn\_service\_state\_stats), and store heartbeat data (vpn\_heartbeat). It also introduces tables to manage the app tracker blocklist, exclusion lists, system app overrides, and exception rules, along with a new repository to query and manage these blocking statistics.

vpn-store · high confidence

Introduce App Tracking Protection onboarding flow

Users are now presented with a new onboarding experience for App Tracking Protection (Device Shield) upon first use. This flow includes a multi-page UI with Lottie animations and static headers that adapt to the device's light or dark theme, a ViewModel to manage the navigation logic and VPN permission requests, and a persistent store to track whether the onboarding has been shown and to manage session-based banners and upsell dismissals.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/ui/onboarding · high confidence

Introduce AppTrackerDetector interface for domain evaluation

Added the AppTrackerDetector interface to the app-tracking-api module, defining a contract for evaluating whether a specific domain requested by an app (identified by UID) is a tracker. This interface includes an evaluate method that returns an AppTracker object containing details like the tracker company name and app ID, intended to be called off the UI thread.

app-tracking-api · high confidence

Introduce DNS and VPN detection interfaces in VPN API

The VPN API module now exposes two new interfaces to support network-aware features. DnsProvider allows querying the system's default DNS addresses, configured search domains, and user-defined private DNS settings, enabling the VPN tunnel to respect or integrate with these configurations. ExternalVpnDetector provides a mechanism to detect if the device's current network connection is already routed through an external VPN, which is essential for preventing VPN-over-VPN loops or handling nested tunnel scenarios.

app-tracking-protection/vpn-api/src/main/java/com/duckduckgo/mobile/android/vpn/network · high confidence

Introduce Event Hub implementation for web event tracking and pixel state management

This change adds the Event Hub implementation module, introducing a new system for handling web events and managing pixel telemetry state. It includes a new Room database (EventHubPixelStateDatabase) and repository for persisting pixel state, a WebEventDeduplicator to prevent duplicate event processing per tab, and a WebEventsDataStore backed by Android DataStore for storing remote configuration. The module also registers plugins to inject JavaScript, handle lifecycle events (foreground/background), and process ContentScope JS messages, all wired via the new Metro dependency injection framework.

event-hub/event-hub-impl · high confidence

Introduce HTTPS Upgrade module implementation

The httpsupgrade-impl module now provides the concrete implementation for the HTTPS Upgrade feature, including the HttpsUpgrader that checks if HTTP URLs should be upgraded to HTTPS using a native Bloom filter, and the HttpsUpgradeDataDownloader that fetches and persists the Bloom filter binary and false-positive allowlist from DuckDuckGo's static CDN. This location also wires the feature via Dagger modules, registers the upgrader as a lifecycle observer to reload data on app start, and adds instrumentation and unit tests for the Bloom filter and JSON parsing.

httpsupgrade/httpsupgrade-impl · high confidence

Introduce Malicious Site Protection feature

This change introduces the Malicious Site Protection feature, which detects and blocks access to phishing, malware, and scam sites. The implementation includes a new API interface, a Room database for storing local filter sets and hash prefixes, and background workers to periodically update these datasets from remote servers. It also adds remote feature flags to control the feature's visibility, enable scam protection, and manage dataset update frequencies.

malicious-site-protection/malicious-site-protection-impl · high confidence

Introduce OS credential import capability

This change adds the credential-exchange module, enabling the app to import passwords from other apps on the device using Android's Credential Exchange Format (CXF). It includes the API interfaces for launching the system import flow and detecting available credential exporters, along with the implementation that parses CXF payloads to extract basic-auth credentials while ignoring unsupported types like passkeys. The feature is gated by remote feature toggles and includes a dummy implementation for builds where the backend is not supported.

credential-exchange/credential-exchange-impl · high confidence

Introduce Page Context feature for Duck.ai

This change adds the implementation for the new 'pageContext' feature, enabling Duck.ai to access and utilize page context data. The update introduces a plugin system that registers the feature within the content scope configuration and privacy feature plugins, while a dedicated repository manages the storage and retrieval of JSON context data via Android SharedPreferences, ensuring the data is loaded into memory only in the main process.

content-scope-scripts/content-scope-scripts-impl/src/main/java/com/duckduckgo/contentscopescripts/impl/features/pagecontext · high confidence

Introduce Request Filterer to block cross-site tracking requests

This change adds the Request Filterer implementation, which blocks web requests that appear to be tracking user activity across different sites. The feature evaluates the Origin and Referer headers of network requests against the previously viewed page; if a request originates from a different top-level domain within a short time window, it is filtered out. The logic respects a configurable time window, supports remote configuration for exceptions and settings, and can be toggled on or off via feature flags with minimum version support.

request-filterer/request-filterer-impl · high confidence

Introduce SitePermissionsManager API for managing site permissions

A new public interface, SitePermissionsManager, has been added to the site-permissions-api module to centralize the management of site permissions. This API allows consumers to retrieve permissions for specific tabs and requests, query permission states via the standard JavaScript Permissions API (returning 'granted', 'prompt', or 'denied'), and check for permanent permission grants. It also provides methods to clear permissions for specific domains or all non-fireproof domains, ensuring that user privacy settings can be programmatically managed and reset as needed.

site-permissions-api · high confidence

Introduce Tracker Allowlist feature

The Tracker Allowlist feature is now available, allowing users to configure specific exceptions for tracker detection. This implementation adds the core logic to evaluate URLs against allowlisted rules, a plugin to store and manage these exceptions via remote configuration, and the necessary data models to support the feature.

privacy-config/privacy-config-impl/src/main/java/com/duckduckgo/privacy/config/impl/features/trackerallowlist · high confidence

Introduce Unprotected Temporary exceptions storage and caching

Added a new persistence layer for Unprotected Temporary exceptions, including a Room DAO and a repository that caches exception data in memory. The repository loads this data only in the main process and provides a snapshot of exceptions for immediate access, supporting the broader privacy config feature set.

privacy-config/privacy-config-store/src/main/java/com/duckduckgo/privacy/config/store/features/unprotectedtemporary · high confidence

Introduce VPN API interfaces for tunnel management and feature registration

This change introduces the core public API interfaces for the VPN module, defining how the application interacts with the device VPN. The new \Vpn\ interface allows clients to start, stop, pause, and snooze the VPN tunnel, with \pause\ designed to keep features registered while temporarily halting the tunnel. The \VpnFeaturesRegistry\ interface enables features (such as App Tracking Protection) to register and unregister themselves, automatically managing the VPN lifecycle based on whether any features are active. Additionally, the \VpnNetworkStackProvider\ interface is added to supply the underlying network stack implementation to the app tracking protection module.

app-tracking-protection/vpn-api/src/main/java/com/duckduckgo/mobile/android/vpn · high confidence

Introduce VoiceSearchLauncher API for voice search integration

Added the VoiceSearchLauncher interface to the voice-search-api module, providing a standardized contract for launching voice search and handling results. This API supports two distinct modes (Search and Duck AI) and identifies the entry source (Browser or Widget), allowing consumers to register callbacks for voice recognition success, cancellation, or disabled states.

voice-search-api · high confidence

Introduce app tracking protection repository and category detection

This change introduces the core repository and helper classes for the App Tracking Protection feature. It adds RealTrackingProtectionAppsRepository to manage the list of installed apps, determine their protection status (protected, unprotected, or excluded via Network Protection), and handle manual exclusions. It also includes RealAppCategoryDetector and ApplicationInfoExtensions to categorize apps (e.g., Game, Audio, System) and identify system apps, forming the backend logic for the app tracking protection UI and exclusion lists.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/apps · high confidence

Introduce attributed metrics implementation module

This change adds the implementation layer for the new attributed metrics feature. It introduces configuration handling via AttributeMetricsConfig, which retrieves metric bucket settings and toggle states from feature flags, and defines data models like SendOriginParamSettings for campaign substring configuration. Additionally, it establishes local persistence for metric events through the EventEntity Room database table, storing event names, counts, and dates.

attributed-metrics-impl · high confidence

Introduce build benchmarking system to track build performance

Added a new build benchmarking tool in the \build-benchmarks\ directory that uses \gradle-profiler\ to measure and report build performance metrics. The system defines scenarios for warm builds, cold builds, and incremental builds (triggered by ABI and non-ABI changes) to track total execution time and Gradle configuration time. A Python script (\run-benchmark.py\) orchestrates the profiling, calculates statistical summaries (mean, median, standard deviation), and optionally reports results to an external API. This enables developers to monitor build speed regressions over time via nightly CI runs.

build-benchmarks · high confidence

Introduce configurable, period-based telemetry pixel counters

The event hub now supports remote configuration of telemetry pixels that count specific web events over defined time periods. This change adds configuration models, a JSON parser, and a persistence layer for pixel state, enabling the system to increment counters based on incoming web events and fire them when their configured period expires. Users benefit from more granular, time-windowed telemetry collection that adapts to server-side configuration changes.

event-hub-impl · high confidence

Introduce data store for persisting and observing accessibility settings

A new \AccessibilitySettingsSharedPreferences\ class has been added to manage user accessibility preferences, specifically font size overrides and force-zoom settings. This component persists these values in SharedPreferences and exposes them via a reactive Flow, allowing the app to automatically refresh the WebView when accessibility settings change.

app/src/main/java/com/duckduckgo/app/accessibility/data · high confidence

Introduce database models for request filterer settings and exceptions

Added new Room database entities (SettingsEntity and RequestFiltererExceptionEntity) to persist request filterer configuration and domain-specific exceptions, along with a helper to map exception entities to the FeatureException model.

request-filterer-store · high confidence

Introduce element-hiding store module for privacy plugin data

Added a new Android library module, element-hiding-store, that provides a local persistence layer for element-hiding privacy plugin data. The module introduces an ElementHidingEntity backed by an Android Room database (version 1) and an ElementHidingDao for CRUD operations. A RealElementHidingRepository loads the stored JSON into memory on initialization (when running in the main process) and keeps it in sync via updateAll, exposing the current entity to consumers. Unit tests verify the repository's load-to-memory behavior and update logic.

element-hiding/element-hiding-store · high confidence

Introduce extensible survey parameter resolution

The survey module now supports dynamic, plugin-based resolution of survey URL query parameters. A new \SurveyParameterManager\ interface and its \RealSurveyParameterManager\ implementation allow external components to register \SurveyParameterPlugin\ providers via a plugin point. This enables flexible addition of new survey parameters (such as cohort or ppro data) without modifying core survey logic, with strict mode failing if parameters are unsupported and lenient mode filling them with empty strings.

survey/survey-impl · high confidence

Introduce fingerprint protection data storage and API

This change adds the foundational API and local storage layer for the new Fingerprint Protection feature. It introduces a \FingerprintProtectionManager\ interface that exposes a method to retrieve a random seed, and defines Room database entities to persist data for specific fingerprinting vectors (battery, canvas, hardware, screen size, and temporary storage) as well as the protection seed itself.

fingerprint-protection-store, fingerprint-protection/fingerprint-protection-api · high confidence

Introduce fingerprint protection module with seed management and periodic updates

This change adds the fingerprint protection implementation module, introducing a seed management system that generates and stores a random seed via an in-memory repository and a Room database-backed seed entity. A background worker is scheduled to periodically refresh this seed (every 24 hours) and also updates it on app lifecycle stop/start events, ensuring the fingerprint data remains current. The module includes DI bindings for the database and various fingerprinting feature repositories (battery, canvas, hardware, screen size, temporary storage), along with database migration logic to handle schema changes.

fingerprint-protection/fingerprint-protection-impl · high confidence

Introduce injectable ViewModel factory plugin points

This change adds a new plugin-point mechanism in common-utils that allows ViewModel factories to be injected and resolved dynamically. It introduces a \ViewModelFactoryPlugin\ interface for creating ViewModel instances, along with specific \PluginPoint\ implementations for Activity, Fragment, View, and Vpn scopes. These components are wired using Metro annotations (\@SingleIn\, \@Inject\) to enable modular, scope-specific ViewModel creation without hardcoding dependencies.

_common/common-utils/src/main/java/com/duckduckgo/common/utils/plugins/view\model · high confidence

Introduce local storage for voice search configuration and device metadata

The voice-search-store module now persists voice search settings and device capability data locally. Users benefit from a new data layer that saves voice search enablement status, the last selected search mode, and rationale dialog acceptance via SharedPreferences, ensuring these preferences are retained across sessions. Additionally, the store introduces a Room database to track supported manufacturers, locales, and minimum version requirements, allowing the app to manage voice search availability based on device-specific constraints.

voice-search-store · high confidence

Introduce on-device voice search with input mode selection and remote configuration

The voice search implementation now supports on-device speech recognition (Android 12+) via a new VoiceSearchActivity, allowing users to toggle between search and AI input modes. The feature includes a tabbed UI for mode selection, real-time volume indicators, and logic to handle recognition timeouts and errors. Support for remote configuration has been added to control feature availability based on device manufacturer, locale, and minimum OS version, while a new attribute matcher plugin enables remote messaging to target users based on voice search availability.

voice-search-impl · high confidence

Introduce per-site desktop mode preference storage

The site preferences module now supports remembering whether a specific site should always open in desktop mode. This is implemented via a new \DesktopModeSettings\ API for managing these preferences and a corresponding \SitePreferencesEntity\ database table to persist the \desktopModeEnabled\ flag per domain, ensuring the browser respects this setting on navigation.

site-preferences-impl, site-preferences/site-preferences-api · high confidence

Introduce request filterer store with Room database and in-memory caching

This change adds a new persistence layer for the request filterer, introducing a Room database (RequestFiltererDatabase) with entities for settings and exceptions, along with a repository that loads this data into memory for the main process. It also includes a feature toggle store backed by SharedPreferences to manage request filterer configuration, enabling the app to efficiently filter false requests made by WebView by maintaining an in-memory cache of exceptions and settings.

request-filterer/request-filterer-store · high confidence

Introduce runtime checks persistence module

A new \runtime-checks-store\ module has been added to persist privacy plugin data. It provides a Room-based database (\RuntimeChecksDatabase\) with a \RuntimeChecksDao\ and \RuntimeChecksEntity\ to store runtime check configurations as JSON. The \RealRuntimeChecksRepository\ manages this data, loading it into memory on initialization (specifically for the main process) and providing methods to update and retrieve the stored configuration.

runtime-checks/runtime-checks-store · high confidence

Introduce settings sync module with local metadata tracking

The sync module now includes a new settings-sync implementation that tracks local changes to syncable settings. This adds a Room database to persist metadata about which settings have been modified, a listener to record when users change settings, and a data observer that triggers sync operations when local metadata changes. The module also provides a shared preferences store for tracking sync timestamps and includes test infrastructure with fake implementations for crypto and settings stores.

sync/sync-settings-impl · high confidence

Introduce single-tab and chat-specific data clearing via Fire dialog

Added SingleTabFireDialog and its ViewModel to enable users to clear data for a single tab or specific chat items (such as Duck.ai chats) rather than clearing all browsing data at once. The dialog supports multiple entry points including the browser, settings, tab switcher, and contextual chat sheets, and includes telemetry pixels to track usage of these granular clearing actions.

app/src/main/java/com/duckduckgo/app/global/view · high confidence

Introduce system search screen with device app suggestions

The app now includes a dedicated System Search screen that displays installed device applications as autocomplete suggestions. This feature allows users to search for and launch apps directly from the search interface, with the list of device apps being cached and refreshed as needed. The implementation includes a new DeviceAppLookup service to handle app queries and a pixel plugin to manage analytics parameters for voice chat sessions initiated from this context.

app/src/main/java/com/duckduckgo/app/systemsearch · high confidence

Introduce toggle report prompt logic and hybrid dashboard view model

The privacy dashboard implementation now includes a new data store to manage toggle report prompts, tracking when users dismiss or send reports and enforcing configurable intervals and limits for these prompts. Additionally, a new hybrid view model has been added to handle the dashboard's UI state, including site protection status, request data, and commands for actions like launching toggle reports or opening settings, integrating with existing plugins for privacy protection toggles and dashboard opening events.

privacy-dashboard-impl · high confidence

Introduces API for Fire Mode browsing and WebView profile isolation

This change adds the core API interfaces for the new Fire Mode browsing experience, defining a \BrowserMode\ enum with \REGULAR\ and \FIRE\ states. It introduces \BrowserModeStateHolder\ for managing the active mode, \FireModeAvailability\ to check feature and WebView support prerequisites, and \WebViewModeInitializer\ to bind WebViews to isolated profiles, ensuring cookies and storage are separated between the regular and Fire modes. Additionally, it provides \AggregateBrowserModeProvider\ and \BrowserModeDataProvider\ for accessing mode-specific data and reactive streams, along with DI qualifiers (\@RegularMode\, \@FireMode\) to support dependency injection for mode-specific implementations.

browser-mode/browser-mode-api · high confidence

Introduces API for importing passwords from Google Password Manager

Adds the \ImportPasswordsFromGoogle\ interface to the autofill API, defining the contract for the Google import flow. This includes methods to check device support (\isSupported\), parse the result from the import screen (\parseResult\), and observe import progress (\importStatus\). The interface also defines result and status types to handle success, cancellation, errors, and import completion metrics.

autofill-api · high confidence

Introduces Android Block Store as the persistent storage backend

The app now uses Google's Block Store API to securely store and retrieve data on Android devices. This implementation adds a new \RealPersistentStorage\ module that wraps the Block Store client, handling operations like storing, retrieving, and deleting bytes. It includes checks for Google Play Services availability and end-to-end encryption support, ensuring data is only stored when the underlying hardware and security features are available. Cloud backup is currently disabled in this initial implementation.

persistent-storage/persistent-storage-impl · high confidence

Introduces ContentScopeScripts implementation with remote feature toggles and optimized JS injection

This change adds the \content-scope-scripts-impl\ module, which provides the core implementation for injecting and managing ContentScopeScripts in the browser. It introduces a new remote feature configuration (\clientContentFeatures\) with toggles to control the feature's activation, the use of new WebView compatibility APIs, WebMessageListener support, and performance optimizations for script injection, inbound messaging, and experiment caching. The implementation includes plugins for injecting scripts at document start and page load, a new asynchronous JS messaging system with an inbound message queue to offload processing from the main thread, and optimized script generation logic that caches configuration and reduces redundant JSON serialization.

content-scope-scripts/content-scope-scripts-impl · high confidence

Introduces Fire Mode tab isolation and per-mode repository resolution

The app now supports Fire Mode with isolated tab data. A new RealTabRepositoryProvider resolves the correct TabRepository based on the active BrowserMode (Regular or Fire), and RealAggregateTabProvider combines tab flows from these mode-specific repositories, automatically excluding Fire Mode tabs when Fire Mode is not active. This ensures that tab state is strictly separated between browsing modes, preventing data leakage and ensuring that tab operations like selection and deletion apply only to the relevant mode's context.

app/src/main/java/com/duckduckgo/app/tabs/model · high confidence

Introduces LinearOnboardingOrchestrator API for structured onboarding flows

The onboarding-api module now exposes the LinearOnboardingOrchestrator interface, which manages linear onboarding runs by walking through defined plans and steps. This API allows consumers to start plans, handle user events, and observe the current state (such as InProgress, Completed, or Skipped) via StateFlow. It supports branching logic through side plans and provides a clean separation between orchestration logic and UI rendering, enabling structured and testable onboarding experiences.

onboarding-api · high confidence

Introduces SqlCipherLoader to manage native library initialization

A new SqlCipherLoader module has been added to handle the asynchronous loading of the SQLCipher native library. This component ensures the library is ready before use by PIR and autofill features, providing a safe, thread-compatible API that waits for initialization with configurable timeouts and reports failures or timeouts via analytics pixels.

sqlcipher-loader/sqlcipher-loader-impl · high confidence

Introduces downloads API module with core interfaces and models

The downloads/downloads-api module now provides the public contract for the downloads feature, defining the core data model (DownloadItem) and key interfaces including FileDownloader for initiating downloads, DownloadsRepository for managing download records, DownloadStateListener for streaming UI commands, and FileDownloadNotificationManager for handling system notifications. It also introduces NewDownloadState to track unseen downloads for menu indicators and DownloadsScreens to define navigation parameters, establishing the foundation for the new modularized downloads implementation.

downloads/downloads-api · high confidence

Introduces extensible custom headers provider for network requests

A new \CustomHeadersProvider\ implementation has been added to the common utilities, allowing custom HTTP headers to be dynamically attached to network requests based on the target URL. This component utilizes a plugin architecture (\CustomHeadersPlugin\) registered via dependency injection, enabling other modules to contribute specific header logic that is aggregated and applied during request execution.

common/common-utils/src/main/java/com/duckduckgo/common/utils/plugins/headers · high confidence

Introduces local storage schema for remote messaging

The remote-messaging-store module now includes the database entities required to persist remote message data locally. This adds a \remote\_message\ table to track message content, display status, and impression metrics, a \remote\_messaging\_cohort\ table to associate messages with user cohorts via percentile, and a \remote\_messaging\ configuration table to manage versioning and cache invalidation.

remote-messaging-store · high confidence

Introduces native storage layer for Duck.ai chat history and metadata

The app now persists Duck.ai chat history, file references, and settings in a local Room database instead of relying solely on browser storage. This change introduces a new store that manages chat records (including title, model, pinning status, and reasoning mode), associated file metadata, and application settings, enabling features like per-row rename, download, and pin/unpin actions in the chat history overflow menu, as well as supporting the Fire Mode data-clearing capability.

duckchat-store · high confidence

Introduces prompts-coordinator to manage RMF card and modal display logic

Adds the RealPromptsCoordinator implementation to arbitrate between New Tab Page (NTP) cards and modals, ensuring they do not overlap by enforcing a cooldown period and waiting for surface availability. This change also introduces prompt exposure metrics tracking, which records how often prompts are shown per install week to support analytics.

prompts-coordinator-impl · high confidence

Introduces scriptlet-based ad blocking with signature validation and remote configuration

This change adds the core implementation for downloading, validating, and storing ad-blocking scriptlets. It introduces a new \ContingencyMessageBottomSheetFragment\ to display fallback messages when ad blocking is disabled, and a \ScriptletSignatureValidator\ that enforces security by verifying downloaded scriptlets using SHA256withECDSA signatures against a trusted public key. The \RealScriptletUpdater\ handles the parallel download and storage of these scriptlets, while \RealAdBlockingStatusChecker\ and \AdBlockingMenuStateProvider\ manage the feature's lifecycle, including remote config kill-switches, contingency modes, and the visibility of the ad-blocking menu item. Additionally, Duck Player settings and state are integrated into this module, allowing the ad-blocking logic to influence Duck Player's visibility and behavior based on the current ad-blocking state. Also in this area: 4 commits (0 fixes) modifying ad-blocking-impl; Ad-blocking module migrates dependency injection to Metro.

ad-blocking-impl · medium confidence · unverified

Introduces state-driven architecture and new backend integrations for Privacy Intelligence Reports

The Pir-impl module now uses a new state engine (PirActionsRunnerStateEngine) to manage broker action flows, replacing previous imperative logic. This change introduces dedicated backend integrations for solving CAPTCHAs (CaptchaResolver) and polling for email-extracted data (EmailDataResolver), alongside a new BrokerStepsParser to handle dynamic broker step configurations. Additionally, a PirEligibility checker is added to gate feature access based on subscription and entitlement status, while utility functions for profile matching and data refreshing are introduced to improve data consistency.

pir-impl · high confidence

Introduces test-seeder-internal for controlled test environment seeding

The test-seeder-internal module now includes RealTestScenarioSeeder, a new internal component that manages test data seeding via a plugin-based architecture. This component gates seeding operations behind specific flags (Maestro and macrobenchmark) and ensures that only declared, non-colliding keys are processed, providing a safer and more structured way to prepare test environments for E2E and benchmark scenarios.

test-seeder/test-seeder-internal · high confidence

Introduces wide event tracking and user segment calculation infrastructure

The statistics implementation now supports a new wide event tracking system, adding database entities and a repository to record complex user flows with steps, metadata, configurable cleanup policies, and interval buckets. It also introduces a new user segment calculation engine that computes activity-based segments (app use, search, and DuckAI) based on usage history, and adds local storage models to track daily and unique pixel firing for deduplication.

statistics-impl · high confidence

Introduction of Ad Click Manager API interface

A new public interface, AdClickManager, has been added to the ad-click-api module. This interface defines the contract for managing ad click detection and tracking, including methods to set the active tab, detect ad clicks and domains, clear tab-specific or all ad-related data, and check for existing exemptions. This provides the foundational API for measuring ad conversions only when required.

ad-click/ad-click-api · high confidence

Introduction of App Tracking Protection screen navigation definitions

The App Tracking Protection module now exposes a sealed class defining navigation parameters for the Tracker Activity and the onboarding screen, enabling other parts of the app to launch these specific UI flows via the global activity starter.

app-tracking-protection/app-tracking-api/src/main/java/com/duckduckgo/mobile/android/app/tracking/ui · high confidence

Introduction of AppTrackingProtection API interface

A new \AppTrackingProtection\ interface has been added to the app-tracking-api module, defining the public contract for the App Tracking Protection feature. This interface exposes methods to check onboarding status (\isOnboarded\), verify if the feature is enabled (\isEnabled\) or currently running (\isRunning\), manage the feature lifecycle (\restart\, \stop\), and retrieve the list of excluded apps (\getExcludedApps\).

app-tracking-protection/app-tracking-api/src/main/java/com/duckduckgo/mobile/android/app/tracking · high confidence

Introduction of Attributed Metrics tracking system

The app now includes a new infrastructure for collecting and emitting attributed metrics, allowing for the tracking of user engagement and retention data. This implementation introduces a modular system with specific metrics for search activity (including 7-day rolling averages) and user retention (weekly and monthly intervals). The system is governed by remote feature toggles, enabling granular control over which metrics are active and emitted. It also handles origin parameter logic for attribution and integrates with the app's lifecycle to ensure data is collected only during valid periods.

attributed-metrics/attributed-metrics-impl · high confidence

Introduction of CookiesFeature configuration model

A new data model class, CookiesFeature, has been added to define the structure for cookie-related feature flags and settings. This model includes fields for feature state, minimum supported version, exceptions, and specific settings such as first-party cookie policies (including threshold and max-age) and lists of third-party cookie names, enabling more granular configuration of cookie behavior.

cookies-impl · high confidence

Introduction of DRM Policy Manager interface

A new \DrmPolicyManager\ interface has been added to the site permissions implementation, defining the structure for DRM-related policy decisions. This change introduces specific enums for \DrmPolicyAction\ (GRANT, DENY, PROMPT) and \DrmPolicyReason\ (such as GLOBAL\_OFF, USER\_DENY\_ALWAYS, BLOCK\_LIST), along with data classes for the decision context and outcome. This establishes the foundational logic for evaluating whether DRM content should be allowed or blocked based on user settings, global protections, and blocklists.

site-permissions-impl · high confidence

Introduction of General Settings screen with user-controllable toggles

A new General Settings screen has been added, allowing users to manage autocomplete suggestions, recently visited site history, voice search, malicious site protection, and AI chat suggestions. The implementation includes a ViewModel that exposes these settings via a ViewState, handles user interactions to toggle features on or off, and fires corresponding analytics pixels for each change. Visibility of certain options, such as the 'Show on App Launch' setting and malicious site protection, is dynamically determined by feature flags and availability checks.

app/src/main/java/com/duckduckgo/app/generalsettings · high confidence

Introduction of Linear Onboarding Orchestrator

The onboarding module now includes a new \LinearOnboardingOrchestrator\ implementation that manages a linear, step-by-step onboarding flow. This orchestrator handles navigation through a stack of plan frames, supports side plans via switching, and manages state transitions including completion and skipping. The implementation is registered in the dependency injection container and includes comprehensive unit tests covering state management, step progression, precondition handling, and late subscription behavior.

onboarding/onboarding-impl · high confidence

Introduction of Request Filterer feature configuration model

A new feature configuration model for the request filterer has been added, defining the structure for filter state, minimum supported version, settings (including a window duration in milliseconds), and a list of feature exceptions. This establishes the data schema used to manage and configure the request filtering behavior within the application.

request-filterer-impl · high confidence

Introduction of Tracker Allowlist persistence and in-memory caching

The privacy configuration store now includes a dedicated data layer for managing tracker allowlists. A new Room-based DAO (TrackerAllowlistDao) handles database operations for storing and retrieving domain exceptions, while the RealTrackerAllowlistRepository loads this data into an in-memory map (rulesByDomain) keyed by domain. This repository ensures that allowlist rules are compiled into regular expressions and cached in memory, with updates synchronized from the database, specifically loading this data only in the main process to optimize resource usage.

privacy-config/privacy-config-store/src/main/java/com/duckduckgo/privacy/config/store/features/trackerallowlist · high confidence

Introduction of VpnBugReporter for generating VPN state logs

The App Tracking Protection module now includes a new VpnBugReporter interface and its RealVpnBugReporter implementation. This component collects the current VPN state via VpnStateCollector and formats it into a string for bug reporting purposes, logging the generation event using logcat instead of Timber.

app-tracking-protection/vpn-internal/src/main/java/com/duckduckgo/vpn/internal/feature/bugreport · high confidence

Introduction of encrypted sync store and sync attempt tracking

The sync-store module now persists sensitive account credentials (such as primary and secret keys) and user identifiers in encrypted shared preferences rather than plain text, enhancing data security on the device. Additionally, the system now tracks sync health by recording sync attempts and categorizing API or operation errors (e.g., data provider failures, encryption issues) into a local database for daily statistics and monitoring.

sync-store · high confidence

Introduction of new Room database entities for saved sites

The saved-sites-store module now includes a new data model file defining Room entities for managing saved sites. This introduces an \Entity\ table to store bookmarks and folders with details like title, URL, type, and modification time, along with a \Relation\ table to handle folder-to-entity associations. A type converter is also added to handle the serialization of the \EntityType\ enum (BOOKMARK or FOLDER) for database storage.

saved-sites-store · high confidence

Local storage for previously submitted broken site reports

A new local data model has been introduced to track the last timestamp a broken site report was sent for a specific hostname. This allows the application to remember which sites have already been reported, preventing duplicate submissions for the same issue.

broken-site-store · high confidence

MacOS implementation adds MacOsViewModel for share and settings navigation

The macos-impl module now includes a new MacOsViewModel that handles user interactions for sharing the macOS download link and navigating to Windows client settings. When a user clicks the share button, the view model checks the status of the download link origin feature flag, fires a telemetry pixel event, and emits a command to share the link. Clicking the settings button emits a command to navigate to Windows client settings.

macos-impl · high confidence

Malicious site protection now supports scam feeds alongside phishing and malware

The malicious site protection implementation has been extended to include a new 'scam' feed type in addition to the existing phishing and malware categories. This change introduces new database entities (revisions, hash\_prefixes, filters) and data models to store and process scam-specific filter sets and hash prefixes, enabling the system to identify and block scam sites using the same revision-based update mechanism as other threat types.

malicious-site-protection-impl · high confidence

Native Duck.ai chat storage with Fire Mode isolation

Duck.ai chat data is now persisted in a native Room database instead of the web layer's localStorage/IndexedDB. This store supports per-chat operations (read, write, delete, rename, pin/unpin) and attachment file management, and it exposes a JavaScript bridge so the frontend can interact with the native backend. Crucially, the storage is split by browser mode: a regular database (\duck\_ai\_bridge.db\) and a separate Fire-mode database (\fire\_mode\_duck\_ai.db\) with destructive migration enabled, ensuring that chats created in Fire mode are kept entirely separate from regular chats.

duckchat/duckchat-store · high confidence

Native input field for the browser omnibar

The browser's address bar now supports a native input field that replaces the legacy omnibar text input. This new input handles search queries and Duck.ai chat submissions, featuring smooth morphing animations when transitioning between the widget and the omnibar, and a layout coordinator that manages positioning, elevation, and padding for autocomplete suggestions. The experience is controlled by feature flags (nativeInputOmnibar, nativeInputSearchOnly) and includes a kill switch (nativeInputStateBugKillSwitch) to mitigate state issues, with the native input falling back to the legacy omnibar when disabled or in search-only mode.

app/src/main/java/com/duckduckgo/app/browser/nativeinput · high confidence

Network Protection auto-excludes incompatible apps

Network Protection now automatically detects and excludes apps that are incompatible with the VPN, preventing connection issues. When an incompatible app is installed or detected, users are presented with a prompt to confirm the exclusion. The system also monitors for newly installed apps and automatically adds them to the exclusion list if they are known to be incompatible, ensuring a stable VPN connection without manual intervention.

network-protection/network-protection-impl · high confidence

Network Protection management screen and settings overhaul

The Network Protection management screen and settings have been significantly updated. The main management activity now supports edge-to-edge display and includes direct navigation to geoswitching, app exclusion lists, custom DNS, and VPN settings. A new auto-exclude feature has been added, allowing users to automatically exclude incompatible apps or manually select them via a prompt. System apps are now excluded by default in categories like Communication, Networking, and Media, with user controls to manage these exclusions. Custom DNS support has been expanded to include malware blocking options. Additionally, VPN settings now include options to pause the VPN during Wi-Fi calls, exclude local network routes, and manage notification alerts.

network-protection-impl · high confidence

New 'Get Desktop Browser' promotion in Settings and new tab shortcut

Users can now see a 'Get Desktop Browser' item in the 'Complete your setup' section of the app settings, which promotes the desktop version of the browser and allows dismissal. This feature includes pixel tracking for impressions, clicks, and dismissals, and is controlled by a feature flag. Additionally, a new 'Settings' shortcut has been added to the New Tab page, allowing users to quickly access the settings screen, with its visibility controlled by a local feature toggle.

app/src/main/java/com/duckduckgo/app/settings · high confidence

New 7-day rolling average ad-click metric

The ad-click implementation now includes a new attributed metric that tracks the 7-day rolling average of ad clicks. This metric is collected on the first ad click of each day and, when enabled via feature flags, emits a pixel named 'attributed\_metric\_average\_ad\_clicks\_past\_week' with bucketed count values. The metric respects installation age, skipping emission on the installation day or if insufficient data exists, and includes a 'dayAverage' parameter for users with less than a full week of data.

ad-click/ad-click-impl/src/main/java/com/duckduckgo/adclick/impl/metrics · high confidence

New ANR and crash reporting implementation

The app now includes a new ANR (Application Not Responding) supervisor and crash reporting system. The AnrSupervisor monitors the main thread for unresponsiveness and records ANR details, including stack traces, WebView version, and whether the app was in a custom tab. Additionally, a GlobalUncaughtExceptionHandler captures unhandled exceptions and logs them via a CrashLogger, which stores crash data locally. OfflinePixelSenders for both ANRs and crashes ensure these events are reported to analytics even when the device is offline, with parameters including stack traces, app version, and WebView version. Verified Play Store installs receive a separate crash pixel. The system also distinguishes between browser and custom tab crashes/ANRs for more granular reporting.

anrs/anrs-impl/src/main/java/com/duckduckgo/app/anr · high confidence

New API for SERP settings synchronization and settings plugin architecture

The settings API now includes a new plugin architecture with interfaces for different settings sections (CompleteSetup, Pro, Other, ThreatProtection, Protections) and a new system for synchronizing settings with the DuckDuckGo SERP. This includes a SerpSettingsDataProvider interface for reading/writing SERP settings, a SerpSetting interface for typed settings with SERP codes, and specific setting enums for HideAiGeneratedImages, SafeSearch, and SearchAssistVisibility. Feature flags have been added for SERP settings synchronization, widget-as-protection, embedded settings WebView, What's New entry, and new desktop browser setting.

settings/settings-api · high confidence

New API interface for VPN access state management

The network-protection-api module now exposes the NetworkProtectionAccessState interface, allowing consumers to query the current VPN access status (Locked or Unlocked) via a synchronous getState() method or a reactive Flow. It also provides a getScreenForCurrentState() method to retrieve the appropriate ActivityParams for launching the relevant UI screen based on the current state, simplifying navigation logic for clients.

network-protection-api · high confidence

New App Tracking Protection section on the New Tab page

Users can now see a dedicated App Tracking Protection section on the New Tab page, which displays the current status of the VPN (enabled, disabled, or revoked) and the number of trackers blocked. This section includes a toggle to enable or disable App Tracking Protection directly from the New Tab, allowing for quick access to privacy controls without navigating to the main settings.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/ui/newtab · high confidence

New AppBuildConfig API for build metadata and variant detection

A new API interface, AppBuildConfig, has been introduced to expose detailed build-time and runtime metadata to the application. This interface provides access to build identifiers such as application ID, version code, version name, and build flavor (INTERNAL, FDROID, or PLAY), as well as runtime device information including manufacturer, model, and SDK version. It also includes utility methods to detect installation states (new install vs. reinstall) and supports conditional logic based on build variants, such as determining if a build is internal or if the default variant is forced.

app-build-config/app-build-config-api · high confidence

New Compose UI components and base activity infrastructure in the Android Design System

The design-system module now includes a suite of new Jetpack Compose components, including DaxTopAppBar and DaxSearchTopAppBar for navigation headers, DaxButton for actions, DaxStatusIndicator for status display, and DaxAction for message/snackbar buttons. Additionally, the module introduces base activity and fragment classes (DuckDuckGoActivity, DuckDuckGoFragment, DuckDuckGoBottomSheetDialogFragment) to standardize Dagger injection and theming, along with edge-to-edge support utilities for bottom sheets and system bar insets.

android-design-system/design-system · high confidence

New Content Scope Scripts API interfaces for plugin integration

The content-scope-scripts-api module now exposes a set of Kotlin interfaces that allow other parts of the app to plug into the Content Scope Scripts (C-S-S) system. These include ContentScopeConfigPlugin for sending feature configuration and user preferences, ContentScopeJsMessageHandlersPlugin and WebViewCompatContentScopeJsMessageHandlersPlugin for handling JS messages, ContentScopeScriptsSubscriptionEventPlugin for subscription events, ContentScopeExperiments for retrieving active experiment toggles, and ContentScopeOptimizations for reporting performance optimization states. These interfaces are designed to be contributed as multibindings, enabling modular integration of C-S-S capabilities.

content-scope-scripts/content-scope-scripts-api · high confidence

New DI module provides core annotations, scopes, and Android injection infrastructure

The new \di\ module introduces the foundational building blocks for the application's dependency injection system. It defines key qualifiers such as \@ActivityContext\, \@AppCoroutineScope\, \@IsMainProcess\, and \@ProcessName\ to distinguish dependencies by their lifecycle or process context. The module also establishes a hierarchy of scoping annotations (\AppScope\, \ActivityScope\, \FragmentScope\, \ServiceScope\, \ReceiverScope\, \ViewScope\, \VpnScope\) to control dependency lifetimes. Furthermore, it provides the \AndroidInjector\ framework and base classes (\InjectableActivity\, \InjectableFragment\) that enable automatic dependency injection for Android components, along with lifecycle observer interfaces (\MainProcessLifecycleObserver\, \PirProcessLifecycleObserver\, \VpnProcessLifecycleObserver\) to manage process-specific initialization.

di · high confidence

New Dax Prompt Browser Comparison screen for re-engagement and win-back flows

Users may now see a new browser comparison prompt when the app detects they have stopped using it as their default browser or when they switch away from the app. This feature introduces a dedicated screen (DaxPromptBrowserComparisonActivity) that presents a comparison view and allows users to set DuckDuckGo as their default browser. The prompt is governed by the 'reactivateUsers' remote feature flag and includes two specific evaluation paths: a 'Re-engagement' path for users inactive for a week, and a 'Win-back' path for users who previously had the app as their default but switched. The implementation includes the necessary UI, ViewModel, and pixel tracking to measure interactions such as prompt display, button clicks, and whether the user successfully sets the default browser.

dax-prompts/dax-prompts-impl · high confidence

New Downloads screen implementation in downloads-impl module

The Downloads screen has been moved from the main :app module into the downloads-impl module, introducing a new UI implementation. This includes a new DataUriParser to improve parsing for data URL schemes, a DownloadsAdapter to render the list of downloads with support for empty states, headers, and a 'Notify Me' view, and a DownloadsViewModel to manage the download state and user interactions. Additionally, a FilenameExtractor has been added to better handle filename generation for downloads.

downloads-impl · high confidence

The navigation-api module introduces the GlobalActivityStarter interface, providing a centralized way to start Activities using strongly-typed parameters (ActivityParams) or deep links (DeeplinkActivityParams). This change allows developers to launch screens via explicit parameter objects or mapped deep-link strings, with support for starting activities for result using ActivityResultLauncher. It also includes helper extensions to safely extract serializable parameters from Intents, replacing ad-hoc intent handling with a structured, type-safe navigation contract.

navigation/navigation-api · high confidence

New Gradle tooling for module creation and AI config validation

The buildSrc now includes a new \ModuleCreator\ Gradle task that streamlines the creation of new feature modules by templating, wiring inter-module dependencies, and updating the app's build.gradle. It supports four module types: pure Kotlin API, Android-aware API, implementation, and internal. Additionally, a new \AiConfigChecker\ validates the project's AI configuration (CLAUDE.md, rules, docs, and skills) to ensure docs are reachable, references are valid, and frontmatter is used correctly.

buildSrc · high confidence

New JavaScript messaging API interfaces for WebView communication

The js-messaging-api module now exposes a set of new Kotlin interfaces to standardize how the app communicates with JavaScript in WebViews. This includes the \AddDocumentStartJavaScriptPlugin\ for injecting scripts before page load, \WebMessagingPlugin\ and \PostMessageWrapperPlugin\ for managing message registration and posting, and \WebViewCompatMessaging\ for handling incoming messages via a compatibility callback. These interfaces define the contract for features like subscription events and early script injection, allowing other parts of the codebase to implement these capabilities consistently.

js-messaging/js-messaging-api · high confidence

New JavaScript messaging implementation for subscription events and responses

The js-messaging-impl module now includes the core implementation for the JavaScript messaging framework, introducing RealJsMessageHelper to handle communication between the Android app and web views. This component serializes subscription events and JS request responses (including success and error states) into JSON using Moshi and executes them via WebView.evaluateJavascript, enabling features like SERP install-origin tracking and frontend subscription integration.

js-messaging/js-messaging-impl · high confidence

New KSP annotations and processors for Metro-based dependency injection and plugin generation

The codegen module introduces a suite of new KSP annotations and their corresponding processors to replace previous Dagger/Anvil-based DI and code generation. New annotations include @ContributeToActivityStarter for generating activity parameter mappers, @ContributesActivePlugin and @ContributesActivePluginPoint for managing remote-feature-flag-gated plugins, @ContributesPluginPoint for standard plugin points, @ContributesRemoteFeature for remote feature toggles, @ContributesServiceApi and @ContributesNonCachingServiceApi for Retrofit service generation, @ContributesViewModel and @ContributesWorker for component factories, @InjectWith for activity/fragment injection, and @PriorityKey for plugin ordering. The accompanying KSP processors in codegen-ksp generate the necessary Metro bindings, plugin point implementations, and mapper classes at compile time.

codegen-ksp, codegen/codegen-annotations, codegen/codegen-ksp · high confidence

New MacOsScreenWithEmptyParams activity starter added

A new activity parameter object, MacOsScreenWithEmptyParams, has been added to the macOS API module. This object implements the GlobalActivityStarter.ActivityParams interface, enabling the navigation system to start a specific macOS screen activity without requiring additional parameters.

macos/macos-api · high confidence

New ModalEvaluator interface for coordinating modal displays

The prompts-coordinator-api module now exposes the ModalEvaluator interface, allowing different modal types to define their own evaluation logic, priority, and lifecycle triggers (such as app resume or new tab page render). This enables the system to coordinate and arbitrate which modals are shown to users based on configurable rules and cooldown periods.

prompts-coordinator-api · high confidence

New PrivatePlayerMode API for Duck Player configuration

The ad-blocking API module now exposes a new \PrivatePlayerMode\ sealed class, providing a structured way to configure Duck Player's privacy settings. This API defines three distinct modes—Enabled, AlwaysAsk, and Disabled—allowing consumers of the ad-blocking module to programmatically control how the private player behaves.

ad-blocking-api · high confidence

New SERP Settings Sync and WebView-based Settings UI

This change introduces a new implementation for the app's settings, replacing the previous native UI with a WebView-based approach (SettingsWebViewActivity) that renders settings pages from the web. It adds a complete SERP (Search Engine Results Page) settings synchronization system, allowing the web frontend to read, write, and subscribe to native settings changes via a DataStore-backed store and JavaScript messaging handlers. The implementation includes specific handlers for opening native screens (like Duck AI features), managing subscription events to keep the web view in sync, and detailed telemetry pixels to track usage and store errors.

settings/settings-impl · high confidence

New Saved Sites API and data models

The saved-sites module now exposes a new API layer defining the core data structures and repository contracts for managing user bookmarks and favorites. This includes the \SavedSitesRepository\ interface for CRUD operations, new data models (\SavedSite\, \Bookmark\, \Favorite\, \BookmarkFolder\) to represent the saved content, and service interfaces (\SavedSitesImporter\, \SavedSitesExporter\) to handle importing and exporting bookmarks in Netscape HTML format. Additionally, a \SavedSitesViewsProvider\ interface is introduced to supply UI views for the favorites grid, supporting configuration for different placements like the New Tab Page and Focused State.

saved-sites/saved-sites-api · high confidence

New Settings WebView ViewModel for SERP and Content Script Integration

A new SettingsWebViewViewModel has been introduced to manage the lifecycle and navigation of the settings WebView. It handles URL loading and exit commands, and on resume, it checks the SERP settings feature flag to synchronize subscription event data from Content Scope Scripts plugins to the UI.

settings-impl · high confidence

New Tab Page API plugin architecture and escape hatch support

The New Tab Page API module now exposes a plugin-based architecture for building the New Tab Page, including interfaces for the main page (NewTabPagePlugin), individual sections (NewTabPageSectionPlugin), and shortcuts (NewTabPageShortcutPlugin), along with providers to resolve them. It introduces an EscapeHatchTargetResolver to determine which tab to return to via the escape hatch, and an NtpAfterIdleManager to track idle-return events and manage the user setting for the return-to-last-tab hatch. Additionally, the chat shortcut label has been updated to 'Duck.ai'.

new-tab-page/new-tab-page-api · high confidence

New Tab page now supports customizing and reordering shortcuts

Users can now manage their New Tab shortcuts directly within the New Tab page settings. This change introduces a new settings interface that allows users to toggle the visibility of specific shortcuts and reorder them via drag-and-drop interactions. The implementation includes new ViewModels and UI adapters to handle the state management, persistence of user preferences, and tracking of shortcut usage analytics.

new-tab-page-impl · high confidence

New Templates tab in the Android Design System showcases PageHeader component variants

The Android Design System now includes a dedicated Templates tab, implemented via a new TemplatesFragment and TemplatesPane, which displays various states of the DaxPageHeader Compose component. This internal UI addition allows developers to preview and verify the appearance of the PageHeader with different configurations, including optional status indicators (Off, On, AlwaysOn), icons, body text, and learn-more actions, ensuring consistent rendering within the design system.

android-design-system/design-system-internal/src/main/java/com/duckduckgo/common/ui/internal/ui/component/templates · high confidence

New VPN connectivity loss listener interface

Added the VpnConnectivityLossListenerPlugin interface in the VPN API module, which defines callbacks for detecting VPN connectivity loss and reconnection events. This interface allows components to react when the VPN connection drops while the device retains general connectivity, or when the VPN connection is restored, enabling more robust handling of network state changes within the app-tracking-protection system.

app-tracking-protection/vpn-api/src/main/java/com/duckduckgo/mobile/android/vpn/service/connectivity · high confidence

New VPN network API interface and callback definitions

The VPN network module now exposes a new \VpnNetwork\ interface that defines the lifecycle methods for managing the networking layer, including creating, starting, running (with a TUN file descriptor), stopping, and destroying the network context, as well as retrieving the MTU size. Additionally, a \VpnNetworkCallback\ interface is introduced to allow the application to handle network events such as unexpected exits, errors, DNS resolution results, and domain/address blocking decisions, along with new data classes for DNS, SNI, domain, and address records to support these callbacks.

vpn-network/vpn-network-api · high confidence

New ad-click attribution pixel reporting

The ad-click module now includes a new daily reporting worker that tracks page loads with ad attribution. This implementation adds a new pixel name (m\_pageloads\_with\_ad\_attribution) and associated parameters to measure ad click detection and active states, with counts aggregated and fired daily via a background worker scheduled through the app lifecycle.

ad-click/ad-click-impl/src/main/java/com/duckduckgo/adclick/impl/pixels · high confidence

New app-specific breakage reporting flow

Users can now report breakages for specific installed apps directly from the App Tracking Protection interface. This change introduces a new activity that displays a list of installed apps, allowing users to select one and submit a detailed report including the app's package name, a selected breakage category, and custom feedback. The implementation includes the necessary UI components, view models, and a metadata reporter to capture VPN state information for the selected app, streamlining the process of diagnosing app-specific issues.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/breakage · high confidence

New browser-ui module introduces autocomplete, menu, and return-hatch components

The browser-ui module has been created, consolidating core browser interface components. This includes a new autocomplete system with a kill-switchable delete button for history suggestions, a bottom-sheet browser menu that supports Duck.ai sections and VPN status, and a New Tab 'Return Hatch' feature that lets users return to, close, or burn their last tab after inactivity. The module also adds a pulse animation utility for UI highlights and an input mode tab layout with theme-aware icon handling.

browser/browser-ui · high confidence

New common-utils module with edge-to-edge support and utility classes

The common/common-utils module has been introduced, providing a centralized library of shared utilities and infrastructure. This includes a comprehensive edge-to-edge implementation (EdgeToEdgeHandler, EdgeToEdgeProvider, and remote feature toggles) that allows the app to apply window insets for status and navigation bars across specific feature buckets like the browser, settings, and VPN. The module also adds essential utility classes such as ViewModel factories for various scopes, time and date providers, coroutine helpers (ConflatedJob, DispatcherProvider), and URI/URL extension functions. Additionally, it includes a new AndroidManifest declaring the POST\_NOTIFICATIONS permission and device information utilities to detect form factors (phone vs. tablet).

common/common-utils · high confidence

New configurable New Tab page with idle-return hatch and settings

This change introduces a new, configurable New Tab page implementation that replaces the legacy view. Users can now customize the layout of the New Tab page via a dedicated settings activity, including dragging and reordering sections and managing shortcuts. A key behavioral addition is the 'Return to Last Tab' hatch, which appears after an idle return to the app, allowing users to quickly jump back to their previous tab; this feature includes configurable idle timeouts and is suppressed in Fire mode. The implementation also adds comprehensive telemetry (pixels) to track NTP displays, hatch interactions, and section customizations, and registers a new \NewTabSettingsActivity\ in the manifest to support these user-facing changes.

new-tab-page/new-tab-page-impl · high confidence

Users will now see a new opt-in prompt when Cookie Pop-Up Protection is enabled for the first time, offering the choice to keep the protection on or turn it off, with behavior (such as back-dismissal and button copy) controlled by remote feature flags. Additionally, the autoconsent system now includes a reload loop detector that monitors CMP interactions per WebView tab and fires a daily error pixel if a loop is detected, helping to prevent infinite reload cycles caused by cookie consent dialogs.

autoconsent-impl · high confidence

New debug activity for managing VPN exception rules

An internal debug screen (ExceptionRulesDebugActivity) has been added to the VPN internal module, allowing users to view and toggle app-tracking exception rules directly. The activity lists installed apps with blocked trackers, displays their status against current exclusion rules, and enables real-time toggling of individual domain exceptions via broadcast intents, while also supporting edge-to-edge display and safe handling of application package queries.

vpn-internal · high confidence

New debug receiver and UI components for App Tracking Protection exclusion rules

This change introduces the \ExceptionRulesDebugReceiver\ and \ExclusionRulesRepository\ to the VPN internal feature rules module, enabling the persistence and restoration of app tracker exclusion rules across VPN restarts to prevent data loss. It also adds \RuleAppView\ and \RuleTrackerView\ custom Android views, which provide the UI components for displaying and managing these exclusion rules in the interface.

app-tracking-protection/vpn-internal/src/main/java/com/duckduckgo/vpn/internal/feature/rules · high confidence

New debug receivers for triggering App Tracking Protection notifications and fake tracker data

Two new debug-only broadcast receivers have been added to the VPN implementation to facilitate testing of App Tracking Protection features. The \DeviceShieldNotificationsDebugReceiver\ allows developers to manually trigger weekly and daily VPN status notifications via ADB commands, while the \SendTrackerDebugReceiver\ enables the injection of fake tracker data into the app's statistics repository to simulate tracking activity. Both components are restricted to debug builds and are registered via dependency injection scopes.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/debug · high confidence

New downloads module implementation

The downloads-impl module introduces the core implementation for the downloads feature, including the DownloadsActivity and OpenDownloadedFileActivity, a new AndroidFileDownloader that routes network and data URL downloads, and a DataUriParser for handling data URI schemes. It also provides a DefaultDownloadsRepository backed by a local database, a DefaultFileDownloadNotificationManager for managing download notifications, and a DownloadConfirmationFragment for user confirmation dialogs.

downloads/downloads-impl · high confidence

New exclusion list UI for App Tracking Protection

The App Tracking Protection feature now includes a dedicated Exclusion List screen, allowing users to view and manage apps that are excluded from protection. This update introduces a new \TrackingProtectionExclusionListActivity\ and a corresponding \ExclusionListAdapter\ to display a list of excluded apps, along with informational panels and filters. Users can now toggle protection for individual apps, view reasons for exclusion (such as known issues or manual exclusions), and access an FAQ or report issues directly from the list. The UI also supports edge-to-edge display and includes dialogs for manually enabling/disabling protection and restoring default settings.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/apps/ui · high confidence

New exclusion list interfaces for app categorization and system app overrides

The VPN API module now exposes two new interfaces to support the exclusion list feature: \AppCategoryDetector\, which maps app package names to categories, and \SystemAppOverridesProvider\, which supplies a list of system app packages to be included in the exclusion list. These interfaces define the contract for how app categories are determined and which system apps are exempted, laying the groundwork for the exclusion list data store and UI implementations.

app-tracking-protection/vpn-api/src/main/java/com/duckduckgo/mobile/android/vpn/exclusion · high confidence

New feature toggle API and metrics infrastructure

The feature-toggles-api module now exposes a new feature flag framework alongside the legacy API. This includes the FeatureToggles class for creating proxy-based toggle interfaces, the Toggle interface with cohort enrollment and Flow-based state observation, and the FeatureTogglesInventory for listing active experiments. Additionally, a new MetricsPixel system with conversion windows and a MetricsPixelPlugin interface has been added to handle experiment telemetry, while the CachedToggleStore provides a concurrent, listener-enabled cache for toggle states.

feature-toggles/feature-toggles-api/src/main/java/com/duckduckgo/feature/toggles · high confidence

New feature-toggle implementation and metrics infrastructure

The feature-toggles module has been replaced with a new implementation that introduces a plugin-based architecture for feature flags, target matching, and metrics. This update adds support for targeting experiments by locale and minimum SDK version, and introduces a robust metrics system that tracks user engagement (searches, app usage, Duck.ai prompts) within specific conversion windows. It also integrates with Remote Messaging by allowing message targeting based on active experiments and enabled feature flags.

feature-toggles/feature-toggles-impl/src/main/java/com/duckduckgo/feature/toggles · high confidence

New fingerprinting protection features for battery, canvas, hardware, screen size, and temporary storage

The fingerprint protection module now includes implementation plugins for five new privacy features: Fingerprinting Battery, Canvas, Hardware, Screen Size, and Temporary Storage. Each feature is registered via Metro's dependency injection and provides both a configuration plugin (to expose settings to content scope scripts) and a feature plugin (to store and manage remote configuration data), enabling the browser to apply specific protections against these fingerprinting vectors.

(repo-wide) · high confidence

New in-app flows for Email Protection signup and Google Password Manager import

The autofill module now includes the implementation for in-context Email Protection sign-up and the web-based import flow for Google Password Manager. This adds the ViewModels and supporting logic to manage the Email Protection webview lifecycle, handle user navigation, and track pixels, as well as the infrastructure to parse, validate, and import credentials from Google Password Manager CSV exports or the web export flow.

autofill-impl · high confidence

New install-source tracking and Samsung Galaxy Store attribution

The installation module now extracts the installer package name using modern Android APIs (API 30+) and sends analytics pixels to indicate whether the app was installed via the Play Store. It also conditionally sends the full installer package name when a remote feature flag is enabled and the installer is in an included list (supporting wildcards). Additionally, installs from the Samsung Galaxy Store are now attributed with a specific campaign origin and variant, controlled by a separate feature flag.

installation/installation-impl · high confidence

The internal App Components gallery now includes a dedicated tab for UI templates and a new activity that lets developers toggle between light/dark themes and enable the new brand design updates. This location provides the supporting infrastructure for that gallery: a Compose lifecycle helper for embedding Compose in XML layouts, a custom PlatformLabelView to tag components as Compose or View, and the data store and view model logic that persists and observes the selected theme and brand design update flags.

android-design-system/design-system-internal/src/main/java/com/duckduckgo/common/ui/internal/ui · high confidence

New internal Autofill dev settings screen

An internal settings screen has been added to the app, accessible via the main settings menu, to provide developers with tools for testing and debugging autofill and email protection features. This screen allows toggling the autofill JavaScript environment between production and debug modes, managing saved logins (including adding sample data, clearing all logins, and viewing counts), and testing password import flows from Google (including launching the import web flow, clearing cookies, and simulating previous imports). It also includes controls for clearing breakage reporting history, resetting engagement KPIs, managing email protection sign-in state, and testing the OS credential exchange import.

attributed-metrics/attributed-metrics-internal · high confidence

New internal Autofill dev settings screen

An internal settings screen has been added to the app, accessible via the main settings menu, to provide developers with tools for testing and debugging autofill and email protection features. This screen allows toggling the autofill JavaScript environment between production and debug modes, managing saved logins (including adding sample data, clearing all logins, and viewing counts), and testing password import flows from Google (including launching the import web flow, clearing cookies, and simulating previous imports). It also includes controls for clearing breakage reporting history, resetting engagement KPIs, managing email protection sign-in state, and testing the OS credential exchange import.

autofill/autofill-internal · high confidence

New internal Crash and ANRs settings screen for developers

An internal settings screen has been added to the app, accessible via the internal features menu, allowing developers to view recent crash and ANR logs, manage minidumps, and configure crash reporting. This feature includes a new activity that lists capabilities such as a minidump browser (for viewing, sharing, and deleting local crash dumps), a crashpad upload configuration dialog (to set upload URLs and rate-limiting options), and native crash actions (triggering, dumping, and uploading native crashes). The screen also displays a live list of recent ANRs and crashes pulled from the local database, and integrates with the Crashkit library for native crash handling.

anrs/anrs-internal · high confidence

New internal Duck.ai developer settings and debugging tools

Internal builds now include a dedicated Duck.ai developer settings entry in the internal features menu, providing access to several debugging and testing capabilities. Users can configure a custom Duck.ai server URL, view and manage usage warning dismissals, seed long chats for testing, and toggle the native input field for E2E automation. Additionally, a native storage debug server is available to inspect and modify chat data and settings via HTTP endpoints.

duckchat/duckchat-internal · high confidence

New internal Feature Flag Inventory screen

An internal settings screen has been added to allow users to view and manage feature flags. This new activity displays a searchable, scrollable list of all available feature toggles, including support for nested sub-features, and enables users to toggle features on or off directly from the interface.

feature-toggles/feature-toggles-internal · high confidence

New internal PIR development settings and debugging tools

An internal PIR (Personal Information Removal) development settings module has been added, providing a suite of debugging and configuration tools for internal users. This includes a central \PirDevSettingsActivity\ that acts as a hub for accessing specific debug screens: \PirDevScanActivity\ for running and monitoring scans, \PirDevOptOutActivity\ for managing opt-out processes, \PirDevEmailActivity\ for handling email confirmation jobs, \PirDevBrokerConfigActivity\ for updating broker configurations, and \PirDevWebViewActivity\ for executing debug scans, opt-outs, and email confirmations via a web view. The module also introduces \InternalPirDashboardUrlProvider\ to support custom dashboard URLs and \PirInternalSettingsDataStore\ for persisting these settings, along with an \InternalFeaturePlugin\ to expose these tools within the app's internal feature interface.

pir/pir-internal · high confidence

New internal Subscriptions Settings screen for debugging and testing

An internal developer settings screen has been added to the app, accessible via the internal features menu. This screen provides a suite of debugging and testing tools for the subscription system, including the ability to override the subscriptions base URL, invalidate V2 auth tokens, copy subscription and auth data to the clipboard, override the local subscription purchase date, cancel pending plan changes, and recover an existing subscription regardless of location.

subscriptions/subscriptions-internal · high confidence

New internal debug activities for PIR email and webview operations

Added PirDevEmailActivity and PirDevWebViewActivity to the internal settings module, providing developers with UI controls to manually trigger and inspect PIR debug operations. PirDevEmailActivity allows selecting and managing email confirmation jobs (including fetching links and viewing results), while PirDevWebViewActivity serves as a unified debug interface for running scan, opt-out, and email confirmation tasks in a WebView context, with both activities updated to support edge-to-edge display.

pir-internal · high confidence

New internal settings screen for App Tracking Protection

Internal users now have access to a dedicated App Tracking Protection settings screen, accessible via the new 'AppTP dev settings' entry in the internal features menu. This screen allows internal testers to manage app protection states directly, including options to protect all apps, unprotect all apps, and restore default protection settings, while also exposing controls for debug logging, bug reporting, and tracker history management.

app-tracking-protection/vpn-internal/src/main/java · high confidence

New internal settings screen to force-load custom privacy configurations

Developers and testers can now access a new internal settings screen (PrivacyConfigInternalSettingsActivity) that allows them to toggle a custom privacy config URL and force-load that configuration into the app. This is supported by a new data store for dev settings, an API interceptor to route config requests to the custom URL, and a patch interceptor that applies JSON patches from assets to the config response before it is used.

privacy-config/privacy-config-internal · high confidence

New internal sync settings and Exchange v2 pairing debug screens

Developers now have access to a dedicated internal sync settings screen and an Exchange v2 pairing debug interface. The new \SyncInternalSettingsActivity\ provides a centralized hub for managing sync state, including account creation, QR code scanning for pairing, device renaming, recovery code handling, and toggles for test sync warnings. Additionally, the \SyncV2PairingDebugActivity\ offers granular control over the v2 pairing process, allowing developers to force specific protocol versions, view detailed session logs with filtering, and manually trigger scan or present sessions. These tools are exposed via the \InternalSyncFeature\ plugin and include a \TestSyncWarningPlugin\ for simulating sync warnings.

sync/sync-internal · high confidence

New local storage for granular site permissions and temporary grants

The site permissions store now persists user choices for camera, microphone, DRM, and location access using a new \site\_permissions\ database table, distinguishing between explicit user decisions (like 'Ask Every Time') and unset defaults. Additionally, a new \site\_permission\_allowed\ table tracks temporary, tab-specific permission grants that automatically expire after 24 hours, supporting features like one-time camera or microphone access without permanent site settings changes.

site-permissions-store · high confidence

New modular data-clearing API and Fire dialog interfaces

The data-clearing module now exposes a new plugin-based API that allows different data sources (such as browsing history, cookies, tabs, and Duck.ai chats) to be cleared by dedicated plugins rather than a legacy monolithic path. This includes the \DataClearingPlugin\ interface for implementing cleanup logic, the \DataClearingTrigger\ for invoking clears, and a \ClearableData\ type hierarchy to specify exactly what data to remove. Additionally, a new \FireDialog\ interface and \FireDialogProvider\ are introduced to standardize the Fire button experience across various entry points, including browser tabs, settings, the tab switcher, and Duck.ai chat contexts.

data-clearing/data-clearing-api · high confidence

New multi-stage default browser prompts with configurable timing

Users will now see a structured, multi-stage set of prompts encouraging them to set DuckDuckGo as their default browser. This new system introduces a message dialog, a highlighted menu item, and a final persistent message, with the specific prompts shown depending on how many days the app has been active. The timing for each stage is controlled by remote feature toggles, allowing the product team to adjust the schedule without a new app release.

app/src/main/java/com/duckduckgo/app/browser/defaultbrowsing · high confidence

New network utility functions for DNS and route handling

Added a new NetworkUtil utility class that provides helper functions to retrieve the system's active network default DNS servers and search domains, identify local IP addresses, convert IPv4 addresses to VPN routes, and enumerate underlying network connections (default, Wi-Fi, and cellular). These utilities support the VPN service's ability to configure DNS settings and manage network routing based on the device's current connectivity state.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/network/util · high confidence

New plugin interfaces for VPN notifications and service callbacks

The VPN API module now exposes new plugin interfaces to decouple notification content and service lifecycle handling. \VpnEnabledNotificationContentPlugin\ and \VpnReminderNotificationContentPlugin\ allow external modules to provide dynamic content, priority, and actions for VPN status and reminder notifications. Additionally, \VpnServiceCallbacks\ provides a standardized interface for listening to VPN lifecycle events (starting, started, stopped, etc.), and \VpnSocketProtector\ defines the contract for protecting sockets from the VPN tunnel.

app-tracking-protection/vpn-api/src/main/java/com/duckduckgo/mobile/android/vpn/service · high confidence

New plugin interfaces for migrations and worker injection

Added two new plugin interfaces to the common utilities library: MigrationPlugin, which defines a contract for running migrations with version tracking, and WorkerInjectorPlugin, which provides a mechanism to inject dependencies into Android ListenableWorker instances. These interfaces are annotated with @ContributesPluginPoint to integrate with the app's dependency injection framework.

common/common-utils/src/main/java/com/duckduckgo/common/utils/plugins/migrations, common/common-utils/src/main/java/com/duckduckgo/common/utils/plugins/worker · high confidence

New plugin interfaces for pixel parameter control and ATB handling

Added three new plugin interfaces in the common utils module to manage pixel data: PixelInterceptorPlugin for attaching OkHttp interceptors, PixelParamRemovalPlugin for specifying which pixels should have ATB and App version parameters stripped, and PixelRequiringAtbPlugin for defining which pixels must include ATB when the ATB opt-in feature is enabled.

common/common-utils/src/main/java/com/duckduckgo/common/utils/plugins/pixel · high confidence

New privacy report UI for app tracking protection

The app tracking protection privacy report now features a new UI implementation. The \DeviceShieldAppTrackersInfo\ activity displays the report with edge-to-edge support, while the \DeviceShieldFragment\ presents a call-to-action card showing the number of trackers blocked, the latest app responsible, and other blocked apps. The \PrivacyReportViewModel\ powers this view by combining VPN state with tracker blocking statistics from the repository, ensuring the UI reflects the current protection status and onboarding state.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/ui/privacyreport · high confidence

New prompts-coordinator arbitrates modal and New Tab Page prompt surfaces

A new prompts-coordinator module has been added to manage and arbitrate the shared prompt surface between the Modal Coordinator and the Remote Messaging Framework (RMF) inline card. This system enforces strict gaps between prompts to prevent overlap: modals are gated by a 24-hour cooldown, while New Tab Page cards are limited to a 10-minute gap. The coordinator uses a kill-switch feature toggle to allow fallback to legacy independent behavior if needed. Additionally, the module introduces prompt exposure metrics to track how often prompts reach users, reporting data via pixels for analysis.

prompts-coordinator/prompts-coordinator-impl · high confidence

New public API interfaces for remote privacy features

The privacy-config-api module now exposes a set of public Kotlin interfaces that allow other parts of the app to interact with remotely configured privacy features. These include AmpLinks for detecting and processing AMP links, ContentBlocking and Https for managing exception lists, Drm for checking DRM permissions, Gpc for managing Global Privacy Control settings and headers, TrackerAllowlist for allowlist rules, TrackingParameters for cleaning URLs, and UnprotectedTemporary for temporary exceptions. Additionally, the module defines the PrivacyFeaturePlugin interface for storing remote config data and the PrivacyConfigCallbackPlugin for notifying when config updates are downloaded or persisted.

privacy-config/privacy-config-api · high confidence

New public APIs for sync state, engine, and setup

The sync module now exposes a set of new public interfaces in the sync/sync-api layer to support broader sync capabilities. DeviceSyncState provides visibility into feature flags, sign-in status, and connected devices, while SyncAutoRestore enables automatic account restoration. SyncCrypto has been extended to support byte arrays alongside text, and SyncStateMonitor allows clients to observe sync readiness and errors via a Flow. The sync engine is now driven by SyncEngine with explicit triggers (background, app open, data change, etc.), and data handling is standardized through SyncableDataProvider, SyncableDataPersister, and DeletableDataManager, which define how changes, conflicts, and deletions are managed. Additionally, SyncScreens and SyncUrlIdentifier streamline the setup flow by providing navigation parameters and URL interception for pairing codes.

sync/sync-api · high confidence

New release automation, code quality, and developer tooling scripts

This change introduces a suite of new scripts to support the release process and developer workflows. The release pipeline now includes dedicated scripts to create Asana tasks for public, internal, and hotfix releases, along with utilities to collect Asana task IDs from commits and update PIR broker JSON bundles. Code quality is enhanced by a new script that validates Android native libraries for 16 KB page-size alignment, and developer productivity is supported by tools for generating Breakpad symbols, analyzing Google Play Store review anomalies, and cleaning up stale Kotlin feature flags.

scripts · high confidence

New shared desktop app promotion screen

A new, unified screen for promoting the DuckDuckGo desktop browser has been added. This screen allows callers to customize the title, body text, illustration, and download link, and supports actions such as sharing the download link, copying it to the clipboard, and dismissing the prompt. It includes a plugin-based interaction handler system to allow other parts of the app to react to user interactions like impressions, share completions, and dismissals, and is available in multiple languages.

desktop-app-promotion/desktop-app-promotion-impl · high confidence

New site-permissions-impl module with DRM policy engine and redesigned permission dialogs

This change introduces the \site-permissions-impl\ module, which centralizes site permission management and introduces a new DRM policy engine. For users, this means a redesigned permission dialog experience for camera, microphone, and location, along with a new policy system for DRM content that can automatically grant, deny, or prompt based on user settings, global toggles, and allow/block lists. The implementation also migrates permission storage to a dedicated Room database (\site\_permissions.db\) and adds telemetry pixels to track permission dialog interactions and auto-grant reasons.

site-permissions/site-permissions-impl · high confidence

New statistics API interfaces for pixels and wide-event flows

The statistics-api module now exposes the core interfaces for analytics collection: the Pixel interface defines how anonymous event pixels are fired (including Count, Daily, and Unique types) and lists the supported pixel parameters and values, while the WideEventClient interface introduces a structured flow-based system for tracking multi-step user journeys with start/step/finish/abort operations, configurable sampling, interval bucketing, and cleanup policies. These interfaces establish the contract for sending telemetry data, enabling downstream implementations to handle event dispatch, persistence, and wide-event lifecycle management.

statistics-api · high confidence

New subscription implementation module

The subscriptions-impl module introduces the core backend logic for the new subscription system, including a SubscriptionsManager for handling purchases and account state, an AuthClient for Auth API v2 integration, and a PlayBillingManager for Google Play Billing interactions. It also adds a SubscriptionFeedbackViewModel for user feedback collection and a SubscriptionOnboardingViewModel to drive the new onboarding flow.

subscriptions-impl · high confidence

New synchronous and asynchronous native library loading API

A new LibraryLoader API has been introduced to handle native library loading with improved reliability. It provides a synchronous method for immediate loading and an asynchronous method that executes on the main thread to prevent page alignment crashes, notifying callers via a success or failure listener.

library-loader/library-loader-api · high confidence

New tracker-detection-api module exposes core detection interfaces and models

The tracker-detection-api module now provides a public API for tracker detection capabilities, introducing interfaces such as TrackerDetector for evaluating URLs against blocklists, CloakedCnameDetector for resolving CNAME cloaking, and EntityLookup for identifying tracker entities. It also exposes data models like TrackingEvent and Entity, along with supporting interfaces for managing blocklist experiments (BlockListExperiment), downloading tracker data (TrackerDataDownloader), and tracking blocked history (WebTrackersBlockedHistory).

tracker-detection/tracker-detection-api · high confidence

New warning layouts and malicious site protection integration

The browser now displays dedicated warning screens when malicious sites are detected. Users see a MaliciousSiteBlockedWarningLayout for malware, phishing, and scam threats, and an SslWarningLayout for SSL errors; both layouts disable tab swiping to prevent accidental navigation and allow users to proceed, leave the site, or report errors. The underlying MaliciousSiteBlockerWebViewIntegration intercepts web requests to check URLs against threat feeds, respects user exemptions, and is controlled by the new WebViewCompatFeature remote configuration flags.

app/src/main/java/com/duckduckgo/app/browser/webview · high confidence

Per-site user-agent branding via Client Brand Hints

The user-agent module now supports dynamically switching the SEC-CH-UA client hint branding (DuckDuckGo, Google Chrome, or Android WebView) on a per-site basis. This is driven by a new remote-config feature gate (clientBrandHint) that allows specific domains to be assigned a custom brand, while others use the default. The implementation includes a new ClientBrandHintProvider interface and RealClientBrandHintProvider that manages these branding changes, a UserAgentPlugin to store and retrieve exception lists and feature toggles from remote config, and dedicated Room databases for persisting brand hint settings and user-agent exceptions.

user-agent/user-agent-impl · high confidence

Persist per-site desktop mode preferences

The site-preferences module now implements persistent storage for desktop mode settings, allowing the browser to remember a user's choice to view a specific site in desktop mode across sessions. This change introduces a new Room-based repository (RealSitePreferencesRepository) and database schema to store domain-level preferences, replacing the previous session-only behavior. A remote feature toggle (RememberDesktopModeFeature) controls this capability, defaulting to internal, and the implementation includes a feature flag to revert to legacy in-memory behavior if needed.

site-preferences/site-preferences-impl · high confidence

Privacy Dashboard module initialization and documentation

The privacy-dashboard module has been initialized with core infrastructure files, including a new README that explains the cross-platform architecture (JS UI with native orchestration) and links to relevant documentation. The module structure now includes API and implementation subdirectories with standard build configurations (.gitignore, proguard-rules.pro) and a lint baseline file that suppresses specific warnings for deny-listed APIs and deprecated methods within the dashboard's view models and tests.

privacy-dashboard · high confidence

Remote configuration of DRM exceptions and feature state

The DRM feature now supports remote configuration, allowing the enabled state, minimum supported version, and specific domain exceptions to be managed via server-side privacy config updates. Users will see DRM permissions applied based on the latest remote policy, including the ability to enable or disable the feature globally and whitelist specific domains for Widevine/DRM content playback.

privacy-config/privacy-config-impl/src/main/java/com/duckduckgo/privacy/config/impl/features/drm · high confidence

SERP Easter Egg Logo viewer and favorite management

This module adds the implementation for the SERP Easter Egg Logos feature, including a dedicated activity to display the discovered logo with animations, a JavaScript interface to extract the logo type and URL from the search page, and a data store to persist the user's favorite logo choice. It also registers the remote feature toggle for controlling the 'set as favorite' capability.

serp-logos/serp-logos-impl · high confidence

Saved Sites module initialization and baseline configuration

The saved-sites module has been initialized with its core submodules (api, impl, store, internal). This includes adding a README describing the module's purpose (managing bookmarks and favorites), establishing standard build configurations like .gitignore and ProGuard rules, and generating lint-baseline.xml files to suppress existing warnings. The baselines specifically acknowledge current usage of the DenyListedApi (such as setRawStoredState and direct SharedPreferences access) and missing plural quantity definitions in localized strings, ensuring the module builds cleanly without blocking on these pre-existing issues.

saved-sites · high confidence

Settings sync implementation added

The sync-settings-impl module now provides the core persistence and data provider logic for synchronizing user settings across devices. This includes the SettingsSyncDataPersister, which handles merging remote changes and resolving conflicts using deduplication or server-wins strategies, and the SettingsSyncDataProvider, which collects local changes and encrypts them before transmission. A new Room entity, SettingsSyncMetadataEntity, tracks modification timestamps to ensure accurate delta syncing.

sync-settings-impl · high confidence

Subscription onboarding API definitions

The subscriptions-api module now exposes the core interfaces for the native subscription onboarding flow, including \SubscriptionOnboardingStepPlugin\ for defining individual onboarding steps, \SubscriptionOnboardingController\ for managing navigation and step completion, and supporting data classes like \SubscriptionOnboardingCompletionSummaryRow\ and \SubscriptionOnboardingStepOutcome\. This provides the contract for feature modules to contribute steps to the onboarding wizard and for the host to coordinate the flow.

subscriptions-api · high confidence

Support for importing credentials via FIDO Credential Exchange Format

Users can now import saved logins and notes from other apps using the FIDO Credential Exchange Format (CXF). This change introduces the credential-exchange-impl module, which includes a launcher to initiate the import flow and a payload parser that processes the exported JSON. The implementation specifically handles basic authentication credentials and notes, mapping them into the app's internal credential format while gracefully skipping any unreadable or unsupported item types within the payload.

credential-exchange-impl · high confidence

Supports experiment cohort and feature flag matching attributes in remote messaging

The feature-toggles-impl module now provides plugins that allow remote messaging configurations to target users based on their active feature toggles and experiment cohorts. Specifically, the new RMFExperimentMatchingAttributePlugin enables matching against active experiments and their assigned cohorts (e.g., checking if a user is in a specific experiment cohort), while the RMFToggleMatchingAttributePlugin allows matching based on whether specific feature flags are enabled. Additionally, a new MetricsPixelStore implementation has been added to track and store metric pixel data using SharedPreferences, supporting the recording of metric counts and pixel firing status.

feature-toggles-impl · high confidence

Sync library encryption and native integration

The sync library now includes a new native crypto implementation (SyncNativeLib) that handles account key generation, login preparation, and data encryption/decryption. This change introduces lazy loading of the native 'ddgcrypto' library to defer initialization until needed, and adds comprehensive instrumentation tests verifying deterministic primary key generation, non-deterministic secret keys, and successful encrypt/decrypt cycles for bookmark data.

sync/sync-lib · high confidence

Tracker Detection System (TDS) data is now persisted in a dedicated local database

The tracker-detection-impl module now manages its own Room database (tracker\_detection.db) to store TDS data, including trackers, entities, domains, and metadata. This change introduces a new database schema with version 1, DAOs for CRUD operations, and DI bindings to provide the database instance and DAOs. It also includes JSON adapters for serializing/deserializing tracker actions and comprehensive unit tests for all database operations.

tracker-detection/tracker-detection-impl · high confidence

Unified device list sync implementation

The sync module now supports a unified device list architecture, introducing a new RSA-3072 \account\_info\ keypair to encrypt cross-credential \device\_info\ blobs. This change adds a complete set of components for key management, encryption, and decryption, including a repairer to add missing \ddg\ wraps to existing keys, a migrator to backfill \device\_info\ for existing users, and a publish watcher to handle race conditions during the initial write. The implementation also registers the necessary sync setup, recovery, and device management activities in the Android manifest.

sync/sync-impl · high confidence

Unified device list: new account\_info key management and device\_info encryption

The sync implementation now introduces a unified device list architecture centered on a new account-wide \account\_info\ RSA-3072 keypair. This change adds dedicated components to manage the lifecycle of this key (creation, wrapping for third-party credentials, and server registration), encrypt and decrypt the new \device\_info\ blob using the account key, and handle the one-time migration for existing signed-in users to backfill their device info. It also includes the logic to build and send these new fields during account signup, ensuring the account, its encryption key, and the device's info are created atomically.

sync-impl · high confidence

Web Compatibility feature implementation

This change introduces the implementation for the webCompat feature, enabling the browser to handle specific JavaScript messages (webShare, permissionsQuery, screenLock, screenUnlock) and store configuration data via a new local database. It adds plugins to integrate with the Content Scope Scripts and WebView compatibility systems, ensuring these web compatibility APIs are available to websites.

web-compat/web-compat-impl · high confidence

Windows API UI navigation parameter added

A new Kotlin object, WindowsScreenWithEmptyParams, has been added to the Windows API module's UI package. This object implements the GlobalActivityStarter.ActivityParams interface, providing a concrete parameter set for launching the Windows Activity Screen from other parts of the application.

windows/windows-api · high confidence

The Windows implementation module now includes a new activity and UI for the Windows download page, featuring a 'Share Link' button that opens a system share dialog. This change introduces tracking for share interactions via a broadcast receiver and pixel events, and conditionally appends an origin query parameter to the shared URL based on a remote feature toggle, allowing the app to attribute downloads back to the Android settings funnel.

windows/windows-impl · high confidence

YouTube ad-blocking extension with scriptlet injection and contingency messaging

The ad-blocking module now includes a dedicated extension for YouTube that downloads and injects scriptlets (ublock-filters) into YouTube pages to block ads. This extension is gated by feature flags and includes a contingency messaging system that displays a bottom-sheet notification if ad-blocking fails or is disabled. The implementation also adds an omnibar animation provider to show a badge on YouTube video pages, settings activities for managing ad-blocking preferences, and pixel tracking for ad-blocking state and user interactions.

ad-blocking/ad-blocking-impl · high confidence

API

Duck.ai API module introduces public interfaces for feature state, input handling, and contextual chat

The \duckchat-api\ module now exposes a set of public interfaces that define the contract for Duck.ai integration across the app. \DuckAiFeatureState\ provides \StateFlow\ booleans to control the visibility of UI elements such as the settings entry, input screen, omnibar shortcuts, voice chat, and contextual mode. \DuckChat\ serves as the main entry point for opening chats, managing user preferences (like input screen and chat history settings), and handling voice sessions. \DuckChatContextual\ allows the browser to launch and embed the contextual chat sheet. The module also introduces \NativeInputState\ and its provider/publisher to manage the shared native input field's state (mode, query, streaming status) per tab, and \NativeInputChatTabItemPlugin\ to allow other modules to contribute items to the chat tab's suggestion list. Additionally, \DuckChatEntryPoint\ enumerates all possible surfaces from which a user can initiate a Duck.ai session.

duckchat/duckchat-api · high confidence

New API for launching site permission dialogs and handling grants

This change introduces the \SitePermissionsDialogLauncher\ interface and \SitePermissionsGrantedListener\ interface in the site-permissions-api module. The \SitePermissionsDialogLauncher\ provides a public contract for requesting microphone and/or camera permissions when a website initiates a request, including methods to register permission launchers and ask for site permissions with specific context (activity, URL, tab ID, requested permissions, and the original permission request). The \SitePermissionsGrantedListener\ interface allows implementing special logic, such as loading an embedded room URL, when permissions are granted, specifically mentioning a case for 'whereby'.

site-permissions/site-permissions-api · high confidence

New Network Protection API interfaces for state, exclusion lists, and navigation

The network-protection-api module now exposes three new interfaces to other components: NetworkProtectionState, which provides methods to check onboarding, enabled, and running status, start/stop/restart the VPN, clear VPN configuration, retrieve the server location, monitor connection state via a Flow, and list excluded apps; NetworkProtectionExclusionList, which allows checking if a specific app package is excluded from Network Protection; and NetworkProtectionScreens, which defines ActivityParams for launching the Network Protection Management screen (with optional auto-enable and launch pixel support) and the App Exclusion List screen.

network-protection/network-protection-api · high confidence

New VPN API interfaces for network stack, state monitoring, and app exclusion

The vpn-api module introduces three new interfaces that define how the VPN service interacts with network layers and monitors its state. VpnNetworkStack allows a networking implementation to provide its own configuration (MTU, addresses, DNS, routes, and app exclusion lists) and lifecycle callbacks, including a stop reason. VpnStateMonitor exposes the VPN's running state (including an ENABLING phase), always-on status, and the reason for any stop (such as snooze, error, or revocation). AppCategory defines a sealed hierarchy of app types (e.g., Game, Social, Maps) used within the exclusion logic.

vpn-api · high confidence

New navigation models for VPN breakage reporting

The VPN API module now exposes specific navigation models (OpenVpnReportBreakageFrom, OpenVpnBreakageCategoryWithBrokenApp) and a data class (AppBreakageCategory) to support launching the VPN breakage report screen from external modules. This allows other parts of the application to initiate the breakage reporting flow by passing the origin, a list of breakage categories, and optionally the specific app details (name and package ID) that are broken.

app-tracking-protection/vpn-api/src/main/java/com/duckduckgo/mobile/android/vpn/ui · high confidence

New plugin interfaces for modular onboarding preferences and CTAs

The onboarding API now exposes three new plugin interfaces to allow other modules to contribute settings and control user interface elements. OnboardingBooleanPreferencePlugin lets modules register on/off preferences (such as AdBlocking) that onboarding can display and commit. OnboardingSingleChoiceDataPlugin enables modules to provide single-choice options (such as Duck AI model provider or state) for onboarding steps. ContextualCtaSuppressorPlugin allows modules to suppress browser onboarding CTAs on specific pages based on the URL.

onboarding/onboarding-api · high confidence

New statistics API interfaces for analytics and wide events

The statistics module exposes a new set of interfaces in the \statistics-api\ package to standardize analytics data collection. This includes the \Pixel\ interface for sending anonymous event pixels (with support for daily/unique deduplication), the \WideEventClient\ for tracking multi-step user flows with sampling and interval bucketing, and lifecycle hooks via \AtbLifecyclePlugin\ and \AtbInitializerListener\ to manage ATB (Anti-Tracking Bypass) retention states. Additionally, \BrowserFeatureStateReporterPlugin\ allows modules to report feature states, while \OfflinePixel\ and \PixelSender\ provide infrastructure for reliable, retryable pixel transmission. Also in this area: Migration of codegen annotations and processors from Anvil to KSP.

statistics/statistics-api · high confidence

Architecture

Autofill API module exposes public interfaces for feature flags, credential management, and Google imports

The autofill-api module now provides a set of public Kotlin interfaces that define the contract for the Autofill feature. This includes AutofillFeature for remote configuration of sub-features (such as credential injection, saving, password generation, and Google import capabilities), BrowserAutofill for WebView integration, and specific interfaces for managing credentials, handling dialog results, and importing data from Google Password Manager and Google Takeout. These interfaces serve as the public API layer for the Autofill implementation.

autofill/autofill-api · high confidence

Centralized browser feature flags in new module

The AndroidBrowserConfigFeature interface has been moved to the browser-feature-toggles module, consolidating browser-specific remote feature flags (such as screenLock, cachedEntityLookup, and stripWebViewImeInsets) into a single location for easier management and configuration.

browser/browser-feature-toggles/src/main/java/com/duckduckgo/browser/feature/toggles · high confidence

Custom tabs moved to a dedicated module with session tracking and Metro DI

Custom tabs have been extracted into their own module (custom-tabs-api and custom-tabs-impl) to improve modularity. The implementation now includes a CustomTabsSessionRegistry that tracks verified Custom Tabs sessions and their calling packages, enabling features like trusted-caller carve-outs for app links. The service layer uses the Metro dependency injection framework (replacing previous Dagger/Anvil setups) and logs via logcat instead of Timber.

custom-tabs/custom-tabs-impl · high confidence

Extracted Saved Sites into a modular architecture with new API and implementation layers

The saved-sites functionality has been refactored into a modular structure, separating the public API (interfaces, data models, and services) from the internal implementation. This change introduces a new \SavedSitesRepository\ interface and associated data models (such as \SavedSite\, \Bookmark\, and \Favorite\) in the API module, while the \saved-sites-impl\ module now houses the concrete repository logic, favorites management, and display mode settings. The implementation also adds support for importing and exporting bookmarks via \SavedSitesImporter\ and \SavedSitesExporter\ interfaces, and registers the \BookmarksActivity\ and \BookmarkFoldersActivity\ in the module's manifest.

saved-sites/saved-sites-impl · high confidence

Subscription module modularization and API extraction

The subscription feature has been restructured into a modular architecture, extracting the public API into a dedicated \subscriptions-api\ module and moving the implementation to \subscriptions-impl\. This change introduces a new \SubscriptionOnboardingStepPlugin\ interface, allowing individual features (like VPN and Duck.ai) to contribute their own onboarding steps to the linear onboarding flow. The public \Subscriptions\ interface now exposes a \getEntitlements()\ method for real-time entitlement tracking and a \SubscriptionUnifiedFeedback\ interface to standardize feedback collection across different app entry points. Additionally, the module registers several new activities in the manifest, including a dedicated feedback screen and a plan change screen, while implementing background subscription data checks via a periodic WorkManager worker.

subscriptions/subscriptions-impl · high confidence

Sync module structure and lint baselines added

The sync module has been reorganized into distinct sub-modules (sync-api, sync-impl, sync-lib, sync-settings-api, sync-settings-impl, and sync-store), each with its own build ignore and lint baseline files. A new readme.md documents the module's purpose and key contributors. The lint baselines record existing issues such as DenyListedApi usage, lifecycle scope misuse in fragments, and implicit locale usage, establishing a clean baseline for future development.

sync · high confidence

Behavioural changes

1 commit (0 fixes) modifying credential-exchange

A change to existing behaviour in credential-exchange — 1 commit, 1 file: “Add R8 rule to not shrink FIDO provider (\#10207)” (refs \#10207).

credential-exchange · low confidence · unverified

16 commits (1 fix) modifying next-steps/next-steps-impl

A change to existing behaviour in next-steps/next-steps-impl — 16 commits (1 fix), 37 files: “Hold the default browser and cookie prompts while Next Steps is active (\#10359)”; “Rotate Next Steps cards and auto-dismiss after active days (\#9961)”; “Wire the Next Steps checklist actions (\#10194)”; and 13 more (refs \#10359, \#9961, \#10194, \#10347, \#9995, …).

next-steps/next-steps-impl · medium confidence · unverified

2 commits (0 fixes) modifying next-steps-impl

A change to existing behaviour in next-steps-impl — 2 commits, 2 files: “Add pixels for the Next Steps stacked cards (\#10177)”; “Add the Next Steps checklist pixels (\#10326)” (refs \#10177, \#10326).

next-steps-impl · medium confidence · unverified

3 commits (0 fixes) modifying device-migration-impl, device-migration/device-migration-impl

A change to existing behaviour in device-migration-impl, device-migration/device-migration-impl — 3 commits, 6 files: “Turn on device-to-device transfer of app data (\#10495)”; “Suggest turning on Sync after a device transfer (\#10494)”; “Show the device migration flow on a migrated install (\#10493)” (refs \#10495, \#10494, \#10493).

device-migration-impl, device-migration/device-migration-impl, device-migration/device-migration-api · medium confidence · unverified

5 commits (0 fixes) modifying macrobenchmark

A change to existing behaviour in macrobenchmark — 5 commits, 8 files: “Add protections ON/OFF variants to the combined page-load macrobenchmark (\#9783)”; “Fail the nightly page-load benchmark explicitly when onboarding can't be skipped (\#10371)”; “Add page-load performance macrobenchmark (\#9774)”; and 2 more (refs \#9783, \#10371, \#9774, \#10272, \#10324).

macrobenchmark · medium confidence · unverified

5 commits (1 fix) modifying app-database

A change to existing behaviour in app-database — 5 commits (1 fix), 124 files: “Extract app.db into a new standalone :app-database module (\#9912)”; “Suggest turning on Sync after a device transfer (\#10494)”; “Add pixel for app.db corruption (\#10195)”; and 2 more (refs \#9912, \#10494, \#10195, \#10306, \#10443).

app-database · medium confidence · unverified

6 commits (0 fixes) modifying test-seeder/test-seeder-api

A change to existing behaviour in test-seeder/test-seeder-api — 6 commits, 3 files: “Add Maestro test seeding for NativeInputWidget E2E tests (\#8418)”; “Add protections ON/OFF variants to the combined page-load macrobenchmark (\#9783)”; “Seed the privacy config URL for the internal privacy Maestro test (\#10331)”; and 3 more (refs \#8418, \#9783, \#10331, \#10272, \#10324, …).

test-seeder/test-seeder-api · medium confidence · unverified

The AMP links feature implementation has been updated to optimize resource usage by loading privacy configuration data (exceptions, link formats, and keywords) into memory exclusively for the main process. The new \RealAmpLinksRepository\ checks an \isMainProcess\ flag during initialization and skips the database load step if it is not the main process, ensuring that background or secondary processes do not incur the overhead of caching this data.

privacy-config/privacy-config-store/src/main/java/com/duckduckgo/privacy/config/store/features/amplinks · high confidence

ANR and crash reports now include app, WebView, and custom tab context with sanitized stack traces

The ANR implementation now enriches crash and ANR telemetry by attaching the app version, WebView version, and a flag indicating whether the event occurred in a custom tab. Additionally, stack traces are sanitized to redact sensitive information such as emails, phone numbers, URLs, and IPv4 addresses before being stored or reported.

anrs-impl · high confidence

Ad click attribution configuration is now remotely configurable

The ad-click module now supports remote configuration for ad click attribution settings. Users can have their ad click behavior controlled via server-side feature flags, specifically a global 'adClickAttribution' toggle and a 'persistExemptions' sub-flag. Additionally, the system now fetches and applies remote settings for link formats, allowlists, navigation and total expiration times, and heuristic/domain detection rules, allowing these parameters to be updated without an app release.

ad-click/ad-click-impl/src/main/java/com/duckduckgo/adclick/impl/remoteconfig · high confidence

Ad click attribution now persists exemptions across app restarts

The ad-click implementation now supports persisting ad-click exemptions to a local database, ensuring that user exemptions are retained even after the app is restarted. This change introduces a new background worker that periodically cleans up expired ad data and migrates the exemption storage mechanism to use a new feature-flag-driven persistence layer. Users will experience more consistent ad-blocking behavior across sessions, as exemptions for trusted ad domains are no longer lost when the app is closed and reopened.

ad-click/ad-click-impl/src/main/java/com/duckduckgo/adclick/impl · high confidence

Added Maestro onboarding configuration scripts

Introduced two new Maestro script files in the shared onboarding directory to control the onboarding flow for tests: \setup.js\ configures the environment to run the full onboarding process, while \skipped\_onboarding.js\ configures it to skip the full onboarding.

_.maestro/shared/onboarding\scripts · high confidence

App Tracking Protection breakage reports now include richer device and network context

The App Tracking Protection bug report system has been restructured to collect more detailed diagnostic data automatically. Reports now include the VPN feature status, app version, device manufacturer, OS version, and whether battery optimizations are enabled. Additionally, they capture the current network type (Wi-Fi or cellular), connection stability, and the last 24 hours of blocked trackers. This enhanced context helps support teams diagnose connectivity and protection issues more effectively.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/bugreport · high confidence

App Tracking Protection feature flags migrated to new remote feature framework

The App Tracking Protection module now uses a new feature-toggle framework to manage its configuration. This change introduces \AppTpLocalFeature\ for local settings (such as verbose logging) and \AppTpRemoteFeatures\ for remote-controlled toggles, including a large set of experiment flags (e.g., \atpTdsExperiment001\ through \atpTdsExperiment043\) and core behaviors like connectivity loss restart and DNS search domain configuration. This migration centralizes how these features are enabled, disabled, and persisted, allowing for more dynamic control over App Tracking Protection capabilities without requiring app updates.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/feature · high confidence

App Tracking Protection notification content is now plugin-driven

The VPN service notification system now uses a plugin architecture to manage App Tracking Protection (ATP) notification content. New plugins handle specific states—such as ATP enabled, disabled, or revoked—and integrate with Network Protection to display combined status when both features are active. This change introduces a dedicated store to track persistent notification dismissal timestamps and utilizes a plugin point to select the highest-priority reminder content, allowing the notification to dynamically reflect ATP's current state and blocking statistics.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/service/notification · high confidence

App Tracking Protection notification system restructured with dedicated schedulers and builders

The App Tracking Protection notification logic has been reorganized into a modular system. A new AppTPReminderNotificationScheduler now handles immediate and periodic reminders for disabled or revoked VPN states, while DeviceShieldNotificationScheduler manages daily and weekly usage stats notifications via background workers. Supporting this, new builders (DeviceShieldAlertNotificationBuilder, VpnEnabledNotificationBuilder, VpnReminderNotificationBuilder) and factories (DeviceShieldNotificationFactory) define specific notification channels and content, and PressNotificationHandlers now track user interactions for analytics.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/ui/notification · high confidence

App Tracking Protection telemetry restructured with new pixel definitions and parameter cleanup

The App Tracking Protection module now uses a centralized \DeviceShieldPixelNames\ enum to define all telemetry identifiers, standardizing naming conventions for enable/disable events, notifications, and error reporting. A new \VpnPixelParamRemovalPlugin\ ensures that ATB (Atb) and other internal parameters are stripped from these pixels before transmission. Additionally, a \VpnEnableWideEvent\ implementation has been added to track the end-to-end VPN start flow, capturing steps like tunnel creation and network stack initialization for performance analysis.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/pixels · high confidence

Autoconsent library updated to v16.34.0

The autoconsent library has been updated to version 16.34.0. This update includes new and improved rules for detecting and interacting with various Consent Management Providers (CMPs), such as TrustArc, Cookiebot, Sourcepoint, and Onetrust, as well as heuristic detection patterns for cookie banners in multiple languages. The bundled JavaScript file now contains the latest logic for identifying consent interfaces and executing opt-out actions.

autoconsent · high confidence

Automatically quiet Gradle build output

A new PreToolUse hook intercepts commands invoking ./gradlew and automatically appends the -q (quiet) flag if no explicit logging level is already specified. This reduces the volume of build output generated during automated tasks, ensuring logs remain concise and readable for agents.

.claude/hooks · high confidence

Content blocking and HTTPS exception data is now loaded into memory only for the main process

The ContentBlockingRepository and HttpsRepository implementations have been updated to check the \isMainProcess\ flag before loading exception data from the database into memory. This ensures that privacy configuration data for content blocking and HTTPS exceptions is cached in memory exclusively by the main application process, preventing redundant loading in background or secondary processes.

privacy-config/privacy-config-store/src/main/java/com/duckduckgo/privacy/config/store/features/contentblocking, privacy-config/privacy-config-store/src/main/java/com/duckduckgo/privacy/config/store/features/https · high confidence

Duck.ai chat data clearing now supports native storage and Fire Mode

The app's data clearing mechanism for Duck.ai chats has been updated to handle both the new native chat storage and the legacy WebView storage. When clearing chats, the system now intelligently selects the correct storage backend based on the user's migration status, ensuring that chat history is properly removed regardless of which storage system is active. Additionally, Fire Mode deletions now bypass the standard deletion chain to directly clear the Fire-specific chat store, improving data privacy and performance when using the Fire button.

duckchat/duckchat-impl · high confidence

Dummy subscription implementation provides no-op stubs for build variants

The subscriptions-dummy-impl module now supplies concrete no-op implementations for the subscription system's core interfaces, including Subscriptions, SubscriptionOnboardingController, SubscriptionsJSHelper, and SubscriptionUnifiedFeedback. This ensures that build variants which do not include the full subscription logic (such as F-Droid builds) can compile and run without errors by providing safe, empty defaults for methods like isSignedIn, getEntitlements, and onboarding event handling.

subscriptions/subscriptions-dummy-impl · high confidence

Enhanced ANR and crash reporting with app and WebView version tracking

The ANR and crash data store now captures the app version and WebView version for each event, enabling more precise debugging and analysis. Additionally, the system distinguishes between crashes/ANRs occurring in the standard browser versus those in custom tabs. These changes are implemented via new Room database schemas (AnrsDatabase and CrashDatabase) with corresponding migrations to add the new columns, and updated Data Access Objects to handle the enriched data.

anrs/anrs-store · high confidence

Enhanced experiment targeting with device filters and returning-user variant protection

The experiments module now supports targeting variants based on the user's locale, Android version, and Privacy Pro subscription eligibility, allowing experiments to be shown only to specific device configurations. Additionally, a new 'reinstaller variant protection' feature allows administrators to specify experiment variants that should be preserved when a user reinstalls the app, preventing returning users from being randomly reassigned to a different variant.

experiments/experiments-impl · high confidence

Fingerprint protection modules now cache data in memory for the main process

The fingerprint protection store layer (battery, canvas, hardware, screen size, and temporary storage) has been updated to load its respective data into memory immediately upon initialization, but only when running in the main process. This change ensures that subsequent reads for these fingerprinting features are served from memory rather than requiring repeated database queries, while non-main processes will continue to read directly from the database.

(repo-wide) · high confidence

Fire Mode: Mode-specific CookieManager

The cookies module now maintains separate cookie jars for Regular and Fire browser modes. The new CookieManagerProvider interface and DefaultCookieManagerProvider implementation allow cookie operations to target the correct profile based on the active mode, ensuring that Fire Mode uses an isolated cookie store. This change also introduces a mode-aware cookie removal strategy that respects these separate profiles, and adds a utility to set cookies across all active modes simultaneously.

cookies/cookies-impl · high confidence

First-party cookies are now automatically expired

The app now includes a background worker that periodically expires first-party cookies stored in the WebView database. This process respects user allow-lists, fireproofed sites, and temporary exceptions, and specifically preserves DuckDuckGo search settings and survey cookies to avoid unintended resets. The feature is controlled by a feature toggle and runs as a periodic background task.

cookies/cookies-impl/src/main/java/com/duckduckgo/cookies/impl/features/firstparty · high confidence

GPC configuration is now persisted in a local database and loaded only in the main process

Global Privacy Control (GPC) settings, including exceptions and header-enabled sites, are no longer stored solely in SharedPreferences. Instead, they are persisted in a local Room database via new DAOs (GpcExceptionsDao, GpcHeadersDao, GpcContentScopeConfigDao) and a new GpcDataStore interface. The GpcRepository now loads this configuration into memory using thread-safe CopyOnWriteArrayLists, but only when running in the main process, ensuring that GPC state is robustly stored and efficiently accessed.

privacy-config/privacy-config-store/src/main/java/com/duckduckgo/privacy/config/store/features/gpc · high confidence

Global Privacy Control (GPC) implementation moves to remote configuration

The Global Privacy Control feature now supports remote configuration, allowing the GPC state, enabled sites, and exceptions to be updated dynamically without an app release. This change introduces a new plugin system that stores GPC settings from the remote config payload and integrates with the existing header and content scope plugins to apply the \sec-gpc: 1\ header only when the remote configuration enables the feature and the URL is not in the exception or allow lists.

privacy-config/privacy-config-impl/src/main/java/com/duckduckgo/privacy/config/impl/features/gpc · high confidence

HTTPS feature now respects user allowlist exceptions

The HTTPS feature implementation has been updated to check the user allowlist in addition to remote configuration exceptions. When determining if a URL is an exception, the system now also queries the UserAllowListRepository, ensuring that domains explicitly added by the user to their allowlist are treated as HTTPS exceptions alongside those defined in the remote privacy config.

privacy-config/privacy-config-impl/src/main/java/com/duckduckgo/privacy/config/impl/features/https · high confidence

Implement shared desktop app promotion content and interaction logic

The desktop app promotion module now uses a centralized implementation to manage promotion screens. A new \DesktopAppPromotionContent\ data class resolves default text, URLs, and illustrations from resources, ensuring consistent branding and copy across different entry points. The accompanying \DesktopAppPromotionViewModel\ handles user interactions—such as sharing the download link, copying the URL to the clipboard, or dismissing the prompt—and dispatches analytics pixels for impressions and clicks. This change consolidates the logic for displaying and interacting with desktop browser promotion screens into a single, reusable component.

desktop-app-promotion-impl · high confidence

Improved VPN service stability and startup reliability

The VPN implementation now includes a trampoline service to ensure the VPN process is ready before starting, reducing startup latency. A new state monitor service handles unexpected service destruction by recording the disabled state and automatically restarting the VPN if it was killed by the system while active. Additionally, a new state monitor implementation provides more accurate tracking of VPN status, including always-on state and stop reasons, to prevent incorrect UI states.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/service/state · high confidence

Improved broken site prompt timing and refresh detection

The broken site reporting experience now features more accurate timing for prompt visibility and better detection of rapid page refreshes. A new remote feature configuration allows backend control over prompt dismissal streaks, reset intervals, and cooldown periods. Additionally, a new in-memory store tracks refresh patterns (double refreshes within 12 seconds or triple refreshes within 20 seconds) to prevent false positive broken site reports caused by rapid reloading.

broken-site-impl · high confidence

Initial feedback screen logic moved to dedicated ViewModel

The logic for the initial feedback screen is now handled by a new InitialFeedbackFragmentViewModel in the feedback-impl module. This ViewModel exposes view state and commands for positive/negative feedback selection and user cancellation, providing a cleaner separation of concerns for the feedback UI flow.

feedback-impl · high confidence

Internal debug logging is now persistable and controllable via system broadcast

The App Tracking Protection module now supports enabling or disabling verbose internal debug logging through a new system broadcast receiver. Users or internal tools can trigger this by sending a broadcast with the action "logging" and an extra "turn" set to "on" or "off". When enabled, the app installs a verbose logcat logger and persists the setting using the renamed \setRawStoredState\ API, then restarts the VPN service to apply the change to the underlying network stack. This replaces the previous transient logging mechanism with a persistent, state-aware implementation.

app-tracking-protection/vpn-internal/src/main/java/com/duckduckgo/vpn/internal/feature/logs · high confidence

Internal feature settings are now ordered by priority keys

The internal settings screen now displays features in a specific, configurable order defined by priority keys in the InternalFeaturePlugin interface. This change introduces a structured list of settings categories—ranging from Developer Settings to Onboarding Dev Settings—allowing the internal UI to present these tools in a consistent sequence rather than an arbitrary one.

internal-features/internal-features-api/src/main/java/com/duckduckgo/internal/features/api · high confidence

Introduce dedicated HTTP authentication credential store

The app now uses a new \RealWebViewHttpAuthStore\ to manage HTTP authentication credentials, replacing direct WebView database interactions with a structured interface. This change introduces a dedicated data class for credentials and integrates the store with the app's lifecycle and dependency injection systems, ensuring credentials are handled consistently across the browser module.

app/src/main/java/com/duckduckgo/app/browser/httpauth · high confidence

The cookies store now loads first-party cookie policies, cookie exceptions, and third-party cookie names into memory upon initialization (in the main process) and keeps them in sync via a repository layer. This means cookie-related configuration changes are applied immediately in memory without requiring repeated database reads, improving responsiveness for cookie handling logic.

cookies/cookies-store · high confidence

Introduce new VPN network implementation with native integration

The VPN network module now includes a new implementation (RealVpnNetwork) that bridges to a native library via JNI to handle core networking tasks such as starting, running, and stopping the VPN tunnel. This change introduces new internal data models (Packet, ResourceRecord, Usage, Allowed) to represent network traffic and DNS resolution data, along with extension functions to map these models to API interfaces. The implementation also integrates a new logging library (logcat) to replace the previous Timber dependency for reporting events like DNS resolution, packet logging, and TLS parsing errors, ensuring that network activity and errors are properly surfaced to the application layer.

vpn-network/vpn-network-impl · high confidence

Introduce per-tab history tracking and deletion

The history implementation now associates each visit with a specific tab ID, enabling per-tab history management. Users can now delete the history for a single tab without affecting other tabs, and the system automatically clears history entries older than 30 days via a scheduled background worker.

history/history-impl · high confidence

Introduces local database models for privacy configuration storage

The privacy-config-store module now defines a set of Room database entities to persist privacy settings locally. This includes tables for tracker allowlists, DRM exceptions, HTTPS exceptions, GPC (Global Privacy Control) headers and exceptions, content blocking exceptions, AMP link formats and exceptions, and tracking parameters. These models enable the application to store and manage granular privacy rules and exceptions directly on the device, replacing previous storage mechanisms.

privacy-config-store · high confidence

The cookies-store module now includes a new data model file defining Room entities for persisting first-party cookie policies, cookie exceptions, individual cookies, and third-party cookie names. This change establishes the local database schema required to manage cookie settings and exceptions within the application.

cookies-store · high confidence

Introduction of new VPN network stack implementation

The App Tracking Protection module now includes a new \NgVpnNetworkStack\ implementation and a provider mechanism to select the active network stack. This new stack handles VPN lifecycle events, manages DNS resolution with an LRU cache, and includes specific logic to mitigate EMFILE errors by restarting the process when file descriptor limits are reached. It also supports device-specific DNS configurations for certain Motorola and FIG models and integrates with the existing feature registry to allow for pluggable network stack implementations.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/integration · high confidence

Introduction of per-tab history tracking

The history storage layer has been updated to support per-tab history records. A new database schema introduces a \visits\_list\ table that links history entries to specific tabs via a \tabId\ field, allowing the application to distinguish and track browsing history on a per-tab basis rather than globally.

history-impl · high confidence

Migrate ANR and crash reporting dependency injection to Metro

The dependency injection setup for ANR and crash reporting modules has been migrated from the previous framework to Metro-native annotations and code generation. This change updates the AnrModule and CrashModule to use Metro-specific imports (such as @BindingContainer, @ContributesTo, and @Provides from dev.zacsweers.metro) and registers the AnrsDatabase and CrashDatabase providers within the AppScope, ensuring these components are correctly wired for the new DI system.

anrs/anrs-impl/src/main/java/com/duckduckgo/app/anr/di · high confidence

Modular data clearing with remote-controlled feature toggles

The data clearing system has been refactored into a modular plugin architecture, allowing individual data types to be enabled or disabled independently via remote feature flags. This change introduces a DataClearingOrchestrator that dispatches clear requests to specific plugins, ensuring that if one plugin fails, others continue to execute. The system now supports granular control over clearing sources such as navigation history, app cache, cookies, tabs, web storage, and Duck.ai chats, with all toggles defaulting to disabled until explicitly enabled.

data-clearing/data-clearing-impl · high confidence

Native crash reporting now uses Crashpad across main, VPN, and PIR processes

The app has replaced its legacy native crash handler with Crashpad, initialized via the new \CrashpadInitializer\ and \DefaultCrashpadInitializer\ classes. This change ensures native crashes are captured and reported in the main process as well as secondary processes (VPN and PIR), with crash data enriched by annotations such as custom tab status, WebView package, and WebView version. The behavior is controlled by feature toggles (\nativeCrashHandling\ and \nativeCrashHandlingSecondaryProcess\), and a new pixel is fired upon successful handler registration.

anrs/anrs-impl/src/main/java/com/duckduckgo/app/anr/ndk · high confidence

New API interfaces for broken site reporting logic and data structures

The broken-site-api module introduces three new interfaces to define the contract for broken site reporting: BrokenSiteLastSentReport tracks the date of the last report sent per hostname to prevent spam; BrokenSitePrompt handles the detection of repeated user-initiated page refreshes (specifically patterns like 'twice in 12 seconds' or 'thrice in 20 seconds') to determine when to show a reporting prompt; and BrokenSiteSender defines the method for submitting feedback. Additionally, the data model for reports is expanded with a new \ReportFlow\ enum (including values like \TOGGLE\_DASHBOARD\ and \RELOAD\_THREE\_TIMES\_WITHIN\_20\_SECONDS\) and new fields in the \BrokenSite\ data class such as \breakageData\, \contentScopeExperiments\, and \debugFlags\ to support more detailed telemetry and experiment integration.

broken-site/broken-site-api · high confidence

New Browser Menu State Model

The browser UI now uses a new \BrowserMenuViewState\ model to manage menu visibility and state. This change introduces distinct state structures for the main Browser, Custom Tabs, New Tab Page (NTP), and Duck.ai contexts, allowing for more granular control over menu items. Key additions include support for Duck.ai-specific options (chat, history, voice), VPN status indicators, fireproofing features, download notifications, and a new page context header that displays page titles or search engine logos in the menu sheet.

browser-ui · high confidence

New GlobalActivityStarter implementation with launcher support and defensive fixes

The navigation module now includes a concrete implementation of the GlobalActivityStarter that supports both standard activity launches and deep-link navigation. This implementation adds overloads for starting activities via ActivityResultLauncher, allowing callers to launch activities and receive results without managing the launcher lifecycle manually. It also includes defensive logic to ensure the FLAG\_ACTIVITY\_NEW\_TASK flag is only added when the context is not an Activity, preventing potential issues when using launchers that require the calling context to be an Activity.

navigation/navigation-impl · high confidence

New data-store implementation with Harmony migration and safer storage handling

The data-store module now includes a new implementation that introduces a \DatabaseProvider\ for Room database configuration and a \SharedPreferencesProvider\ that supports multiprocess access via Harmony. This change adds automatic migration of existing shared preferences to Harmony when requested, ensuring data continuity. It also introduces a \SafeSharedPreferences\ wrapper that catches decryption and file-system errors (such as fsync failures) to prevent app crashes, logging them instead. Additionally, the implementation includes a feature-flag-controlled \DatabaseExecutorProvider\ to manage thread pools for database operations, improving performance and stability.

data-store/data-store-impl · high confidence

New dependency injection modules for App Tracking Protection

The App Tracking Protection VPN implementation now includes dedicated Dagger modules to manage its internal dependencies. This change introduces \VpnAppModule\ and \VpnModule\ to provide core services such as the VPN database, tracker repositories, and dispatcher providers, while \AppTrackerBreakageCategoriesModule\ supplies the specific categories used when users report app breakages. Additionally, new qualifier annotations (\AppTpBreakageCategories\, \BatteryOptimizationState\, \AppTpBlocklistUpdateMutex\) and a \VpnDispatcherProvider\ interface are added to support these new bindings.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/di · high confidence

New experiment variant filtering and protection infrastructure

The experiments module now supports filtering variants by Android version and locale via new database entities and variant definitions, and introduces a remote-config-gated feature to protect specific reinstall variants from being overridden.

experiments-impl · high confidence

New lint rules enforce Metro DI, safe coroutines, and API usage standards

The lint-rules module now includes several new detectors that enforce stricter coding standards. For dependency injection, rules require Dagger @Module classes to include @ContributesTo, mandate explicit return types on @Provides/@Binds methods, and require the @HasMemberInjections marker on classes with field injection to support the Metro migration. Coroutines are protected by rules banning direct Fragment lifecycleScope usage (forcing viewLifecycleOwner.lifecycleScope), preventing hardcoded Dispatchers, and restricting computation dispatcher usage. Additionally, a deny-listed API detector blocks unsafe patterns like Flow.first()/last() on empty flows, direct SharedPreferences access, and hardcoded petal pixel parameters, while a separate rule prevents importing from internal :\*-impl modules.

lint-rules · high confidence

New matching rules and display conditions for remote messages

The remote messaging system now supports more granular targeting and lifecycle control. You can configure messages to appear only after you have interacted with or seen specific previous messages using the new "interacted with message" and "shown message" matching attributes. Additionally, messages can now be automatically dismissed based on display conditions such as a maximum number of impressions or a set number of days after being shown, allowing for better control over message frequency and duration.

remote-messaging-impl · high confidence

New tab management architecture and tab reuse analytics

The tab management logic has been refactored into a new \DefaultTabManager\ implementation within the \app/src/main/java/com/duckduckgo/app/browser/tabs\ package, introducing a hard cap of 15 active tabs and integrating with the Duck AI session to trigger exit callbacks when new tabs are opened. Additionally, a new \TabReuseDistanceReporter\ has been added to track and report analytics on how far back in the activation history users return to tabs, firing a specific pixel with distance and tab count buckets when the browser is paused.

app/src/main/java/com/duckduckgo/app/browser/tabs · high confidence

New user-agent feature toggle storage and exception model

The user-agent-store module now includes a new database model for user-agent exceptions (UserAgentExceptionEntity) and a new SharedPreferences-based store (RealUserAgentFeatureToggleStore) for managing feature toggles. This introduces the ability to persist and retrieve user-agent specific feature flags and their minimum supported versions, replacing the previous exception store implementation.

user-agent-store · high confidence

New verified Play Store install detection logic

The verified-installation implementation now determines whether the app is a verified Play Store build by checking four conditions: the build is a Play release flavor, the package ID matches the production app, the installation source is the Play Store (using modern Android APIs where available), and the app is signed with the known production certificate. This replaces previous simpler checks with a more robust, multi-factor verification process.

verified-installation/verified-installation-impl · high confidence

New-user onboarding orchestrator introduces structured step definitions and event handling

The onboarding orchestrator now uses a structured set of Kotlin types to manage the new-user onboarding flow. New files define specific step models for the OnboardingActivity (NewUserOnboardingActivityStep) and BrowserActivity (NewUserBrowserActivityStep), including rendering hooks (resolveDialog) and actions (resolveAction). A new ViewModel (NewUserBrowserOnboardingViewModel) handles navigation commands between these activities and manages the Duck.ai onboarding demo. A comprehensive event interface (NewUserOnboardingEvent) captures user interactions such as quick setup confirmations, password import results, and widget additions, while NewUserOnboardingResult defines the final outcomes (launching a search or chat). This refactors the underlying logic to support a more modular and observable onboarding experience.

app/src/main/java/com/duckduckgo/app/onboarding/orchestrator · high confidence

Omnibar UI and logic refactored into new modular components

The omnibar address bar has been restructured into a new, modular architecture to improve maintainability and support advanced features. The core logic has been moved into \OmnibarLayoutViewModel\, which now manages the address bar's state, including visibility of the tabs menu, fire button, and browser menu, as well as handling animations for trackers and cookies. The UI layer is handled by the new \OmnibarLayout\ and \Omnibar\ classes, which support multiple display modes (split, single top, single bottom) and integrate with the new \Decoration\ model to manage visual updates like the privacy shield and custom tab titles. This change also introduces a new \TrackersLottieAssetDelegate\ to handle dynamic rendering of tracker logos within the address bar animations.

app/src/main/java/com/duckduckgo/app/browser/omnibar · high confidence

Optimized content scope script injection and new messaging infrastructure

The content scope scripts implementation now uses an optimized path for generating and caching JavaScript injection scripts, significantly reducing redundant serialization and template processing when underlying configuration or allow-list data has not changed. This change introduces a dual-path system (legacy vs. optimized) controlled by a feature flag, ensuring backward compatibility while improving performance. Additionally, new Room entities for \message\_bridge\ and \navigator\_interface\ are added to support persistent storage for the new JavaScript messaging framework, enabling more robust communication between the native app and web content.

content-scope-scripts-impl · high confidence

Optimized experiment resolution to prevent navigation delays

The ContentScopeExperiments implementation now caches the list of active experiments and resolves them only once, rather than on every navigation. This change prevents Application Not Responding (ANR) errors and reduces page-start latency by avoiding the expensive operation of walking every feature toggle during navigation. The cache is invalidated when a new privacy config is downloaded or persisted, ensuring experiments remain up-to-date while significantly improving performance.

content-scope-scripts/content-scope-scripts-impl/src/main/java/com/duckduckgo/contentscopescripts/impl/features/contentscopeexperiments · high confidence

Page-load macrobenchmark script and more lenient Asana URL matching

The page-load macrobenchmark now includes protections ON/OFF variants, allowing users to measure performance with different protection states. Additionally, Asana URL matching in release utilities has been made more lenient, supporting flexible whitespace and formatting in commit messages.

python · high confidence

Persist ad-click exemptions across app restarts

The ad-click implementation now persists user exemptions (such as those granted when a user interacts with an ad) so they survive app restarts. This is achieved by introducing an Exemption data model and corresponding Room database entities (including a tab\_exemptions table) to store exemption details like deadlines and active pixel status, ensuring that valid exemptions are retained rather than lost when the application is closed and reopened.

ad-click-impl · high confidence

Privacy config download performance is now tracked

The app now measures and reports the duration of privacy config downloads, splitting the time into fetch, persistence, and total phases. This telemetry is sent via the 'privacy\_config\_downloaded' pixel with bucketed duration values, allowing the team to monitor download performance and identify potential latency issues.

privacy-config/privacy-config-impl · high confidence

Privacy feature toggles now persist in SharedPreferences instead of a database

The local storage mechanism for privacy feature toggles has shifted from a Room database to Android SharedPreferences. This change means that toggle states and their minimum supported versions are now saved in a lightweight preference file rather than a SQL database, which simplifies the data layer for these specific settings and avoids the overhead of database migrations for toggle state changes.

privacy-config/privacy-config-store · high confidence

Redesigned App Tracking Protection company details and activity feed screens

The App Tracking Protection UI has been rebuilt to provide a more detailed and structured view of tracking activity. The new Company Details screen displays a summary of total tracking attempts, the time since the last block, and a categorized list of tracking companies with expandable signal details. The Activity Feed now features a sticky-header timeline of recent tracker events and includes a dedicated section for managing app protection states (protected vs. unprotected apps). These changes are supported by new ViewModels and RecyclerView adapters that handle data aggregation, DiffUtil-based list updates, and edge-to-edge layout integration.

_app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/ui/tracker\activity · high confidence

Redesigned contextual Duck.ai sheet with native input and page context

The contextual Duck.ai experience has been redesigned to use a native input composer instead of the legacy WebView-based entry flow. Users can now attach page context to their queries, select from suggested prompts, and submit requests that are handed off to a dedicated chat sheet. This change introduces a new \ContextualEntryPromptStore\ to manage the hand-off between the entry dialog and the chat sheet, ensuring that page context and user selections are preserved across the transition. The implementation includes new ViewModels and Fragments to handle the input state, page context attachment, and the subsequent chat display, providing a more integrated and responsive experience for contextual queries.

duckchat-impl · high confidence

Refactored referral parsing into a plugin-based architecture with SERP install-origin bridge

The referral implementation has been restructured to extract referrer parsing into a modular plugin system, allowing separate components to process referrer data independently. This change introduces a new \ReferrerParserPlugin\ interface and \QueryParamReferrerParser\ that delegates to registered plugins, enabling extensible handling of attribution data. Additionally, a SERP install-origin bridge has been added, featuring a \GetInstallOriginVariantHandler\ and \SerpHandshakeHandler\ that allow the search engine to query and verify install origin variants through JavaScript messaging, controlled by the \installOriginBridge\ feature toggle.

referral/referral-impl · high confidence

Refactored statistics module with new pixel sending and ATB initialization logic

The statistics implementation module has been restructured to introduce a new \AtbInitializer\ that manages the App Tracking Breakthrough (ATB) lifecycle, including running pre-initialization plugins with configurable timeouts and firing a \timeout\_atb\_pre\_initializer\_plugin\ pixel if they exceed their limit. Pixel delivery is now handled by \RxPixelSender\, which supports both immediate sending and offline queuing via \OfflinePixelScheduler\ and \OfflinePixelSender\ to ensure reliable delivery. A new remote feature toggle, \pixelSenderAtbOptIn\, allows controlling whether ATB is attached to all pixels or only those explicitly declared as requiring it. The module also adds support for tracking daily and unique pixel firing via new Room entities (\DailyPixelFired\, \UniquePixelFired\) and introduces a \FeatureRetentionPixelSender\ to report daily active feature states.

statistics/statistics-impl · high confidence

The app link handling logic has been updated to allow deep links back to the application that opened a Custom Tab to launch without requiring a user gesture, even if the global 'Open Links in Other Apps' setting is set to Never. This 'trusted caller' exception prevents endless redirect loops for specific callers while maintaining security by verifying the target package matches the caller. Additionally, the system now supports a hardcoded list of domains (such as DigiD) that always trigger their associated apps on repeat navigations, bypassing standard gesture and prompt requirements.

app/src/main/java/com/duckduckgo/app/browser/applinks · high confidence

Refined launch flow with onboarding orchestration and referrer handling

The app's launch sequence now explicitly manages the transition between onboarding and the home screen based on user status and feature toggles. New users are routed through a new onboarding plan bootstrapper, which can direct them to either the onboarding activity or directly to the home screen depending on the current step's host configuration. Existing users bypass onboarding and go straight to the home screen. Additionally, the launch process now waits for app installation referrer data with a defined timeout, firing a specific pixel event if the wait exceeds the maximum allowed time, ensuring that referrer information is captured without blocking the launch indefinitely.

app/src/main/java/com/duckduckgo/app/launch · high confidence

Remote messaging API refactored to support modular plugins and advanced message controls

The remote-messaging-api module has been restructured to expose a cleaner, plugin-based architecture for handling message actions and attribute matching. New interfaces, \AttributeMatcherPlugin\ and \MessageActionMapperPlugin\, allow external modules to contribute custom logic for evaluating user attributes and mapping JSON actions to concrete behaviors, replacing hardcoded logic. The core \RemoteMessage\ model now includes \DisplayConditions\ (supporting triggers like \after\_idle\ and limits like \maxImpressions\) and a \surfaces\ list to target specific UI areas such as the modal or new tab page. Additionally, the API introduces a \CardsList\ message type for list-based content, expands the \Action\ sealed class with new types like \Navigation\ and \Survey\, and provides a \RemoteMessageModel\ interface for managing message lifecycle events and image caching per surface.

remote-messaging/remote-messaging-api · high confidence

Remote messaging implementation module restructured and enhanced

The remote-messaging-impl module has been reorganized to host the core RemoteMessagingRepository and its dependencies, introducing a new ModalSurfaceActivity and a broadcast receiver for promo links. The system now supports auto-dismissal of messages based on impression caps and expiration thresholds, configurable download scheduling via WorkManager, and refined matching logic that filters card list items and section titles. Additionally, the module includes a new DataStore for modal surfaces, updated dependency injection bindings, and backward-compatible JSON adapters for message actions.

remote-messaging/remote-messaging-impl · high confidence

Request blocklist feature and models moved to request-interception module

The RequestBlocklist feature definition and associated data models have been relocated from the privacy-config module to the new request-interception-impl module. This change introduces the RequestBlocklistFeature interface, which exposes a remote toggle for controlling the blocklist, and defines the BlockedRequestEntry and BlocklistRuleEntity models used to parse and apply blocking rules based on domain and regex patterns.

request-interception-impl · high confidence

Request blocklist logic moved to new interception module with Metro DI

The request blocklist implementation has been relocated from the privacy-config module to the new request-interception module. This change introduces the \RealRequestBlocklist\ class, which now handles loading blocklist rules from the privacy configuration, checking if specific requests match those rules, and managing exceptions. The implementation uses Metro-native annotations for dependency injection and binding, replacing previous DI mechanisms. The core behavior remains the same: checking if a request URL matches blocklist rules defined in the privacy configuration, considering document domain exceptions and feature toggle states.

request-interception/request-interception-impl · high confidence

Shared JSON models and cohort assignment callback for remote feature toggles

The feature-toggles-internal-api module now provides shared JSON model classes (such as JsonToggleTarget and JsonToggleCohort) and a pre-built Moshi instance used by generated remote feature code, which reduces the app's DEX method count by eliminating duplicate model copies across features. Additionally, a new FeatureTogglesCallback interface has been introduced to allow implementations to handle cohort assignment events via onCohortAssigned and to evaluate toggle targets against device configuration using matchesToggleTargets.

feature-toggles/feature-toggles-internal-api/src/main/java/com/duckduckgo/feature/toggles · high confidence

Site permissions storage migrates to Room database

The site-permissions-store module now uses a Room database (version 5) to persist site permission settings, replacing the previous storage mechanism. This introduces dedicated tables for per-site permission states (camera, microphone, DRM, location) and a separate table for temporary permission allowances, along with database migrations to handle schema changes such as adding DRM and location settings and removing the old DRM block exceptions table.

site-permissions/site-permissions-store · high confidence

Suppress automatic Input Screen launch for new tabs opened via Intent

The browser now prevents the native Input Screen from automatically launching when a new tab is opened via an external Intent. This change ensures that if a user taps a link from another app, the browser opens the destination page directly without interrupting the flow by forcing the search or chat input interface to appear. Also in this area: 5 commits (0 fixes) modifying app/src; 6 commits adding/updating tests in app/src/test; 1 commit (0 fixes) modifying app/src/internal; 3 commits (1 fix) modifying app, app/src; Custom tabs now survive app switching and are properly closed during data clearing; and 162 more.

app/src, app/src/main/java/com/duckduckgo/app/browser · medium confidence

Sync store introduces encrypted credential storage and error tracking database

The sync-store module now persists sensitive authentication credentials (user ID, device ID, keys, tokens) in encrypted shared preferences using AES-256-GCM, replacing previous unencrypted storage. It also adds a new Room database (version 3) to track sync attempts and errors, providing DAOs for recording and querying API and operation errors by date and feature.

sync/sync-store · high confidence

Tracker Detection Service (TDS) cache tables moved to implementation module

The Room database entity classes for the Tracker Detection Service cache—specifically TdsCnameEntity, TdsDomainEntity, TdsEntity, TdsMetadata, and TdsTracker—have been relocated into the tracker-detection-impl module. This change consolidates the persistence layer for TDS data within the implementation module, ensuring that the local storage structures for tracking domains, entities, and metadata are managed alongside the detection logic rather than in a shared or API module.

tracker-detection-impl · high confidence

Tracker detection performance and caching improvements

The tracker detection module now uses an in-memory cache for entity lookups and CNAME cloaking detection, reducing database queries during request evaluation. A new TdsClient pre-compiles tracker rules into regex patterns for faster matching, and the CloakedCnameDetector caches its CNAME map in memory, refreshed only when the TDS dataset updates. These changes optimize the core tracker evaluation path, improving performance for users by reducing latency in blocking decisions. Also in this area: Migrate dependency injection from Dagger/Anvil to Metro.

app/src/main/java/com/duckduckgo/app/trackerdetection · high confidence

Tracking parameter removal now respects user allowlists

The tracking parameter removal feature has been updated to check the user's allowlist before cleaning URLs. Previously, only internal exceptions and temporary unprotected sites were checked; now, if a URL is present in the user's allowlist, tracking parameters will no longer be stripped, ensuring that user-configured exceptions are honored during the cleaning process.

privacy-config/privacy-config-impl/src/main/java/com/duckduckgo/privacy/config/impl/features/trackingparameters · high confidence

Tracking parameters are now loaded into memory only in the main process

The tracking parameters repository now loads privacy configuration data into memory exclusively for the main application process. This change ensures that tracking parameter and exception data is cached in memory only when running in the primary process, avoiding redundant loading in background or secondary processes.

privacy-config/privacy-config-store/src/main/java/com/duckduckgo/privacy/config/store/features/trackingparameters · high confidence

Unified favorites display mode and new entity storage model

The saved-sites store now supports a unified view of favorites alongside the existing native view, controlled by a new \FavoritesDisplayMode\ setting (NATIVE or UNIFIED) persisted in shared preferences. To support this, the underlying data model has been refactored to use a generic \Entity\ table (with \BOOKMARK\ or \FOLDER\ types) and a separate \Relation\ table for folder membership, replacing the previous structure. This new schema includes specific migration logic to consolidate native mobile and desktop favorites into a single unified root folder, and the store provides methods to manage these form-factor-specific folder structures.

saved-sites/saved-sites-store · high confidence

Updated privacy grade submodule and added editorconfig

The privacy-grade submodule has been updated to a new commit (f59b564), which likely incorporates changes to the privacy grading algorithm as suggested by the commit message. Additionally, an .editorconfig file has been added to the submodules directory to enforce consistent coding styles.

submodules · medium confidence

User-Agent string generation now supports per-site client hint brand overrides

The user-agent implementation has been refactored to support dynamic, per-site configuration of client hint brands. This change introduces a new \UserAgentFeature\ model and database storage (\ClientHintBrandDomainEntity\) to allow specific domains to be mapped to brand hints (DuckDuckGo, Google Chrome, or Android WebView). The \RealUserAgentProvider\ now integrates these remote-config-driven brand hints, enabling the browser to send more accurate or compatible User-Agent strings for sites that require specific browser identification, while maintaining fallback logic for legacy behavior and user allow-lists.

user-agent-impl · high confidence

VPN background workers now run in a dedicated process

Periodic background tasks for App Tracking Protection are now executed in a separate VPN process rather than the main app process. This is achieved by introducing a new VpnRemoteWorkerService and a boundToVpnProcess extension for WorkManager requests, which ensures these workers are isolated from the main application lifecycle and can operate independently.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/worker · high confidence

VPN database schema updated to version 24

The VPN store database schema has been updated to version 24, introducing a new \stopReason\ column to the \vpn\_service\_state\_stats\ table to record why the VPN service stopped. This change is part of a broader series of migrations (versions 18 through 24) that also added health tracking tables (\AppHealthDatabase\, \HealthStatsDatabase\, \VpnRemoteConfigDatabase\) and refined the \vpn\_tracker\ and \app\_health\_state\ structures to support improved connectivity detection and app health monitoring.

app-tracking-protection/vpn-store · high confidence

VPN service now restarts automatically when DNS settings change

The VPN service now monitors system DNS changes and automatically restarts the VPN tunnel when the active network's DNS servers are updated. This is handled by a new DnsChangeCallback that listens for link property changes on cellular and Wi-Fi networks, ensuring the VPN remains functional and correctly configured after system-level DNS updates.

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/service · high confidence

Web detection and interference detection implementations migrate to Metro DI

The implementation modules for web detection and web interference detection have been rewritten to use the Metro dependency-injection framework. This change introduces Metro-native annotations (such as @ContributesIntoSet and @ContributesBinding) for registering feature plugins and data stores, and replaces the previous DI wiring with Metro's @BindingContainer and @Provides. Additionally, the data storage layer now uses AndroidX DataStore with SharedPreferences, and the feature plugins implement the PrivacyFeaturePlugin and ContentScopeConfigPlugin interfaces to store and serve remote configuration JSON for their respective features.

web-detection/web-detection-impl, web-interference-detection/web-interference-detection-impl · high confidence

Fixes

1 commit (1 fix) fixing (repo-wide)

A fix in (repo-wide) — 1 commit (1 fix), 25 files: “Detect device-transferred installs and fix previous-phone state (\#10443)” (refs \#10443).

app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/devicemigration · low confidence · unverified

2 commits (2 fixes) fixing app/src/main/java/com/duckduckgo/app/browser/state

A fix in app/src/main/java/com/duckduckgo/app/browser/state — 2 commits (2 fixs), 1 file: “Show NTP with hatch fix: Sync NTP with the hatch display (\#10417)”; “Show NTP with hatch fix: Prevent previous tab flashing (\#10416)” (refs \#10417, \#10416).

app/src/main/java/com/duckduckgo/app/browser/state · medium confidence · unverified

Bookmarks screen UI issues fixed

The Bookmarks screen now correctly handles edge-to-edge display, ensuring that the edit bookmark, new folder, and PDF viewer screens are no longer obscured by system UI elements.

saved-sites-impl · high confidence

Test coverage

Added E2E test steps for Sync critical paths and bookmark management; Added FakeVpnFeaturesRegistry for testing; Added FakeVpnNetworkStack test helper; Added instrumentation tests for first-party cookie expiration logic; Added reference tests for ad-click attribution allowlist and link formats; Added test double for App Tracker repository; Added test fakes for VPN notification content plugins; Added test infrastructure for DNS provider configuration; Added test utilities for mocking feature toggles and metrics; Added tests for App Tracking Protection core components; Added tests for MessageBridge and NavigatorInterface feature plugins; Added tests for ad-click attributed metric logic; Added tests for feature toggle API, code generation, and targeting logic; Added tests for native crash initialization and multi-process feature store; Added tests for the AMP Links repository; Added unit tests for ANR crash reporting and log sanitization; Added unit tests for ContentScopeExperiments feature logic; Added unit tests for DRM plugin and RealDrm implementation; Added unit tests for ExceptionListsSettingStore; Added unit tests for GPC feature implementation; Added unit tests for GPC repository logic; Added unit tests for HTTPS feature configuration and enforcement; Added unit tests for RealDrmRepository; Added unit tests for RealPageContextRepository; Added unit tests for RealTrackerAllowlistRepository; Added unit tests for RealTrackingParametersRepository; Added unit tests for RealUnprotectedTemporary exception handling; Added unit tests for RealUnprotectedTemporaryRepository; Added unit tests for Tracker Allowlist implementation and plugin; Added unit tests for ad-click implementation components; Added unit tests for ad-click pixel reporting and daily worker; Added unit tests for autofill feature repository and email protection settings persister; Added unit tests for content blocking and HTTPS exception repositories; Added unit tests for content blocking plugin and implementation; Added unit tests for fingerprint protection feature plugins; Added unit tests for fingerprint protection store repositories; Added unit tests for first-party cookie worker scheduling and execution; Added unit tests for the AMP links feature implementation; Added unit tests for tracking parameter removal feature; New Maestro E2E test steps for password manager operations; New common test utilities and fixtures; PIR integration test suite and API contracts added.

Dependencies

Add GitHub Action for PR-to-Asana synchronization

A new GitHub Action named 'pr-asana-sync' has been added to the repository, introducing a TypeScript-based tool that synchronizes pull requests with Asana. The implementation includes a \package-lock.json\ file defining dependencies such as \@actions/core\, \@actions/github\, the \asana\ SDK, and \markdown-it\, enabling automated updates to Asana tasks based on PR activity.

(dependencies) · high confidence

Upgrade Gradle Wrapper to version 8.14.4

The project's Gradle wrapper has been updated to use Gradle 8.14.4. This ensures that builds are executed with a specific, verified version of the Gradle build tool, improving build consistency and potentially enabling features or performance improvements available in the 8.x release line.

gradle · high confidence

Housekeeping

Added app-level lint baseline and ProGuard configuration files; App version updated to 5.295.3.

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

How this codebase got here

Score

  • CAI 53 → 52 (-0.8)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 57 → 68 (+11.7)
  • Architecture 95 → 94 (-1.1)
  • Maturity 60 → 65 (+4.9)
  • Readiness 50 → 45 (-5.0)
  • Security 55 → 57 (+1.6)
  • Domain Modelling 51 → 51 (+0.0)
  • Performance 77 → 89 (+12.2)

Resolved (329)

  • BrowserActivity.processIntent (cognitive 58) (app/src/main/java/com/duckduckgo/app/browser/BrowserActivity.kt)
  • BrowserActivity.processIntent (cyclomatic 28) (app/src/main/java/com/duckduckgo/app/browser/BrowserActivity.kt)
  • Change coupling clique: AttachmentView.kt, ModelPickerView.kt, OptionsView.kt, ReasoningModePickerView.kt (duckchat/duckchat-impl/src/main/java/com/duckduckgo/duckchat/impl/ui/nativeinput/views/AttachmentView.kt)
  • Coverage not measured — JavaScript/TypeScript suite
  • Critical CVE: [GHSA redacted] (.github/actions/pr-asana-sync/package-lock.json)
  • Dependency source pinned to a moving git ref
  • Duplicated block (10 lines × 2) (ad-click/ad-click-impl/src/main/java/com/duckduckgo/adclick/impl/metrics/AdClickAttributedMetric.kt)
  • Duplicated block (10 lines × 2) (ad-click/ad-click-impl/src/main/java/com/duckduckgo/adclick/impl/metrics/AdClickAttributedMetric.kt)
  • Duplicated block (10 lines × 2) (android-design-system/design-system-internal/src/main/java/com/duckduckgo/common/ui/internal/ui/dialogs/DialogsFragment.kt)
  • Duplicated block (10 lines × 2) (android-design-system/design-system/src/main/java/com/duckduckgo/common/ui/view/DaxDialog.kt)
  • Duplicated block (10 lines × 2) (app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/apps/ui/ExclusionListAdapter.kt)
  • Duplicated block (10 lines × 2) (app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/ui/newtab/AppTrackingProtectionNewTabSettingsViewModel.kt)
  • Duplicated block (10 lines × 2) (app/src/main/java/com/duckduckgo/app/browser/BrowserTabViewModel.kt)
  • Duplicated block (10 lines × 2) (app/src/main/java/com/duckduckgo/app/browser/webview/WebViewActivity.kt)
  • Duplicated block (10 lines × 2) (app/src/main/java/com/duckduckgo/widget/SearchAndFavoritesWidget.kt)
  • Duplicated block (10 lines × 2) (autofill/autofill-internal/src/main/java/com/duckduckgo/autofill/internal/AutofillInternalSettingsActivity.kt)
  • Duplicated block (10 lines × 2) (downloads/downloads-impl/src/main/java/com/duckduckgo/downloads/impl/RealDownloadsFileActions.kt)
  • Duplicated block (10 lines × 2) (pir/pir-impl/src/main/java/com/duckduckgo/pir/impl/common/actions/BrokerActionFailedEventHandler.kt)
  • Duplicated block (10 lines × 2) (subscriptions/subscriptions-impl/src/main/java/com/duckduckgo/subscriptions/impl/messaging/ItrMessagingInterface.kt)
  • Duplicated block (10 lines × 3) (app/src/internal/java/com/duckduckgo/app/audit/AuditSettingsActivity.kt)
  • …and 309 more

New (882)

  • AdditionalDefaultBrowserPromptsImpl.evaluate (cyclomatic 16) (app/src/main/java/com/duckduckgo/app/browser/defaultbrowsing/prompts/AdditionalDefaultBrowserPromptsImpl.kt)
  • BrowserActivity.processLaunchIntent (cognitive 65) (app/src/main/java/com/duckduckgo/app/browser/BrowserActivity.kt)
  • BrowserActivity.processLaunchIntent (cyclomatic 30) (app/src/main/java/com/duckduckgo/app/browser/BrowserActivity.kt)
  • BrowserTabViewModel.progressChanged (cyclomatic 19) (app/src/main/java/com/duckduckgo/app/browser/BrowserTabViewModel.kt)
  • Change coupling: AttachmentView.kt ↔ OptionsView.kt (duckchat/duckchat-impl/src/main/java/com/duckduckgo/duckchat/impl/ui/nativeinput/views/AttachmentView.kt)
  • Change coupling: ModelPickerView.kt ↔ ReasoningModePickerView.kt (duckchat/duckchat-impl/src/main/java/com/duckduckgo/duckchat/impl/ui/nativeinput/views/ModelPickerView.kt)
  • Change coupling: OptionsView.kt ↔ ReasoningModePickerView.kt (duckchat/duckchat-impl/src/main/java/com/duckduckgo/duckchat/impl/ui/nativeinput/views/OptionsView.kt)
  • Change coupling: SubscriptionsDummy.kt ↔ SubscriptionsManager.kt (subscriptions/subscriptions-dummy-impl/src/main/java/com/duckduckgo/subscriptions/impl/SubscriptionsDummy.kt)
  • ClassTooLong: AutoCompleteApi (app/src/main/java/com/duckduckgo/app/autocomplete/api/AutoComplete.kt)
  • Documentation: no build, run or usage example (PixelDefinitions/README.md)
  • DuckAiResponseWaitWideEventImpl.reconcileOnScreen (cognitive 21) (duckchat/duckchat-impl/src/main/java/com/duckduckgo/duckchat/impl/wideevents/DuckAiResponseWaitWideEvent.kt)
  • DuckChatContextualWebViewFragment.onViewCreated (cognitive 18) (duckchat/duckchat-impl/src/main/java/com/duckduckgo/duckchat/impl/contextual/DuckChatContextualWebViewFragment.kt)
  • DuckChatContextualWebViewViewModel.onPageContextReceived (cyclomatic 16) (duckchat/duckchat-impl/src/main/java/com/duckduckgo/duckchat/impl/contextual/DuckChatContextualWebViewViewModel.kt)
  • DuckChatContextualWebViewViewModel.submitPrompt (cognitive 19) (duckchat/duckchat-impl/src/main/java/com/duckduckgo/duckchat/impl/contextual/DuckChatContextualWebViewViewModel.kt)
  • Duplicated block (10 lines × 2) (ad-click/ad-click-impl/src/main/java/com/duckduckgo/adclick/impl/metrics/AdClickAttributedMetric.kt)
  • Duplicated block (10 lines × 2) (ad-click/ad-click-impl/src/main/java/com/duckduckgo/adclick/impl/metrics/AdClickAttributedMetric.kt)
  • Duplicated block (10 lines × 2) (android-design-system/design-system-internal/src/main/java/com/duckduckgo/common/ui/internal/ui/dialogs/DialogsFragment.kt)
  • Duplicated block (10 lines × 2) (android-design-system/design-system/src/main/java/com/duckduckgo/common/ui/view/DaxDialog.kt)
  • Duplicated block (10 lines × 2) (app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/apps/ui/ExclusionListAdapter.kt)
  • Duplicated block (10 lines × 2) (app-tracking-protection/vpn-impl/src/main/java/com/duckduckgo/mobile/android/vpn/ui/newtab/AppTrackingProtectionNewTabSettingsViewModel.kt)
  • …and 862 more

Changes since last survey

  • 255 commits — 234 feature/other, 21 fixes

By area

  • app/src — 41 commits
  • duckchat/duckchat-impl — 30 commits
  • sync/sync-impl — 26 commits
  • .github/workflows — 18 commits
  • (root) — 14 commits
  • ad-blocking/ad-blocking-impl — 14 commits
  • autofill/autofill-impl — 14 commits
  • subscriptions/subscriptions-impl — 14 commits
  • pir/pir-impl — 9 commits
  • (repo) — 8 commits
  • node_modules/@duckduckgo — 7 commits
  • next-steps/next-steps-impl — 6 commits
  • app/version — 5 commits
  • remote-messaging/remote-messaging-impl — 4 commits
  • PixelDefinitions/pixels — 3 commits
  • android-design-system/design-system — 3 commits
  • network-protection/network-protection-impl — 3 commits
  • autofill/autofill-api — 2 commits
  • browser/browser-ui — 2 commits
  • event-hub/event-hub-impl — 2 commits

Notable commits

  • fix: Detect device-transferred installs and fix previous-phone state (#10443)
  • fix: Fix Duck.ai's content missing its padding when coming back to a tab that's in memory (#10405)
  • fix: Fix Duck.ai's content view bottom inset (#10274)
  • fix: Fix NativeInputModeWidget.focusInput CalledFromWrongThreadException (#10186)
  • fix: Fix UI state race conditions in Autofill VM (#10295)
  • fix: Fix page load timeout pixel definitions to include form factor suffix (#10237)
  • fix: Fix race when cleaning up stale wide events with OnProcessStart policy (#10271)
  • fix: Fix view injection inside non-InjectableFragment fragments (#10294)
  • fix: Fix: Occasional delay when opening an app (#10391)
  • fix: Link the manual hotfix process when a hotfix fails on a conflict (#10153)
  • fix: Merge branch 'hotfix/5.301.1'
  • fix: Next Steps ship review fixes: show after onboarding, dismiss completed check list, tablet close button (#10340)
  • fix: PIR: Fix opt-out confirmation pixels overcounting removals (#10296)
  • fix: Run lint rule tests in PR CI and fix NoLifecycleObserverTest (#10235)
  • fix: Run nightly and hotfix E2E tests with high Maestro Cloud priority (#10334)
  • fix: Show NTP with hatch fix: Add a feature flag (#10398)
  • fix: Show NTP with hatch fix: Prevent previous tab flashing (#10416)
  • fix: Show NTP with hatch fix: Remove the selected-tab debounce (#10425)
  • fix: Show NTP with hatch fix: Sync NTP with the hatch display (#10417)
  • fix: Subscription Onboarding: Fix Settings entry point opening on the completion screen (#10465)
  • …and 235 more

Architecture

  • Containers 0 added · 0 removed · contexts 2 added · 0 removed · edges 9 added · 2 removed

Added bounded contexts (2)

  • device-migration-impl
  • next-steps-impl

Added dependency edges (9)

  • app → request-interception-impl
  • app-database → statistics-api (coupling)
  • device-migration-impl → browser-api
  • device-migration-impl → statistics-api (coupling)
  • experiments-impl → statistics-api (coupling)
  • next-steps-impl → browser-api (coupling)
  • next-steps-impl → statistics-api (coupling)
  • sync-impl → autofill-api (coupling)
  • sync-impl → browser-ui

Removed dependency edges (was a dependency, now gone) (2)

  • experiments-impl → statistics-api
  • sync-impl → autofill-api

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

Survey your own repository

duckduckgo/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.

About this page

  • The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 396ac4085123d122a78c00475d1faeb0f55010a9 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.64+preprod-569132d3dfbe.