@react-native-ohos/react-native-ble-plx 3.2.1-rc.1

package/src/NativeBlePlx.ts

@@ -0,0 +1,121 @@
+/*
+ * MIT License
+ *
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import type { TurboModule } from 'react-native/Libraries/TurboModule/RCTExport';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+
+  // NativeModule methods
+
+  addListener(eventName: string): void;
+
+  removeListeners(count: number): void;
+
+  createClient(restoreStateIdentifier?: string): void;
+
+  destroyClient(): Promise<void>;
+
+  cancelTransaction(transactionId: string): Promise<void>;
+
+  setLogLevel(logLevel: string): Promise<Object>;
+
+  logLevel(): Promise<Object>;
+
+  enable(transactionId: string): Promise<void>;
+
+  disable(transactionId: string): Promise<void>;
+
+  state(): Promise<Object>;
+
+  startDeviceScan(filteredUUIDs?: Array<string>, options?: Object): Promise<void>;
+
+  stopDeviceScan(): Promise<void>;
+
+  requestConnectionPriorityForDevice(deviceId: string, connectionPriority: number, transactionId: string): Promise<Object>;
+
+  readRSSIForDevice(deviceId: string, transactionId: string): Promise<Object>;
+
+  requestMTUForDevice(deviceId: string, mtu: number, transactionId: string): Promise<Object>;
+
+  devices(deviceIdentifiers: Array<string>): Promise<Array<Object>>;
+
+  connectedDevices(serviceUUIDs: Array<string>): Promise<Array<Object>>;
+
+  connectToDevice(deviceId: string, options?: Object): Promise<Object>;
+
+  cancelDeviceConnection(deviceId: string): Promise<Object>;
+
+  isDeviceConnected(deviceId: string): Promise<boolean>;
+
+  discoverAllServicesAndCharacteristicsForDevice(deviceId: string, transactionId: string): Promise<Object>;
+
+  servicesForDevice(deviceId: string): Promise<Array<Object>>;
+
+  characteristicsForDevice(deviceId: string, serviceUUID: string): Promise<Array<Object>>;
+
+  characteristicsForService(serviceIdentifier: number): Promise<Array<Object>>;
+
+  descriptorsForDevice(deviceId: string, serviceUUID: string, characteristicUUID: string): Promise<Array<Object>>; //Object-->NativeDescriptor
+
+  descriptorsForService(serviceIdentifier: number, characteristicUUID: string): Promise<Array<Object>>; //Object-->NativeDescriptor
+
+  descriptorsForCharacteristic(characteristicIdentifier: number): Promise<Array<Object>>; //Object-->NativeDescriptor
+
+  readCharacteristicForDevice(deviceId: string, serviceUUID: string, characteristicUUID: string, transactionId: string): Promise<Object>; //Object-->NativeCharacteristic
+
+  readCharacteristicForService(serviceIdentifier: number, characteristicUUID: string, transactionId: string): Promise<Object>; //Object-->NativeCharacteristic
+
+  readCharacteristic(characteristicIdentifer: number, transactionId: string): Promise<Object>; //Object-->NativeCharacteristic
+
+  writeCharacteristicForDevice(deviceId: string, serviceUUID: string, characteristicUUID: string, valueBase64: string, response: boolean, transactionId: string): Promise<Object>; //Object-->NativeCharacteristic
+
+  writeCharacteristicForService(serviceIdentifier: number, characteristicUUID: string, valueBase64: string, response: boolean, transactionId: string): Promise<Object>; //Object-->NativeCharacteristic
+
+  writeCharacteristic(characteristicIdentifier: number, valueBase64: string, response: boolean, transactionId: string): Promise<Object>; //Object-->NativeCharacteristic
+
+  monitorCharacteristicForDevice(deviceId: string, serviceUUID: string, characteristicUUID: string, transactionId: string): Promise<void>;
+
+  monitorCharacteristicForService(serviceIdentifier: number, characteristicUUID: string, transactionId: string): Promise<void>;
+
+  monitorCharacteristic(characteristicIdentifier: number, transactionId: string): Promise<void>;
+
+  readDescriptorForDevice(deviceId: string, serviceUUID: string, characteristicUUID: string, descriptorUUID: string, transactionId: string): Promise<Object>; //Object-->NativeDescriptor
+
+  readDescriptorForService(serviceIdentifier: number, characteristicUUID: string, descriptorUUID: string, transactionId: string): Promise<Object>; //Object-->NativeDescriptor
+
+  readDescriptorForCharacteristic(characteristicIdentifier: number, descriptorUUID: string, transactionId: string): Promise<Object>; //Object-->NativeDescriptor
+
+  readDescriptor(descriptorIdentifier: number, transactionId: string): Promise<Object>; //Object-->NativeDescriptor
+
+  writeDescriptorForDevice(deviceId: string, serviceUUID: string, characteristicUUID: string, descriptorUUID: string, valueBase64: string, transactionId: string): Promise<Object>; //Object-->NativeDescriptor
+
+  writeDescriptorForService(serviceIdentifier: number, characteristicUUID: string, descriptorUUID: string, valueBase64: string, transactionId: string): Promise<Object>; //Object-->NativeDescriptor
+
+  writeDescriptorForCharacteristic(characteristicIdentifier: number, descriptorUUID: string, valueBase64: string, transactionId: string): Promise<Object>; //Object-->NativeDescriptor
+
+  writeDescriptor(descriptorIdentifier: number, valueBase64: string, transactionId: string): Promise<Object>; //Object-->NativeDescriptor
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('BlePlx');

package/src/Service.js

@@ -0,0 +1,188 @@
+// @flow
+'use strict'
+
+import type { BleManager } from './BleManager'
+import type { BleError } from './BleError'
+import type { Characteristic } from './Characteristic'
+import type { Descriptor } from './Descriptor'
+import type { NativeService } from './BleModule'
+import type { DeviceId, Identifier, Base64, UUID, Subscription, TransactionId } from './TypeDefinition'
+
+/**
+ * Service object.
+ */
+export class Service implements NativeService {
+  /**
+   * Internal BLE Manager handle
+   * @private
+   */
+  _manager: BleManager
+  /**
+   * Service unique identifier
+   */
+  id: Identifier
+  /**
+   * Service UUID
+   */
+  uuid: UUID
+  /**
+   * Device's ID to which service belongs
+   */
+  deviceID: DeviceId
+  /**
+   * Value indicating whether the type of service is primary or secondary.
+   */
+  isPrimary: boolean
+
+  /**
+   * Private constructor used to create {@link Service} object.
+   *
+   * @param {NativeService} nativeService NativeService properties to be copied.
+   * @param {BleManager} manager Current BleManager instance.
+   * @private
+   * @ignore
+   */
+  constructor(nativeService: NativeService, manager: BleManager) {
+    Object.assign(this, nativeService, { _manager: manager })
+  }
+
+  /**
+   * {@link #blemanagercharacteristicsfordevice|bleManager.characteristicsForDevice()} with partially filled arguments.
+   *
+   * @returns {Promise<Array<Characteristic>>} Promise which emits array of {@link Characteristic} objects which are
+   * discovered for this service.
+   */
+  characteristics(): Promise<Array<Characteristic>> {
+    return this._manager._characteristicsForService(this.id)
+  }
+
+  /**
+   * {@link #blemanagerdescriptorsfordevice|bleManager.descriptorsForDevice()} with partially filled arguments.
+   *
+   * @param {UUID} characteristicUUID {@link Characteristic} UUID.
+   * @returns {Promise<Array<Descriptor>>} Promise which emits array of {@link Descriptor} objects which are
+   * discovered for this {@link Service} in specified {@link Characteristic}.
+   */
+  descriptorsForCharacteristic(characteristicUUID: UUID): Promise<Array<Descriptor>> {
+    return this._manager._descriptorsForService(this.id, characteristicUUID)
+  }
+
+  /**
+   * {@link #blemanagerreadcharacteristicfordevice|bleManager.readCharacteristicForDevice()} with partially filled arguments.
+   *
+   * @param {UUID} characteristicUUID {@link Characteristic} UUID.
+   * @param {?TransactionId} transactionId optional `transactionId` which can be used in
+   * {@link #blemanagercanceltransaction|bleManager.cancelTransaction()} function.
+   * @returns {Promise<Characteristic>} Promise which emits first {@link Characteristic} object matching specified
+   * UUID path. Latest value of {@link Characteristic} will be stored inside returned object.
+   */
+  readCharacteristic(characteristicUUID: UUID, transactionId: ?TransactionId): Promise<Characteristic> {
+    return this._manager._readCharacteristicForService(this.id, characteristicUUID, transactionId)
+  }
+
+  /**
+   * {@link #blemanagerwritecharacteristicwithresponsefordevice|bleManager.writeCharacteristicWithResponseForDevice()} with partially filled arguments.
+   *
+   * @param {UUID} characteristicUUID {@link Characteristic} UUID.
+   * @param {Base64} valueBase64 Value in Base64 format.
+   * @param {?TransactionId} transactionId optional `transactionId` which can be used in
+   * {@link #blemanagercanceltransaction|bleManager.cancelTransaction()} function.
+   * @returns {Promise<Characteristic>} Promise which emits first {@link Characteristic} object matching specified
+   * UUID path. Latest value of characteristic may not be stored inside returned object.
+   */
+  writeCharacteristicWithResponse(
+    characteristicUUID: UUID,
+    valueBase64: Base64,
+    transactionId: ?TransactionId
+  ): Promise<Characteristic> {
+    return this._manager._writeCharacteristicWithResponseForService(
+      this.id,
+      characteristicUUID,
+      valueBase64,
+      transactionId
+    )
+  }
+
+  /**
+   * {@link #blemanagerwritecharacteristicwithoutresponsefordevice|bleManager.writeCharacteristicWithoutResponseForDevice()} with partially filled arguments.
+   *
+   * @param {UUID} characteristicUUID {@link Characteristic} UUID.
+   * @param {Base64} valueBase64 Value in Base64 format.
+   * @param {?TransactionId} transactionId optional `transactionId` which can be used in
+   * {@link #blemanagercanceltransaction|bleManager.cancelTransaction()} function.
+   * @returns {Promise<Characteristic>} Promise which emits first {@link Characteristic} object matching specified
+   * UUID path. Latest value of characteristic may not be stored inside returned object.
+   */
+  writeCharacteristicWithoutResponse(
+    characteristicUUID: UUID,
+    valueBase64: Base64,
+    transactionId: ?TransactionId
+  ): Promise<Characteristic> {
+    return this._manager._writeCharacteristicWithoutResponseForService(
+      this.id,
+      characteristicUUID,
+      valueBase64,
+      transactionId
+    )
+  }
+
+  /**
+   * {@link #blemanagermonitorcharacteristicfordevice|bleManager.monitorCharacteristicForDevice()} with partially filled arguments.
+   *
+   * @param {UUID} characteristicUUID - {@link Characteristic} UUID.
+   * @param {function(error: ?BleError, characteristic: ?Characteristic)} listener callback which emits
+   * {@link Characteristic} objects with modified value for each notification.
+   * @param {?TransactionId} transactionId optional `transactionId` which can be used in
+   * {@link #blemanagercanceltransaction|bleManager.cancelTransaction()} function.
+   * @returns {Subscription} Subscription on which `remove()` function can be called to unsubscribe.
+   */
+  monitorCharacteristic(
+    characteristicUUID: UUID,
+    listener: (error: ?BleError, characteristic: ?Characteristic) => void,
+    transactionId: ?TransactionId
+  ): Subscription {
+    return this._manager._monitorCharacteristicForService(this.id, characteristicUUID, listener, transactionId)
+  }
+
+  /**
+   * {@link #blemanagerreaddescriptorfordevice|bleManager.readDescriptorForDevice()} with partially filled arguments.
+   *
+   * @param {UUID} characteristicUUID {@link Characteristic} UUID.
+   * @param {UUID} descriptorUUID {@link Descriptor} UUID.
+   * @param {?TransactionId} transactionId optional `transactionId` which can be used in
+   * {@link #blemanagercanceltransaction|cancelTransaction()} function.
+   * @returns {Promise<Descriptor>} Promise which emits first {@link Descriptor} object matching specified
+   * UUID paths. Latest value of {@link Descriptor} will be stored inside returned object.
+   */
+  async readDescriptorForCharacteristic(
+    characteristicUUID: UUID,
+    descriptorUUID: UUID,
+    transactionId: ?TransactionId
+  ): Promise<Descriptor> {
+    return this._manager._readDescriptorForService(this.id, characteristicUUID, descriptorUUID, transactionId)
+  }
+
+  /**
+   * {@link #blemanagerwritedescriptorfordevice|bleManager.writeDescriptorForDevice()} with partially filled arguments.
+   *
+   * @param {UUID} characteristicUUID Characteristic UUID
+   * @param {UUID} descriptorUUID Descriptor UUID
+   * @param {Base64} valueBase64 Value to be set coded in Base64
+   * @param {?TransactionId} transactionId Transaction handle used to cancel operation
+   * @returns {Promise<Descriptor>} Descriptor which saved passed value.
+   */
+  async writeDescriptorForCharacteristic(
+    characteristicUUID: UUID,
+    descriptorUUID: UUID,
+    valueBase64: Base64,
+    transactionId: ?TransactionId
+  ): Promise<Descriptor> {
+    return this._manager._writeDescriptorForService(
+      this.id,
+      characteristicUUID,
+      descriptorUUID,
+      valueBase64,
+      transactionId
+    )
+  }
+}

