@dittolive/ditto 4.4.4 → 4.5.0

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

@@ -0,0 +1,495 @@
+//
+// 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 = {
+  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._parameters
+  }
+
+  /** @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._parameters = parameters
+    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)
+    this.subscriptions = Object.freeze(newSyncSubscriptions)
+
+    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
+    this.ditto.deferClose(() => {
+      // prettier-ignor
+      mapFFIErrors(
+        () => FFI.tryExperimentalRemoveDQLSubscription(dittoHandle.deref(), syncSubscription.queryString, syncSubscription.queryArgumentsCBOR)
+      )
+    })
+    return true
+  }
+
+  /** @internal */
+  update(parameters: SyncParameters) {
+    this._parameters = { ...parameters }
+
+    const stateOld = this.state
+    const stateNew = stateFrom(this.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()
+    }
+
+
+  }
+
+  // ------------------------------------------------------------ Private ------
+
+  private state: SyncState
+
+  private _parameters: SyncParameters
+
+  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) {
+    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) {
+        FFI.transportsBLEDestroy(this.bluetoothLETransportPointer as FFI.Pointer<FFI.TransportBluetooth>)
+        this.bluetoothLETransportPointer = null
+      }
+    })
+  }
+
+  private updatePeerToPeerAWDL(stateOld: SyncState, stateNew: SyncState) {
+    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) {
+        FFI.transportsAWDLDestroy(this.awdlTransportPointer as FFI.Pointer<FFI.TransportAWDL>)
+        this.awdlTransportPointer = null
+      }
+    })
+  }
+
+  private updatePeerToPeerLAN(stateOld: SyncState, stateNew: SyncState) {
+    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
+      }
+
+
+      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)
+    })
+  }
+}
+
+/**
+ * @private
+ */
+function stateFrom(parameters: SyncParameters): SyncState {
+  const ditto = parameters.ditto
+  const dittoHandle = Bridge.ditto.handleFor(ditto)
+  return ditto.deferClose(() => {
+
+
+    const transportConfig = parameters.transportConfig.copy()
+    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') {
+      appID = identity.appID
+      customDittoCloudURL = identity.customDittoCloudURL ?? null
+      isDittoCloudSyncEnabled = identity.enableDittoCloudSync ?? true
+    }
+
+    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(', ')}`)
+    }
+
+    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
+    }
+
+    if (isSyncActive && isWebValid && isDittoCloudSyncEnabled) {
+      const dittoCloudURL = customDittoCloudURL ?? defaultDittoCloudURL(appID)
+      transportConfig.connect.websocketURLs.push(dittoCloudURL)
+    }
+
+    return {
+      underlyingSyncParameters: parameters,
+      effectiveTransportConfig: transportConfig.freeze(),
+    }
+  })
+}

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]
+  }
+}