LogSink implementation that writes to Android's log.

An animated progress bar following the Photon Design System.

SearchEngineProvider implementation to load the included search engines from assets.

A popup menu composed of BrowserMenuItem objects.

Helper class for building browser menus.

Interface to be implemented by menu items to be shown in the browser menu.

A toolbar of buttons to show inside the browser menu.

A customizable tabs tray for browsers.

A customizable toolbar for browsers.

A unique, randomly generated UUID for this client.

Config represents the server endpoint configurations needed for the authentication flow.

A generic wrapper for values that can get consumed.

The field 'created' from CreatedDateMeasurement will be deprecated for the `createdDate` field

The field 'created' from CreatedTimestampMeasurement will be deprecated for the `createdTimestamp` field

Contains functionality to manage custom domains for auto-completion.

Holds configuration data for a Custom Tab. Use createFromIntent to create instances.

This client just prints pings to logcat instead of uploading them. Therefore this client is only useful for debugging purposes.

Default implementation of SessionStorage which persists browser and engine session states to a JSON file.

Settings implementation used to set defaults for Engine and EngineSession.

Provides autocomplete functionality for domains, based on a provided list of assets (see Domains) and/or a custom domain list managed by CustomDomains.

Contains functionality to access domain lists shipped as part of this module's assets.

Value type that represents a Download.

Sub-component of the browser toolbar responsible for allowing the user to edit the URL.

Entry point for interacting with the engine implementation.

Class representing a single engine session.

View component that renders web content.

Presenter implementation for EngineView.

Enum containing all supported error types that we can display an error page for.

Represents an A/B test experiment, independent of the underlying storage mechanism

Class used to identify an experiment

Exception while downloading experiments from the server

Class which represents an experiment associated data

Represents a location where experiments are stored (Kinto, a JSON file on a server, etc)

Represents a location where experiments are stored locally on the device

Represents an experiment sync result

TelemetryStorage implementation that stores pings as files on disk.

FirefoxAccount represents the authentication state of a client.

This measurement will save the timestamp of the first time it was instantiated and report this as profile creation date.

Class which uses a flat JSON file as an experiment storage mechanism

Entry point of the library

Wrapper class for the exceptions thrown in the Rust library, which ensures that the error messages will be consumed and freed properly in Rust.

FxaResult is a class that represents an asynchronous result.

Gecko-based implementation of Engine interface.

Gecko-based EngineSession implementation.

Gecko-based EngineView implementation.

Represents all the different supported types of data that can be found from long clicking an element.

Represents an http client, used to make it easy to swap implementations as needed

A UI edit text component which supports inline autocompletion.

Processor for intents which should trigger session-related actions.

Default JSON parsing implementation

TelemetryPingSerializer that uses the org.json library provided by the Android system.

The Parser is a function that takes a JSON Response and maps it to a Suggestion list.

Class used to schedule sync of experiment configuration from the server

TelemetryScheduler implementation that uses Android's JobScheduler API to schedule ping uploads.

Manages data protection using a system-isolated cryptographic key.

Class responsible for fetching and parsing experiments from a Kinto server

LifecycleObserver which dispatches lifecycle events to an EngineView.

Registry which provides a list of our custom lint checks to be performed on an Android project.

Custom lint checks related to logging.

LocalizationProvider implementation that only provides the language and country from the system's default languageTag.

API for logging messages and exceptions.

A wrapper for the Log object providing a more convenient API for logging.

Interface for observables. This interface is implemented by ObserverRegistry so that classes that want to be observable can implement the interface by delegation:

A helper for classes that want to get observed. This class keeps track of registered observers and can automatically unregister observers if a LifecycleOwner is provided.

Interface for classes that want to intercept load requests to allow custom behavior.

A String wrapper utility that allows for efficient string reversal. We regularly need to reverse strings. The standard way of doing this in Java would be to copy the string to reverse (e.g. using StringBuffer.reverse()). This seems wasteful when we only read our Strings character by character, in which case can just transpose positions as needed.

Base class that wraps an non-optional Pointer representing a pointer to a Rust object. This class implements Closeable but does not provide an implementation, forcing all subclasses to implement it. This ensures that all classes that inherit from RustObject will have their Pointer destroyed when the Java wrapper is destroyed.

