@dittolive/ditto 4.5.1-experimental.aarch64-linux.1.aarch64 → 4.5.2-rc.2

package/react-native/src/sources/sync.ts

@@ -0,0 +1,559 @@
+//
+// Copyright © 2021 DittoLive Incorporated. All rights reserved.
+//
+
+import * as FFI from './ffi'
+import * as Environment from './@environment'
+
+import { Bridge } from './bridge'
+import { CBOR, documentIDReplacer } from './cbor'
+import { defaultDittoCloudURL } from './internal'
+import { SyncSubscription } from './sync-subscription'
+import { TransportConfig } from './transport-config'
+import { DittoError, mapFFIErrors } from './error'
+
+import type { Ditto } from './ditto'
+import type { Identity } from './identity'
+import type { DQLQueryArguments } from './essentials'
+
+/** @internal */
+export type SyncParameters = {
+  readonly isSyncActive: boolean
+  readonly isX509Valid: boolean
+  readonly isWebValid: boolean
+  readonly ditto: Ditto
+  readonly identity: Identity
+  readonly transportConfig: TransportConfig
+}
+
+/** @internal */
+export type SyncState = {
+  // NOTE: we can get away with just an effective transport config for now,
+  // but this is meant to carry more state if need be. Whenever possible,
+  // prefer putting logic into the `stateFrom()` function together with some
+  // flags here and keep the `updateXXX()` to just diffing and updating the
+  // low-level transports machinery.
+  readonly underlyingSyncParameters: SyncParameters
+  readonly effectiveTransportConfig: TransportConfig
+}
+
+/**
+ * Provides access to sync related functionality of Ditto.
+ *
+ * Access this object via {@link Ditto.sync | Ditto.sync} on any Ditto instance.
+ */
+export class Sync {
+  /**
+   * The {@link Ditto} instance managed by this sync object.
+   */
+  readonly ditto: Ditto
+
+  /**
+   * All currently active sync subscriptions.
+   *
+   * **Note:** Manage sync subscriptions using
+   * {@link registerSubscription | registerSubscription()} to register a new
+   * sync subscription and
+   * {@link SyncSubscription.cancel | SyncSubscription.cancel()} to remove an
+   * existing sync subscription.
+   */
+  readonly subscriptions: Readonly<Array<SyncSubscription>> = Object.freeze([])
+
+  /**
+   * Installs and returns a sync subscription for a query, configuring Ditto to
+   * receive updates from other peers for documents matching that query. The
+   * passed in query must be a `SELECT` query, otherwise an error is thrown.
+   *
+   * @param query a string containing a valid query expressed in DQL.
+   * @param queryArguments an object containing the arguments for the query.
+   * Example: `{mileage: 123}` for a query with `:mileage` placeholder.
+   * @returns An active `SyncSubscription` for the passed in query and
+   * arguments. It will remain active until it is
+   * {@link SyncSubscription.cancel | cancelled} or the {@link Ditto} instance
+   * managing the sync subscription has been closed.
+   * @throws {@link DittoError} `query/invalid`: if `query` argument is not a
+   * string or not valid DQL.
+   * @throws {@link DittoError} `query/arguments-invalid`: if `queryArguments`
+   * argument is invalid (e.g. contains unsupported types).
+   * @throws {@link DittoError} `query/unsupported`: if the query is not a
+   * `SELECT` query.
+   * @throws {@link DittoError} may throw other errors.
+   */
+  registerSubscription(query: string, queryArguments?: DQLQueryArguments): SyncSubscription {
+    if (typeof query !== 'string') {
+      throw new DittoError('query/invalid', `Expected parameter 'query' to be of type 'string', found: ${typeof query}`)
+    }
+
+    let queryArgumentsCBOR: Uint8Array | null = null
+    if (queryArguments != null) {
+      try {
+        queryArgumentsCBOR = CBOR.encode(queryArguments, documentIDReplacer)
+      } catch (error: any) {
+        throw new DittoError('query/arguments-invalid', `Unable to encode query arguments: ${error.message}`)
+      }
+    }
+
+    const errorContext = { query, queryArguments }
+    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
+    this.ditto.deferClose(() => {
+      mapFFIErrors(() => FFI.tryExperimentalAddDQLSubscription(dittoHandle.deref(), query, queryArgumentsCBOR), undefined, errorContext)
+    })
+
+    const subscription = new SyncSubscription(this.ditto, query, queryArguments || null, queryArgumentsCBOR)
+
+    // @ts-expect-error modifying readonly property
+    this.subscriptions = Object.freeze([...this.subscriptions, subscription])
+
+    return subscription
+  }
+
+  // ---------------------------------------------------------- Internal ------
+
+  /** @internal */
+  get parameters(): SyncParameters {
+    return this.state.underlyingSyncParameters
+  }
+
+  /** @internal */
+  constructor(ditto: Ditto) {
+    const identity = ditto.identity
+    const transportConfig = new TransportConfig()
+    const parameters = { identity, transportConfig, ditto, isWebValid: false, isX509Valid: false, isSyncActive: false }
+
+    this.ditto = ditto
+    this.state = stateFrom(parameters)
+
+    FFI.transportsInit()
+  }
+
+  /**
+   * Removes the passed in `syncSubscription`, configuring Ditto to not receive
+   * updates for documents matching the corresponding query anymore. No-op if
+   * the passed in `syncSubscription` has already been removed.
+   *
+   * This must only be called by the sync subscription itself.
+   *
+   * @param syncSubscription the sync subscription to remove
+   * @returns `true` if the passed in sync subscription could be found and has
+   * been removed, otherwise returns `false`.
+   * @throws {@link DittoError} `internal`: if the replication subscription does not
+   * belong to this store
+   * @throws {@link DittoError} `internal`: if the replication subscription has not
+   * been cancelled yet
+   * @internal
+   */
+  unregisterSubscription(syncSubscription: SyncSubscription): boolean {
+    if (syncSubscription.ditto !== this.ditto) {
+      throw new DittoError('internal', `Can't remove replication subscription that does not belong to this store`)
+    }
+
+    if (!syncSubscription.isCancelled) {
+      throw new DittoError('internal', "Internal inconsistency, can't remove replication subscription that has not been cancelled")
+    }
+
+    const indexToDelete = this.subscriptions.findIndex((s) => s === syncSubscription)
+    if (indexToDelete === -1) {
+      return false
+    }
+
+    const newSyncSubscriptions = [...this.subscriptions]
+    newSyncSubscriptions.splice(indexToDelete, 1)
+    // @ts-expect-error modifying readonly property
+    this.subscriptions = Object.freeze(newSyncSubscriptions)
+
+    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
+    this.ditto.deferClose(() => {
+      // prettier-ignore
+      mapFFIErrors(
+        () => FFI.tryExperimentalRemoveDQLSubscription(dittoHandle.deref(), syncSubscription.queryString, syncSubscription.queryArgumentsCBOR)
+      )
+    })
+    return true
+  }
+
+  /** @internal */
+  update(parameters: SyncParameters) {
+    // NOTE: updating is a two-step process. Given all parameters, we
+    // first compute the final "state" we want the transports stuff to
+    // be in via the `stateFrom()` function. We then take that "desired" state
+    // and feed it into the various update methods, which essentially perform
+    // a diff on the state before and after, and update the low-level transports
+    // machinery accordingly.
+
+    const stateOld = this.state
+    const stateNew = stateFrom(parameters)
+
+    this.updatePeerToPeerBluetoothLE(stateOld, stateNew)
+    this.updatePeerToPeerAWDL(stateOld, stateNew)
+    this.updatePeerToPeerLAN(stateOld, stateNew)
+    this.updateListenTCP(stateOld, stateNew)
+    this.updateListenHTTP(stateOld, stateNew)
+    this.updateConnectTCPServers(stateOld, stateNew)
+    this.updateConnectWebsocketURLs(stateOld, stateNew)
+    this.updateGlobal(stateOld, stateNew)
+    this.updateConnectRetryInterval(stateOld, stateNew)
+
+    this.state = stateNew
+  }
+
+  /** @internal */
+  close() {
+    if (this.parameters.isSyncActive) {
+      throw new Error(`Internal inconsistency, can't close sync object while sync is active, please 'stopSync()' first.`)
+    }
+
+    for (const subscription of this.subscriptions) {
+      subscription.cancel()
+    }
+
+    // Nothing to do, when sync is stopped, this object should be
+    // already be cleaned up properly.
+  }
+
+  // ------------------------------------------------------------ Private ------
+
+  private state: SyncState
+
+  private bluetoothLETransportPointer: FFI.Pointer<'DittoTransportsBLE_t'> | null = null
+  private awdlTransportPointer: FFI.Pointer<'DittoTransportsAWDL_t'> | null = null
+  private lanTransportPointer: FFI.Pointer<'DittoTransportsLAN_t'> | null = null
+  private mdnsClientTransportPointer: FFI.Pointer<'DittoTransportsMdnsClient_t'> | null = null
+  private mdnsServerAdvertiserPointer: FFI.Pointer<'DittoTransportsMdnsServer_t'> | null = null
+
+  private updatePeerToPeerBluetoothLE(stateOld: SyncState, stateNew: SyncState) {
+    // Updating BLE transport is a no-op outside of Node.js & React Native.
+    if (!Environment.isNodeBuild && !Environment.isReactNativeBuild) return
+
+    const ditto = this.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    ditto.deferClose(() => {
+      const bluetoothLEOld = stateOld.effectiveTransportConfig.peerToPeer.bluetoothLE
+      const bluetoothLENew = stateNew.effectiveTransportConfig.peerToPeer.bluetoothLE
+
+      const shouldStart = !bluetoothLEOld.isEnabled && bluetoothLENew.isEnabled
+      const shouldStop = bluetoothLEOld.isEnabled && !bluetoothLENew.isEnabled
+
+      if (shouldStart && this.bluetoothLETransportPointer) throw new Error(`Internal inconsistency, when starting BLE transport, no BLE transport pointer should exist.`)
+      if (shouldStop && !this.bluetoothLETransportPointer) throw new Error(`Internal inconsistency, when stopping BLE transport, a BLE transport pointer should exist.`)
+
+      if (process.platform === 'linux' || process.platform === 'win32') {
+        if (shouldStart) {
+          const clientTransport = FFI.dittoAddInternalBLEClientTransport(dittoHandle.deref())
+          const serverTransport = FFI.dittoAddInternalBLEServerTransport(dittoHandle.deref())
+          const blePlatform = { clientTransport, serverTransport } as any
+          this.bluetoothLETransportPointer = blePlatform
+        }
+
+        if (shouldStop) {
+          const blePlatform = this.bluetoothLETransportPointer as any
+          const { clientTransport, serverTransport } = blePlatform
+          FFI.bleServerFreeHandle(serverTransport)
+          FFI.bleClientFreeHandle(clientTransport)
+          this.bluetoothLETransportPointer = null
+        }
+
+        return
+      }
+
+      if (shouldStart) {
+        this.bluetoothLETransportPointer = FFI.transportsBLECreate(dittoHandle.deref()) as FFI.Pointer<FFI.TransportBluetooth> | null
+      }
+
+      if (shouldStop) {
+        // null check is performed above
+        FFI.transportsBLEDestroy(this.bluetoothLETransportPointer as FFI.Pointer<FFI.TransportBluetooth>)
+        this.bluetoothLETransportPointer = null
+      }
+    })
+  }
+
+  private updatePeerToPeerAWDL(stateOld: SyncState, stateNew: SyncState) {
+    // Updating AWDL transport is a no-op outside of Node.js & React Native.
+    if (!Environment.isNodeBuild && !Environment.isReactNativeBuild) return
+
+    const ditto = this.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    ditto.deferClose(() => {
+      const awdlOld = stateOld.effectiveTransportConfig.peerToPeer.awdl
+      const awdlNew = stateNew.effectiveTransportConfig.peerToPeer.awdl
+
+      const shouldStart = !awdlOld.isEnabled && awdlNew.isEnabled
+      const shouldStop = awdlOld.isEnabled && !awdlNew.isEnabled
+
+      if (shouldStart && this.awdlTransportPointer) throw new Error(`Internal inconsistency, when starting AWDL transport, no AWDL transport pointer should exist.`)
+      if (shouldStop && !this.awdlTransportPointer) throw new Error(`Internal inconsistency, when stopping AWDL transport, an AWDL transport pointer should exist.`)
+
+      if (shouldStart) {
+        this.awdlTransportPointer = FFI.transportsAWDLCreate(dittoHandle.deref()) as FFI.Pointer<FFI.TransportAWDL> | null
+      }
+
+      if (shouldStop) {
+        // null check is performed above
+        FFI.transportsAWDLDestroy(this.awdlTransportPointer as FFI.Pointer<FFI.TransportAWDL>)
+        this.awdlTransportPointer = null
+      }
+    })
+  }
+
+  private updatePeerToPeerLAN(stateOld: SyncState, stateNew: SyncState) {
+    // Updating LAN transport currently only works with Node.js & React Native.
+    if (!Environment.isNodeBuild && !Environment.isReactNativeBuild) return
+
+    const ditto = this.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    ditto.deferClose(() => {
+      const lanOld = stateOld.effectiveTransportConfig.peerToPeer.lan
+      const lanNew = stateNew.effectiveTransportConfig.peerToPeer.lan
+      
+      if (process.platform === 'win32' || process.platform === 'linux') {
+        if (lanOld.isEnabled) {
+          if (lanOld.isMdnsEnabled) {
+            if (this.mdnsClientTransportPointer == null) throw new Error(`Internal inconsistency, when stopping LAN transport, a LAN transport pointer should exist.`)
+            FFI.mdnsClientFreeHandle(this.mdnsClientTransportPointer)
+            this.mdnsClientTransportPointer = null
+
+            if (this.mdnsServerAdvertiserPointer == null) throw new Error(`Internal inconsistency, when stopping LAN transport, a LAN transport pointer should exist.`)
+            FFI.mdnsServerFreeHandle(this.mdnsServerAdvertiserPointer)
+            this.mdnsServerAdvertiserPointer = null
+          }
+
+          if (lanOld.isMulticastEnabled) {
+            FFI.dittoRemoveMulticastTransport(dittoHandle.deref())
+          }
+        }
+
+        if (lanNew.isEnabled) {
+          if (lanNew.isMdnsEnabled) {
+            this.mdnsClientTransportPointer = FFI.dittoAddInternalMdnsTransport(dittoHandle.deref())
+            this.mdnsServerAdvertiserPointer = FFI.dittoAddInternalMdnsAdvertiser(dittoHandle.deref())
+          }
+
+          if (lanNew.isMulticastEnabled) {
+            FFI.dittoAddMulticastTransport(dittoHandle.deref())
+          }
+        }
+
+        return
+      }
+
+      // IDEA: move the logic for this dance into stateFrom() signal
+      // via some additional state signaling the actions here.
+
+      if (lanOld.isEnabled) {
+        if (lanOld.isMdnsEnabled) {
+          if (this.lanTransportPointer == null) throw new Error(`Internal inconsistency, when stopping LAN transport, a LAN transport pointer should exist.`)
+          FFI.transportsLANDestroy(this.lanTransportPointer as FFI.Pointer<FFI.TransportLAN>)
+          this.lanTransportPointer = null
+        }
+
+        if (lanOld.isMulticastEnabled) {
+          FFI.dittoRemoveMulticastTransport(dittoHandle.deref())
+        }
+      }
+
+      if (lanNew.isEnabled) {
+        if (lanNew.isMdnsEnabled) {
+          if (this.lanTransportPointer != null) throw new Error(`Internal inconsistency, when starting LAN transport, no LAN transport pointer should exist.`)
+          this.lanTransportPointer = FFI.transportsLANCreate(dittoHandle.deref()) as FFI.Pointer<FFI.TransportLAN>
+        }
+
+        if (lanNew.isMulticastEnabled) {
+          FFI.dittoAddMulticastTransport(dittoHandle.deref())
+        }
+      }
+    })
+  }
+
+  private updateListenTCP(stateOld: SyncState, stateNew: SyncState) {
+    const ditto = this.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    ditto.deferClose(() => {
+      const tcpOld = stateOld.effectiveTransportConfig.listen.tcp
+      const tcpNew = stateNew.effectiveTransportConfig.listen.tcp
+
+      if (TransportConfig.areListenTCPsEqual(tcpNew, tcpOld)) return
+
+      if (tcpOld.isEnabled) FFI.dittoStopTCPServer(dittoHandle.deref())
+      if (tcpNew.isEnabled) FFI.dittoStartTCPServer(dittoHandle.deref(), `${tcpNew.interfaceIP}:${tcpNew.port}`)
+    })
+  }
+
+  private updateListenHTTP(stateOld: SyncState, stateNew: SyncState) {
+    const ditto = this.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    ditto.deferClose(() => {
+      const httpOld = stateOld.effectiveTransportConfig.listen.http
+      const httpNew = stateNew.effectiveTransportConfig.listen.http
+
+      if (TransportConfig.areListenHTTPsEqual(httpOld, httpNew)) return
+      if (httpOld.isEnabled) FFI.dittoStopHTTPServer(dittoHandle.deref())
+
+      /* eslint-disable */
+      if (httpNew.isEnabled) {
+        FFI.dittoStartHTTPServer(dittoHandle.deref(), `${httpNew.interfaceIP}:${httpNew.port}`, httpNew.staticContentPath || null, httpNew.websocketSync ? 'Enabled' : 'Disabled', httpNew.tlsCertificatePath || null, httpNew.tlsKeyPath || null)
+      }
+      /* eslint-enable */
+    })
+  }
+
+  private updateConnectTCPServers(stateOld: SyncState, stateNew: SyncState) {
+    const ditto = this.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    ditto.deferClose(() => {
+      const tcpServers = stateNew.effectiveTransportConfig.connect.tcpServers
+      FFI.dittoSetStaticTCPClients(dittoHandle.deref(), tcpServers)
+    })
+  }
+
+  private updateConnectWebsocketURLs(stateOld: SyncState, stateNew: SyncState) {
+    const ditto = this.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    ditto.deferClose(() => {
+      const websocketURLs = stateNew.effectiveTransportConfig.connect.websocketURLs
+      const routingHint = stateNew.effectiveTransportConfig.global.routingHint
+      FFI.dittoSetStaticWebsocketClients(dittoHandle.deref(), websocketURLs, routingHint)
+    })
+  }
+
+  private updateGlobal(stateOld: SyncState, stateNew: SyncState) {
+    const ditto = this.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    ditto.deferClose(() => {
+      if (stateOld.effectiveTransportConfig.global.syncGroup !== stateNew.effectiveTransportConfig.global.syncGroup) {
+        FFI.dittoSetSyncGroup(dittoHandle.deref(), stateNew.effectiveTransportConfig.global.syncGroup)
+      }
+    })
+  }
+
+  private updateConnectRetryInterval(stateOld: SyncState, stateNew: SyncState) {
+    const ditto = this.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    ditto.deferClose(() => {
+      FFI.dittoSetConnectRetryInterval(dittoHandle.deref(), stateNew.effectiveTransportConfig.connect.retryInterval)
+    })
+  }
+}
+
+/**
+ * Computes the effective transport config given a desired transport config and
+ * some additional state.
+ *
+ * Disables all transports that are unavailable due to the runtime environment
+ * or authentication requirements. Adds websocket URL for Ditto Cloud if
+ * enabled.
+ *
+ * Throws if the target transport config enables sync but contains transports
+ * that are not available in the current environment. Does not throw when
+ * transports are enabled but not available due to authentication requirements.
+ *
+ * @private
+ */
+function stateFrom(parameters: SyncParameters): SyncState {
+  // IMPORTANT: this function maps a set of sync parameters to an effective
+  // transport config plus some extra state where need be. Make sure
+  // to keep this function free of side-effects.
+
+  const identity = parameters.identity
+
+  const isSyncActive = parameters.isSyncActive
+  const isX509Valid = parameters.isX509Valid
+  const isWebValid = parameters.isWebValid
+
+  let appID
+  let customDittoCloudURL
+  let isDittoCloudSyncEnabled = false
+
+  if (identity.type === 'onlinePlayground' || identity.type === 'onlineWithAuthentication') {
+    // NOTE: enableDittoCloudSync is true by default for any online identity.
+    appID = identity.appID
+    customDittoCloudURL = identity.customDittoCloudURL ?? null
+    isDittoCloudSyncEnabled = identity.enableDittoCloudSync ?? true
+  }
+
+  validateEnabledTransportsAvailable(parameters.ditto, parameters.transportConfig)
+
+  const transportConfig = parameters.transportConfig.copy()
+
+  if (!isSyncActive || !isX509Valid) {
+    transportConfig.peerToPeer.bluetoothLE.isEnabled = false
+    transportConfig.peerToPeer.awdl.isEnabled = false
+    transportConfig.peerToPeer.lan.isEnabled = false
+    transportConfig.listen.tcp.isEnabled = false
+    transportConfig.connect.tcpServers = []
+  }
+
+  if (!isSyncActive || !isWebValid) {
+    transportConfig.connect.websocketURLs = []
+  }
+
+  if (!isSyncActive) {
+    transportConfig.listen.http.isEnabled = false
+  }
+
+  // NOTE: we have to smuggle in an additional Ditto Cloud websocket URL to
+  // connect to if cloud sync is enabled.
+  if (isSyncActive && isWebValid && isDittoCloudSyncEnabled) {
+    // @ts-ignore To fix this type error, refactor using a switch
+    // statement, c.f.
+    // https://github.com/getditto/ditto/blob/d35b6c1cb280cdd6368d14137c97609b9b9b9296/js/sources/sync.ts#L488
+    const dittoCloudURL = customDittoCloudURL ?? defaultDittoCloudURL(appID)
+    transportConfig.connect.websocketURLs.push(dittoCloudURL)
+  }
+
+  return {
+    underlyingSyncParameters: parameters,
+    effectiveTransportConfig: transportConfig.freeze(),
+  }
+}
+
+/**
+ * Validate that all enabled transports are available in the current environment
+ * and throw an error if not.
+ *
+ * @private
+ */
+function validateEnabledTransportsAvailable(ditto: Ditto, transportConfig: TransportConfig) {
+  const dittoHandle = Bridge.ditto.handleFor(ditto)
+  return ditto.deferClose(() => {
+    // - BLE
+    // - AWDL
+    // - LAN / mDNS
+
+    const unavailableButEnabledP2PTransports = []
+
+    const isBLEAvailable = FFI.transportsBLEIsAvailable(dittoHandle.deref())
+    const isAWDLAvailable = FFI.transportsAWDLIsAvailable(dittoHandle.deref())
+    const isLANAvailable = FFI.transportsLANIsAvailable(dittoHandle.deref())
+
+    if (transportConfig.peerToPeer.bluetoothLE.isEnabled && !isBLEAvailable) {
+      unavailableButEnabledP2PTransports.push('BluetoothLE')
+    }
+
+    if (transportConfig.peerToPeer.awdl.isEnabled && !isAWDLAvailable) {
+      unavailableButEnabledP2PTransports.push('AWDL')
+    }
+
+    if (transportConfig.peerToPeer.lan.isEnabled && !isLANAvailable) {
+      unavailableButEnabledP2PTransports.push('LAN')
+    }
+
+    if (unavailableButEnabledP2PTransports.length > 0) {
+      throw new Error(`The following P2P transports are enabled in the transport config but are not supported in the current environment: ${unavailableButEnabledP2PTransports.join(', ')}`)
+    }
+
+    // - Websocket / HTTP
+    // - TCP
+
+    if (transportConfig.connect.tcpServers.length > 0 && Environment.isWebBuild) {
+      throw new Error(`The transport config contains TCP servers, but this transport is not supported in web environments`)
+    }
+
+    if (transportConfig.listen.http.isEnabled && Environment.isWebBuild) {
+      throw new Error(`The transport config contains an HTTP listener, which is not supported in web environments`)
+    }
+
+    if (transportConfig.listen.tcp.isEnabled && Environment.isWebBuild) {
+      throw new Error(`The transport config contains a TCP listener, which is not supported in web environments`)
+    }
+  })
+}

