The result of authentication with FxA via an OAuth flow.

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 node of the abstract syntax tree.

An interface equivalent to the LoginsStorage interface, but where operations are asynchronous.

A helper class to wrap a synchronous LoginsStorage implementation and make it asynchronous.

An exception which may happen while obtaining auth information using FirefoxAccount.

An auth-related exception type, for use with AuthException.

Describes an object to which a AutocompleteResult may be applied. Usually, this will delegate to a specific text view.

Describes an autocompletion result.

Interface to be implemented by awesome bar implementations.

Connects an AwesomeBar with a Toolbar and allows adding multiple AwesomeBar.SuggestionProvider implementations.

Provides common autocomplete functionality powered by domain lists.

A customizable AwesomeBar implementation.

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.

Value type that represents a select option, optgroup or menuitem html element.

android.support.v4.app.DialogFragment implementation to display choice(options,optgroup and menu) web content in native dialogs.

A generic Client for fetching resources via HTTP/s.

A unique, randomly generated UUID for this client.

This defines the common set of data shared across all the different metric types.

The Configuration class describes how to configure the Glean.

An interface which describes a Closeable connection that provides access to a PlacesAPI.

A generic wrapper for values that can get consumed.

A generic wrapper for a stream of values that can be consumed. Values will be consumed first in, first out.

A candidate for an item to be displayed in the context menu.

Feature for displaying a context menu after long-pressing web content.

DialogFragment implementation to display the actual context menu dialog.

Feature implementation for connecting an EngineView with any View that you want to coordinate scrolling behavior with.

Crash types that are handled by this library.

Service receiving native code crashes (from GeckoView).

A generic crash reporter that can report crashes to multiple services.

Activity showing the crash reporter prompt asking the user for confirmation before submitting a crash report.

Interface to be implemented by external services that accept crash reports.

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.

Provides autocomplete functionality for domains based on a list managed by CustomDomains.

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

Service providing Custom Tabs related functionality.

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

Settings implementation used to set defaults for Engine and EngineSession.

Class intended for internal use which encapsulates meta data about a domain.

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

Describes an autocompletion result against a list of domains.

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

Value type that represents a Download.

This is a general representation of a dialog meant to be used in collaboration with DownloadsFeature to show a dialog before a download is triggered. If SimpleDownloadDialogFragment is not flexible enough for your use case you should inherit for this class. Be mindful to call onStartDownload when you want to start the download.

Handles the interactions with the AndroidDownloadManager.

Feature implementation for proving download functionality for the selected session. It will subscribe to the selected session and will listening for downloads.

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.

This implements the developer facing API for recording events.

Thread.UncaughtExceptionHandler implementation that forwards crashes to the CrashReporter instance.

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

Generic test cases for concept-fetch implementations.

TelemetryStorage implementation that stores pings as files on disk.

FirefoxAccount represents the authentication state of a client.

Facilitates testing consumers of FirefoxAccount.

A feature implementation which orchestrates data synchronization of a set of SyncableStore which all share a common AuthType.

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

A Firefox Sync friendly auth object which can be obtained from FirefoxAccount.

Wrapper class for the exceptions thrown in the Rust library.

Gecko-based implementation of Engine interface.

Gecko-based EngineSession implementation.

Gecko-based EngineView implementation.

Gecko-based implementation of PermissionRequest.

A base class for 'scalar' like metrics. This allows sharing the common store managing and lifetime behaviours.

Grammar of the JEXL language.

Represents a Header containing of a name and value.

A collection of HTTP Headers (immutable) of a Request or Response.

Describes an autocompletion result against history storage.

An interface which defines read/write methods for history data.

A AwesomeBar.SuggestionProvider implementation that provides suggestions based on the browsing history stored in the HistoryStorage.

An interface used for providing history information to an engine (e.g. for link highlighting), and receiving history updates from the engine (visits to URLs, title changes).

Feature implementation for connecting an engine implementation with a history storage implementation in order to enable engine to track history.

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 simple ping Uploader, which implements a "send once" policy, never storing or attempting to send the ping again.

HttpURLConnection implementation of Client.

This is thrown if add() is given a record whose id is not blank, and collides with a record already known to the storage instance.

An in-memory implementation of mozilla.components.concept.storage.HistoryStorage.

A UI edit text component which supports inline autocompletion.

Processor for intents which should trigger session-related actions.

This error is emitted in two cases:

This is thrown on attempts to insert or update a record so that it is no longer valid, where "invalid" is defined as such:

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.

JEXL Array type.

JEXL Boolean type.

Variables defined in the JexlContext are available to expressions.

JEXL Double type.

Generic exception thrown when evaluating an expression failed.

JEXL Integer type.

JEXL Object type.

JEXL String type.

JEXL undefined type.

A JEXL value type.

Class used to schedule sync of experiment configuration from the server

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

Wraps the critical functions around a Java KeyStore to better facilitate testing and instrumenting.

Manages data protection using a system-isolated cryptographic key.

Exception type thrown by {@link Keystore} when an error is encountered that is not otherwise covered by an existing sub-class to GeneralSecurityException.

Class responsible for fetching and parsing experiments from a Kinto server

LifecycleObserver which dispatches lifecycle events to an EngineView.

Enumeration of different metric lifetimes.

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.

The base class of all errors emitted by logins storage.

This is thrown if lock()/unlock() pairs don't match up.

A CrashReporterService implementation uploading crash reports to crash-stats.mozilla.com.

A collection of HTTP Headers (mutable) of a Request or Response.

geckoView that supports nested scrolls (for using in a CoordinatorLayout).

WebView that supports nested scrolls (for using in a CoordinatorLayout).

This is thrown if update() is performed with a record whose ID does not exist.

Scoped key data.

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.

Client implementation using OkHttp.

A representation of an Android Padding.

Represents all the different supported permission types.

Represents a permission request, used when engines need access to protected resources. Every request must be handled by either calling grant or reject.

The interface defining how to send pings.

Implementation of the HistoryStorage which is backed by a Rust Places lib via PlacesConnection.

An abstract representation for all different types of prompt dialogs. for handling PromptFeature dialogs.

Feature for displaying native dialogs for html elements like: input type date,file,time,color, option, menu, authentication, confirmation and other alerts.

Value type that represents a request for showing a native dialog for prompt web content.

The Request data class represents a resource request to be send by a Client.

This error is emitted if a request to a sync server failed.

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

The Response data class represents a reponse to a Request send by a Client.

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.

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.

Encapsulates a set of properties which define a result of querying history storage.

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

Async function responsible for taking a URL and returning the results

A AwesomeBar.SuggestionProvider implementation that provides a suggestion containing search engine suggestions (as chips) from the passed in SearchEngine.

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.

This class is a combination of Session.Observer and SessionManager.Observer. It provides functionality to observe changes to a specified or selected session, and can automatically take care of switching over the observer in case a different session gets selected (see observeFixed and observeSelected).

A CrashReporterService implementation that uploads crash reports to a Sentry server.

Raw password data that is stored by the storage implementation.

Servo-based implementation of the Engine interface.

Servo-based EngineSession implementation.

Servo-based implementation of EngineView.

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.

Session storage for persisting the state of a SessionManager to disk (browser and engine session states).

A AwesomeBar.SuggestionProvider implementation that provides suggestions based on the sessions in the SessionManager (Open tabs).

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.

Provides autocomplete functionality for domains based on provided list of assets (see Domains).

A simple browser menu checkbox.

A simple browser menu item displaying text.

A confirmation dialog to be called before a download is triggered. Meant to be used in collaboration with DownloadsFeature

This implements the developer facing API for recording string metrics.

This indicates that the authentication information (e.g. the SyncUnlockInfo) provided to AsyncLoginsStorage.sync is invalid. This often indicates that it's stale and should be refreshed with FxA (however, care should be taken not to get into a loop refreshing this information).

JobScheduler job used to updating the list of experiments

A set of results of running a sync operation for all configured stores.

This type contains the set of information required to successfully connect to the server and sync.

Wraps AsyncLoginsStorage instance along with a lazy encryption key.

Describes a "sync" entry point for store which operates over AuthInfo.

WebView-based implementation of the Engine interface.

WebView-based EngineSession implementation.

WebView-based implementation of EngineView.

WebView-based implementation of PermissionRequest.

WebView-based implementation of WindowRequest.

A Toolbar.Action implementation that shows a TabCounter.

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

A token emitted by the Lexer.

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

Feature implementation for connecting a toolbar with a list of autocomplete providers.

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.

This implements the developer facing API for recording uuids.

Class used to provide custom filter values

Visit type constants as defined by Desktop Firefox.

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

Feature implementation for handling window requests.

Represents a request to open or close a browser window.

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