package/src/TypeDefinition.js

@@ -0,0 +1,360 @@
+// @flow
+'use strict'
+
+import type { Device } from './Device'
+import { BleErrorCode } from './BleError'
+
+/**
+ * Bluetooth device id.
+ */
+export type DeviceId = string
+
+/**
+ * Unique identifier for BLE objects.
+ */
+export type Identifier = number
+
+/**
+ * Bluetooth UUID
+ */
+export type UUID = string
+
+/**
+ * Base64 value
+ */
+export type Base64 = string
+
+/**
+ * Transaction identifier. All transaction identifiers in numeric form are reserved for internal use.
+ */
+export type TransactionId = string
+
+/**
+ * [Android only] ConnectionOptions parameter to describe when to call BluetoothGatt.refresh()
+ */
+export type RefreshGattMoment = 'OnConnected'
+
+/**
+ * Subscription
+ * @interface
+ */
+export interface Subscription {
+  /**
+   * Removes subscription
+   * @memberof Subscription
+   * @ignore
+   */
+  remove(): void;
+}
+
+/**
+ * Type of error code mapping table
+ */
+export type BleErrorCodeMessageMapping = { [$Values < typeof BleErrorCode >]: string }
+
+/**
+ * Options which can be passed to when creating BLE Manager
+ */
+export interface BleManagerOptions {
+  /**
+   * BLE State restoration identifier used to restore state.
+   * @memberof BleManagerOptions
+   * @instance
+   */
+  restoreStateIdentifier?: string;
+
+  /**
+   * Optional function which is used to properly restore state of your BLE Manager. Callback
+   * is emitted in the beginning of BleManager creation and optional {@link BleRestoreState}
+   * is passed. When value is `null` application is launching for the first time, otherwise
+   * it contains saved state which may be used by developer to continue working with
+   * connected peripherals.
+   * @memberof BleManagerOptions
+   * @instance
+   */
+  restoreStateFunction?: (restoredState: ?BleRestoredState) => void;
+
+  /**
+   * Optional mapping of error codes to error messages. Uses {@link BleErrorCodeMessage}
+   * by default.
+   *
+   * To override logging UUIDs or MAC adresses in error messages copy the original object
+   * and overwrite values of interest to you.
+   *
+   * @memberof BleManagerOptions
+   * @instance
+   */
+  errorCodesToMessagesMapping?: BleErrorCodeMessageMapping;
+}
+
+/**
+ * Object representing information about restored BLE state after application relaunch.
+ */
+export interface BleRestoredState {
+  /**
+   * List of connected devices after state restoration.
+   * @type {Array<Device>}
+   * @instance
+   * @memberof BleRestoredState
+   */
+  connectedPeripherals: Array<Device>;
+}
+
+/**
+ * Scan mode for Bluetooth LE scan.
+ */
+export const ScanMode = {
+  /**
+   * A special Bluetooth LE scan mode. Applications using this scan mode will passively listen for
+   * other scan results without starting BLE scans themselves. [Android only]
+   */
+  Opportunistic: -1,
+
+  /**
+   * Perform Bluetooth LE scan in low power mode. This is the default scan mode as it consumes the
+   * least power. [Android and Harmony] [default value]
+   */
+  LowPower: 0,
+
+  /**
+   * Perform Bluetooth LE scan in balanced power mode. Scan results are returned at a rate that
+   * provides a good trade-off between scan frequency and power consumption. [Android and Harmony]
+   */
+  Balanced: 1,
+
+  /**
+   * Scan using highest duty cycle. It's recommended to only use this mode when the application is
+   * running in the foreground. [Android and Harmony]
+   */
+  LowLatency: 2
+}
+
+/**
+ * The enum of BLE match mode.
+ */
+export const MatchMode = {
+  /**
+   * Aggressive mode
+   */
+  Aggressive: 1,
+
+  /**
+   * Sticky mode
+   */
+  Sticky: 2
+}
+
+/**
+ * Phy type used during scan.
+ */
+export const PhyType = {
+  /**
+   * Use 1M phy for scanning.
+   */
+  LE_1M: 1,
+
+  /**
+   * Use all supported Phys for scanning.
+   */
+  LE_All_Supported: 255
+}
+
+/**
+ * Scan callback type for Bluetooth LE scan.
+ * @name ScanCallbackType
+ */
+export const ScanCallbackType = {
+  /**
+   * Trigger a callback for every Bluetooth advertisement found that matches the filter criteria.
+   * If no filter is active, all advertisement packets are reported. [default value]
+   */
+  AllMatches: 1,
+
+  /**
+   * A result callback is only triggered for the first advertisement packet received that matches
+   * the filter criteria.
+   */
+  FirstMatch: 2,
+
+  /**
+   * Receive a callback when advertisements are no longer received from a device that has been
+   * previously reported by a first match callback.
+   */
+  MatchLost: 4
+}
+
+/**
+ * Options which can be passed to scanning function
+ * @name ScanOptions
+ */
+export interface ScanOptions {
+  /**
+   * By allowing duplicates scanning records are received more frequently [iOS only]
+   * @memberof ScanOptions
+   * @instance
+   */
+  allowDuplicates?: boolean;
+
+  /**
+   * Scan mode for Bluetooth LE scan [Android and Harmony]
+   * @memberof ScanOptions
+   * @instance
+   */
+  scanMode?: $Values<typeof ScanMode>;
+
+  /**
+   * Scan callback type for Bluetooth LE scan [Android only]
+   * @memberof ScanOptions
+   * @instance
+   */
+  callbackType?: $Values<typeof ScanCallbackType>;
+  /**
+   * Use legacyScan (default true) [Android only]
+   * https://developer.android.com/reference/android/bluetooth/le/ScanSettings.Builder#setLegacy(boolean)
+   * @memberof ScanOptions
+   * @instance
+   */
+  legacyScan?: boolean;
+
+  /**
+   * Time of delay for reporting the scan result [Harmony only]
+   * @memberof ScanOptions
+   * @instance
+   */
+  interval?: number;
+
+  /**
+   * Match mode for Bluetooth LE scan filters hardware match [Harmony only]
+   * @memberof ScanOptions
+   * @instance
+   */
+  matchMode?: $Values<typeof MatchMode>;
+
+  /**
+   * Physical Layer used during scan [Harmony only]
+   * @memberof ScanOptions
+   * @instance
+   */
+  phyType?: $Values<typeof PhyType>;
+}
+
+/**
+ * Connection specific options to be passed before connection happen. [Not used]
+ */
+export interface ConnectionOptions {
+  /**
+   * Whether to directly connect to the remote device (false) or to automatically connect as soon as the remote device
+   * becomes available (true). [Android only]
+   * @memberof ConnectionOptions
+   * @instance
+   */
+  autoConnect?: boolean;
+
+  /**
+   * Whether MTU size will be negotiated to this value. It is not guaranteed to get it after connection is successful.
+   *
+   * @memberof ConnectionOptions
+   * @instance
+   */
+  requestMTU?: number;
+
+  /**
+   * Whether action will be taken to reset services cache. This option may be useful when a peripheral's firmware was
+   * updated and it's services/characteristics were added/removed/altered. [Android only]
+   * {@link https://stackoverflow.com/questions/22596951/how-to-programmatically-force-bluetooth-low-energy-service-discovery-on-android}
+   * @memberof ConnectionOptions
+   * @instance
+   */
+  refreshGatt?: RefreshGattMoment;
+
+  /**
+   * Number of milliseconds after connection is automatically timed out. In case of race condition were connection is
+   * established right after timeout event, device will be disconnected immediately. Time out may happen earlier then
+   * specified due to OS specific behavior.
+   *
+   * @memberof ConnectionOptions
+   * @instance
+   */
+  timeout?: number;
+}
+
+/**
+ * Device Bluetooth Low Energy state. It's keys are used to check {@link #blemanagerstate} values
+ * received by {@link BleManager}
+ */
+export const State = {
+  /**
+   * The current state of the manager is unknown; an update is imminent.
+   */
+  Unknown: 'Unknown',
+  /**
+   * The connection with the system service was momentarily lost; an update is imminent.
+   */
+  Resetting: 'Resetting',
+  /**
+   * The platform does not support Bluetooth low energy.
+   */
+  Unsupported: 'Unsupported',
+  /**
+   * The app is not authorized to use Bluetooth low energy.
+   */
+  Unauthorized: 'Unauthorized',
+  /**
+   * Bluetooth is currently powered off.
+   */
+  PoweredOff: 'PoweredOff',
+  /**
+   * Bluetooth is currently powered on and available to use.
+   */
+  PoweredOn: 'PoweredOn'
+}
+
+/**
+ * Native module logging log level. By default it is set to None.
+ * @name LogLevel
+ */
+export const LogLevel = {
+  /**
+   * Logging in native module is disabled
+   */
+  None: 'None',
+  /**
+   * All logs in native module are shown
+   */
+  Verbose: 'Verbose',
+  /**
+   * Only debug logs and of higher importance are shown in native module.
+   */
+  Debug: 'Debug',
+  /**
+   * Only info logs and of higher importance are shown in native module.
+   */
+  Info: 'Info',
+  /**
+   * Only warning logs and of higher importance are shown in native module.
+   */
+  Warning: 'Warning',
+  /**
+   * Only error logs and of higher importance are shown in native module.
+   */
+  Error: 'Error'
+}
+
+/**
+ * Connection priority of BLE link determining the balance between power consumption and data throughput.
+ * @name ConnectionPriority
+ */
+export const ConnectionPriority = {
+  /**
+   * Default, recommended option balanced between power consumption and data throughput.
+   */
+  Balanced: 0,
+  /**
+   * High priority, low latency connection, which increases transfer speed at the expense of power consumption.
+   */
+  High: 1,
+  /**
+   * Low power, reduced data rate connection setup.
+   */
+  LowPower: 2
+}

package/src/Utils.js

@@ -0,0 +1,26 @@
+// @flow
+'use strict'
+
+import type { UUID } from './TypeDefinition'
+
+/**
+ * Converts UUID to full 128bit, lowercase format which should be used to compare UUID values.
+ *
+ * @param {UUID} uuid 16bit, 32bit or 128bit UUID.
+ * @returns {UUID} 128bit lowercase UUID.
+ */
+export function fullUUID(uuid: UUID): UUID {
+  if (uuid.length === 4) {
+    return '0000' + uuid.toLowerCase() + '-0000-1000-8000-00805f9b34fb'
+  }
+  if (uuid.length === 8) {
+    return uuid.toLowerCase() + '-0000-1000-8000-00805f9b34fb'
+  }
+  return uuid.toLowerCase()
+}
+
+export function fillStringWithArguments(value: string, object: Object): string {
+  return value.replace(/\{([^}]+)\}/g, function (_, arg: string) {
+    return object[arg] || '?'
+  })
+}