See SafeIntent for more background: applications can put garbage values into Bundles. This is primarily experienced when there's garbage in the Intent's Bundle. However that Bundle can contain further bundles, and we need to handle those defensively too.

External applications can pass values into Intents that can cause us to crash: in defense, we wrap Intent and catch the exceptions they may force us to throw. See bug 1090385 for more.

Used for when we need to schedule loading a url or data with a mime type, if there isn't a session already created.

A data class representing a search engine.

Interface for classes that want to filter the list of search engines a SearchEngineProvider implementation loads.

This class provides access to a centralized registry of search engines.

A very simple parser for search plugins.

Interface for classes that load search engines from a specific source.

Class providing language, country and optionally region (actual location) of the user/device to customize the search experience.

Provides an interface to get search suggestions from a given SearchEngine.

Async function responsible for taking a URL and returning the results

A function representing the search use case, accepting the search terms as string.

Contains use cases related to the search feature.

A TelemetryMeasurement implementation to count the number of times a user has searched with a specific engine from a specific location.

Value type that represents the state of a browser session. Changes can be observed.

Feature implementation for connecting the engine module with the session module.

This class provides access to a centralized registry of all active sessions.

Storage component for browser and engine sessions.

Contains use cases related to the session feature.

Holds settings of an engine or session. Concrete engine implementations define how these settings are applied i.e. whether a setting is applied on an engine or session instance.

A simple browser menu checkbox.

A simple browser menu item displaying text.

JobScheduler job used to updating the list of experiments

WebView-based implementation of the Engine interface.

WebView-based EngineSession implementation.

WebView-based implementation of EngineView.

A RecyclerView ViewHolder implementation for "tab" items.

RecyclerView adapter implementation to display a list/grid of tabs.

Feature implementation for connecting a tabs tray implementation with the session module.

Feature implementation for connecting a tabs tray implementation with a toolbar implementation.

Generic interface for components that provide "tabs tray" functionality.

Interactor for a tabs tray component. Subscribes to the tabs tray and invokes use cases to update the session manager.

Presenter implementation for a tabs tray implementation in order to update the tabs tray whenever the state of the session manager changes.

Contains use cases related to the tabs feature.

The TelemetryConfiguration class collects the information describing the telemetry setup of an app. There are some parts that every app needs to configure: Where should measurements store data? What servers are we actually uploading pings to? This class should provide good defaults so that in the best case it is not needed to modify the configuration.

This mobile-specific ping is intended to provide the most critical data in a concise format, allowing for frequent uploads. Since this ping is used to measure retention, it should be sent each time the app is opened. https://gecko.readthedocs.io/en/latest/toolkit/components/telemetry/telemetry/data/core-ping.html

TelemetryEvent specifies a common events data format, which allows for broader, shared usage of data processing tools.

A telemetry ping builder for pings of type "focus-event".

Holder of a static reference to the Telemetry instance. This is required for background services that somehow need to get access to the configuration and storage. This is not particular nice. Hopefully we can replace this with something better.

A telemetry ping builder for events of type "mobile-event". See the schema for more details: https://github.com/mozilla-services/mozilla-pipeline-schemas/blob/master/schemas/telemetry/mobile-event/mobile-event.1.schema.json

A telemetry ping builder for events of type "mobile-metrics". See the schema for more details: https://github.com/mozilla-services/mozilla-pipeline-schemas/blob/master/schemas/telemetry/mobile-metrics/mobile-metrics.1.schema.json

Interface to be implemented by components that provide browser toolbar functionality.

Feature implementation for connecting a toolbar implementation with the session module.

Connects a toolbar instance to the browser engine via use cases

Presenter implementation for a toolbar implementation in order to update the toolbar whenever the state of the selected session changes.

Simple implementation of a Trie, used for indexing URLs.

Exception thrown by default if a setting is not supported by an engine or session.

Provides functionality to process categorized URL black/white lists and match URLs against these lists.

Class used to provide custom filter values

Regular expressions used in this class are taken from Android's Patterns.java. We brought them in to standardize URL matching across Android versions, instead of relying on Android version-dependent built-ins that can vary across Android versions. The original code can be found here: http://androidxref.com/8.0.0_r4/xref/frameworks/base/core/java/android/util/Patterns.java

Class used to schedule sync of experiment configuration from the server using WorkManager