box_database!(     H263SpecificBox                   0x6432_3633, // "d263"     MP4AudioSampleEntry               0x6d70_3461, // "mp4a"     MP4VideoSampleEntry               0x6d70_3476, // "mp4v"+    AMRNBSampleEntry                  0x7361_6d72, // "samr" - AMR narrow-band+    AMRWBSampleEntry                  0x7361_7762, // "sawb" - AMR wide-band+    AMRSpecificBox                    0x6461_6d72, // "damr"

     "karma-firefox-launcher": "~1.1.0",     "karma-mocha": "^2.0.1",     "karma-sinon": "^1.0.5",-    "mocha": "^8.0.1",+    "mocha": "^8.3.1",     "sinon": "^7.2.3",-    "webpack": "~4.27.1",-    "webpack-cli": "^3.3.11"+    "webpack": "^4.46.0",

++++// # Firefox Accounts Client+//+// The fxa-client component lets applications integrate with the+// [Firefox Accounts](https://mozilla.github.io/ecosystem-platform/docs/features/firefox-accounts/fxa-overview)+// identity service. The shape of a typical integration would look+// something like:+//+// * Out-of-band, register your application with the Firefox Accounts service,+//   providing an OAuth `redirect_uri` controlled by your application and+//   obtaining an OAuth `client_id`.+//+// * On application startup, create a [`FirefoxAccount`] object to represent the+//   signed-in state of the application.+//     * On first startup, a new [`FirefoxAccount`] can be created by calling+//       [`FirefoxAccount::new`] and passing the application's `client_id`.+//     * For subsequent startups the object can be persisted using the+//       [`to_json`](FirefoxAccount::to_json) method and re-created by+//       calling [`FirefoxAccount::from_json`].+//+// * When the user wants to sign in to your application, direct them through+//   a web-based OAuth flow using [`begin_oauth_flow`](FirefoxAccount::begin_oauth_flow)+//   or [`begin_pairing_flow`](FirefoxAccount::begin_pairing_flow); when they return+//   to your registered `redirect_uri`, pass the resulting authorization state back to+//   [`complete_oauth_flow`](FirefoxAccount::complete_oauth_flow) to sign them in.+//+// * Display information about the signed-in user by using the data from+//   [`get_profile`](FirefoxAccount::get_profile).+//+// * Access account-related services on behalf of the user by obtaining OAuth+//   access tokens via [`get_access_token`](FirefoxAccount::get_access_token).+//+// * If the user opts to sign out of the application, calling [`disconnect`](FirefoxAccount::disconnect)+//   and then discarding any persisted account data.++namespace fxa_client {+    +};++++// Generic error type thrown by many [`FirefoxAccount`] operations.+//+// Precise details of the error are hidden from consumers, mostly due to limitations of+// how we expose this API to other languages. The type of the error indicates how the+// calling code should respond.+//+//+//  `Authentication`:

 package mozilla.appservices.fxaclient  import android.util.Log-import com.sun.jna.Native-import com.sun.jna.Pointer-import mozilla.appservices.fxaclient.rust.FxaHandle-import mozilla.appservices.fxaclient.rust.LibFxAFFI-import mozilla.appservices.fxaclient.rust.RustError-import mozilla.appservices.support.native.toNioDirectBuffer-import java.util.concurrent.atomic.AtomicLong import org.json.JSONObject  /**- * FirefoxAccount represents the authentication state of a client.+ * PersistedFirefoxAccount represents the authentication state of a client.+ *+ * This is a thin wrapper around the `FirefoxAccount` object exposed from Rust.+ * Its main job is to transparently manage persistence of the account state by+ * calling the provided callback at appropriate times.+ *+ * In future it would be nice to push this logic down into the Rust code,+ * once UniFFI's support for callback interfaces is a little more battle-tested.+ *  */-class FirefoxAccount(handle: FxaHandle, persistCallback: PersistCallback?) : AutoCloseable {-    private var handle: AtomicLong = AtomicLong(handle)+class PersistedFirefoxAccount(inner: FirefoxAccount, persistCallback: PersistCallback?) : AutoCloseable {+    private var inner: FirefoxAccount = inner     private var persistCallback: PersistCallback? = persistCallback      /**-     * Create a FirefoxAccount using the given config.+     * Create a PersistedFirefoxAccount using the given config.      *      * This does not make network requests, and can be used on the main thread.      */-    constructor(config: Config, persistCallback: PersistCallback? = null) :-    this(rustCall { e ->-        LibFxAFFI.INSTANCE.fxa_new(-            config.contentUrl,-            config.clientId,-            config.redirectUri,-            config.tokenServerUrlOverride,-            e-        )-    }, persistCallback) {+    constructor(config: Config, persistCallback: PersistCallback? = null) : this(FirefoxAccount(+        config.contentUrl,

 class FxAccountManagerTests: XCTestCase {     func testAccountRestorationEnsureCapabilitiesNonAuthError() {         class MockAccount: MockFxAccount {             override func ensureCapabilities(supportedCapabilities _: [DeviceCapability]) throws {-                throw FirefoxAccountError.network(message: "The WiFi cable is detached.")+                throw FxaError.Network(message: "The WiFi cable is detached.")

 impl From<StateV1> for Result<StateV2> {     } } -// `StateV1` was a previous state schema.-//-// The below is sufficient to read existing state data serialized in this form, but should not-// be used to create new data using that schema, so it is deliberately private and deliberately-// does not derive(Serialize).-//-// If you find yourself modifying this code, you're almost certainly creating a potential data-migration-// problem and should reconsider.-+/// `StateV1` was a previous state schema.

+# Firefox Accounts Client++The fxa-client component lets applications integrate with the+[Firefox Accounts](https://mozilla.github.io/ecosystem-platform/docs/features/firefox-accounts/fxa-overview)+identity service.++* [Features](#features)+* [Using the Firefox Accounts client](#using-the-firefox-accounts-client)+* [Working on the Firefox Accounts client](#working-on-the-firefox-accounts-client)++## Features++The fxa-client component offers support for:++1. Letting users sign in to your app,+   using either an email-and-password-based OAuth flow+   or a QR-code-based pairing flow.+1. Accessing basic profile information about the signed-in user,+   such as email address and display name.+1. Obtaining OAuth access tokens and client-side encryption keys.+   in order to access account-enabled services such as Firefox Sync.+1. Listing and managing other applications connected to the+   user's account.+     1. Sending tabs to other applications that are capable+      of receiving them.

+/* This Source Code Form is subject to the terms of the Mozilla Public+ * License, v. 2.0. If a copy of the MPL was not distributed with this+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */++import Foundation++/// This class inherits from the Rust `FirefoxAccount` and adds:+/// - Automatic state persistence through `PersistCallback`.+/// - Auth error signaling through observer notifications.+/// - Some convenience higher-level datatypes, such as URLs rather than plain Strings.+///+/// Eventually we'd like to move all of this into the underlying Rust code, once UniFFI+/// grows support for these extra features:+///   - Callback interfaces in Swift: https://github.com/mozilla/uniffi-rs/issues/353+///   - Higher-level data types: https://github.com/mozilla/uniffi-rs/issues/348+///+/// It's not yet clear how we might integrate with observer notifications in+/// a cross-platform way, though.+///+class PersistedFirefoxAccount {+    private var persistCallback: PersistCallback?+    private var inner: FirefoxAccount++    init(inner: FirefoxAccount) {+        self.inner = inner+    }++    public convenience init(config: FxAConfig) {+        self.init(inner: FirefoxAccount(contentUrl: config.contentUrl,+                                        clientId: config.clientId,+                                        redirectUri: config.redirectUri,+                                        tokenServerUrlOverride: config.tokenServerUrlOverride))+    }++    /// Registers a persistance callback. The callback will get called every time+    /// the `FxAccounts` state needs to be saved. The callback must+    /// persist the passed string in a secure location (like the keychain).+    public func registerPersistCallback(_ cb: PersistCallback) {+        persistCallback = cb+    }++    /// Unregisters a persistance callback.+    public func unregisterPersistCallback() {+        persistCallback = nil+    }++    public static func fromJSON(data: String) throws -> PersistedFirefoxAccount {+        return PersistedFirefoxAccount(inner: try FirefoxAccount.fromJson(data: data))+    }++    public func toJSON() throws -> String {+        try inner.toJson()+    }++    public func beginOAuthFlow(+        scopes: [String],+        entrypoint: String,+        metrics: MetricsParams = MetricsParams(parameters: [:])+    ) throws -> URL {+        return try notifyAuthErrors {+            URL(string: try self.inner.beginOauthFlow(+                scopes: scopes,+                entrypoint: entrypoint,+                metrics: metrics+            ))!+        }+    }++    public func getPairingAuthorityURL() throws -> URL {+        return URL(string: try inner.getPairingAuthorityUrl())!+    }++    public func beginPairingFlow(+        pairingUrl: String,+        scopes: [String],+        entrypoint: String,+        metrics: MetricsParams = MetricsParams(parameters: [:])+    ) throws -> URL {+        return try notifyAuthErrors {+            URL(string: try self.inner.beginPairingFlow(pairingUrl: pairingUrl,+                                                        scopes: scopes,+                                                        entrypoint: entrypoint,+                                                        metrics: metrics))!+        }+    }++    public func completeOAuthFlow(code: String, state: String) throws {+        defer { tryPersistState() }

+# Firefox Accounts Client++The fxa-client component lets applications integrate with the+[Firefox Accounts](https://mozilla.github.io/ecosystem-platform/docs/features/firefox-accounts/fxa-overview)+identity service.++* [Features](#features)+* [Using the Firefox Accounts client](#using-the-firefox-accounts-client)+* [Working on the Firefox Accounts client](#working-on-the-firefox-accounts-client)++## Features++The fxa-client component offers support for:++1. Letting users sign in to your app,+   using either an email-and-password-based OAuth flow+   or a QR-code-based pairing flow.+1. Accessing basic profile information about the signed-in user,+   such as email address and display name.+1. Obtaining OAuth access tokens and client-side encryption keys.