package/react-native/src/sources/test-helpers.ts

@@ -0,0 +1,24 @@
+import { Bridge } from './bridge'
+
+/**
+ * Get a count of bridged objects binned by bridge type.
+ *
+ * Use this in testing to ensure that all objects are properly garbage collected at the end of tests.
+ *
+ * @returns an object with a key per bridge type, set to the count of registered
+ * objects.
+ */
+export function getBridgeLoad(): { [bridgeName: string]: number } {
+  const countsByType: { [bridgeName: string]: number } = {}
+  Bridge.all.map((bridgeWeakRef) => {
+    const bridge = bridgeWeakRef.deref()
+    if (!bridge) {
+      return null
+    }
+    if (bridge.count === 0) {
+      return null
+    }
+    countsByType[bridge.type.name] = bridge.count
+  })
+  return countsByType
+}

package/react-native/src/sources/transport-conditions-manager.ts

@@ -0,0 +1,104 @@
+//
+// Copyright © 2021 DittoLive Incorporated. All rights reserved.
+//
+
+import * as FFI from './ffi'
+
+import { Bridge } from './bridge'
+import { ObserverManager } from './observer-manager'
+
+import type { Ditto, TransportCondition, ConditionSource } from './ditto'
+
+/** @internal */
+export class TransportConditionsManager extends ObserverManager {
+  readonly ditto: Ditto
+
+  constructor(ditto: Ditto) {
+    const keepAlive = ditto.keepAlive
+    super('TransportConditionsObservation', { keepAlive })
+    this.ditto = ditto
+  }
+
+  protected register(callback: (...args: any[]) => void) {
+    const ditto = this.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    return ditto.deferClose(() => {
+      return FFI.dittoRegisterTransportConditionChangedCallback(dittoHandle.deref(), callback)
+    })
+  }
+
+  protected unregister() {
+    const ditto = this.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    return ditto.deferClose(() => {
+      return FFI.dittoRegisterTransportConditionChangedCallback(dittoHandle.deref(), null)
+    })
+  }
+
+  protected process(conditionSource: FFI.ConditionSource, transportCondition: FFI.TransportCondition): [TransportCondition, ConditionSource] {
+    /* eslint-disable */
+    let apiConditionSource: ConditionSource
+    switch (conditionSource) {
+      case 'Bluetooth':
+        apiConditionSource = 'BLE'
+        break
+      case 'Tcp':
+        apiConditionSource = 'TCP'
+        break
+      case 'Awdl':
+        apiConditionSource = 'AWDL'
+        break
+      case 'Mdns':
+        apiConditionSource = 'MDNS'
+        break
+    }
+    /* eslint-enable */
+
+    /* eslint-disable */
+    let apiTransportCondition: TransportCondition
+    switch (transportCondition) {
+      case 'Unknown':
+        apiTransportCondition = 'Unknown'
+        break
+      case 'Ok':
+        apiTransportCondition = 'OK'
+        break
+      case 'GenericFailure':
+        apiTransportCondition = 'GenericFailure'
+        break
+      case 'AppInBackground':
+        apiTransportCondition = 'AppInBackground'
+        break
+      case 'MdnsFailure':
+        apiTransportCondition = 'MDNSFailure'
+        break
+      case 'TcpListenFailure':
+        apiTransportCondition = 'TCPListenFailure'
+        break
+      case 'NoBleCentralPermission':
+        apiTransportCondition = 'NoBLECentralPermission'
+        break
+      case 'NoBlePeripheralPermission':
+        apiTransportCondition = 'NoBLEPeripheralPermission'
+        break
+      case 'CannotEstablishConnection':
+        apiTransportCondition = 'CannotEstablishConnection'
+        break
+      case 'BleDisabled':
+        apiTransportCondition = 'BLEDisabled'
+        break
+      case 'NoBleHardware':
+        apiTransportCondition = 'NoBLEHardware'
+        break
+      case 'WifiDisabled':
+        apiTransportCondition = 'WiFiDisabled'
+        break
+      case 'TemporarilyUnavailable':
+        apiTransportCondition = 'TemporarilyUnavailable'
+        break
+    }
+    /* eslint-enable */
+
+    return [apiTransportCondition, apiConditionSource]
+  }
+}