@bubblsdk/react-native-sdk 4.1.7 → 5.0.0-alpha.1

package/src/index.ts

@@ -1,323 +1,379 @@
-import {
-  NativeEventEmitter,
-  NativeModules,
-  type EmitterSubscription,
-} from 'react-native';
-import NativeBubblSdk from './specs/NativeBubblSdk';
-
-export type BubblEnvironment = 'development' | 'staging' | 'production';
-export type BubblLogLevel = 'off' | 'error' | 'warn' | 'info' | 'debug';
-export type BubblNotificationRenderingMode = 'sdkDefault' | 'hostRendered' | 'eventOnly';
-export type BubblNotificationSource = 'firebase' | 'apns' | 'runtime' | 'geofence' | 'manual';
-export type BubblNotificationModalTheme = 'light' | 'dark';
-
-export type BubblNotificationModalStyle = {
-  theme?: BubblNotificationModalTheme;
-  transparentBackdrop?: boolean;
-  backdropColor?: string | null;
-  cardBackgroundColor?: string | null;
-  cardBorderColor?: string | null;
-  titleColor?: string | null;
-  bodyColor?: string | null;
-  accentColor?: string | null;
-  iconBackgroundColor?: string | null;
-  iconTextColor?: string | null;
-  primaryButtonBackgroundColor?: string | null;
-  primaryButtonTextColor?: string | null;
-  secondaryButtonBackgroundColor?: string | null;
-  secondaryButtonTextColor?: string | null;
-  textButtonColor?: string | null;
-  surveyBackgroundColor?: string | null;
-  inputBackgroundColor?: string | null;
-  inputTextColor?: string | null;
-  inputBorderColor?: string | null;
-  cornerRadius?: number | null;
-  buttonCornerRadius?: number | null;
+import { NativeEventEmitter, Platform } from 'react-native';
+import NativeBubblSdk from './BubblModule';
+import type { Spec } from './NativeBubblSdk';
+import type {
+  BubblCredential,
+  BubblDiagnostics,
+  BubblEvent,
+  BubblMessage,
+  BubblOptions,
+  BubblPermissionStatus,
+  BubblTestDeviceResult,
+  EventListener,
+  NotificationListener,
+  Subscription,
+  SurveyAnswers,
+} from './types';
+
+export type * from './types';
+
+/** The one native event every event, and every notification for the app's listener, arrives on. */
+const NATIVE_EVENT = 'BubblSdkEvent';
+
+const PACKAGE = '@bubblsdk/react-native-sdk';
+const JEST_MOCK = `jest.mock('${PACKAGE}', () => require('${PACKAGE}/jest'))`;
+
+type Globals = {
+  __turboModuleProxy?: unknown;
+  RN$Bridgeless?: boolean;
+  process?: { env?: Record<string, string | undefined> };
 };
 
-export type BubblConfig = {
-  apiKey: string;
-  environment?: BubblEnvironment;
-  runtimeBaseUrl?: string | null;
-  transmissionBaseUrl?: string | null;
-  ingestBaseUrl?: string | null;
-  segments?: string[];
-  correlationId?: string | null;
-  defaultDistanceMeters?: number;
-  refreshIntervalSeconds?: number;
-  enablePushHandling?: boolean;
-  enableLocationTracking?: boolean;
-  notificationRenderingMode?: BubblNotificationRenderingMode;
-  enableDefaultNotificationModal?: boolean;
-  defaultNotificationModalStyle?: BubblNotificationModalStyle | null;
-  enableDefaultSurveyUi?: boolean;
-  logLevel?: BubblLogLevel;
-};
-
-export type BubblBootResult = {
-  ready: boolean;
-  fromCache: boolean;
-  deviceRegistered: boolean;
-  requiresPermission: string[];
-  warnings: string[];
-};
-
-export type BubblLocation = {
-  latitude: number;
-  longitude: number;
-};
-
-export type BubblGeofenceTransitionType = 'enter' | 'exit';
-
-export type BubblGeofenceTransition = {
-  type: BubblGeofenceTransitionType;
-  campaignId?: string | null;
-  locationId?: string | null;
-  location: BubblLocation;
-};
-
-export type BubblGeofenceVertex = BubblLocation;
-
-export type BubblGeofencePolygon = {
-  campaignId?: string | null;
-  campaignName?: string | null;
-  locationId?: string | null;
-  vertices: BubblGeofenceVertex[];
-};
-
-export type BubblGeofenceCircle = {
-  campaignId?: string | null;
-  campaignName?: string | null;
-  locationId?: string | null;
-  center: BubblGeofenceVertex;
-  radius: number;
-};
-
-export type BubblGeofenceSnapshot = {
-  stats: {
-    campaignsTotal: number;
-    polygonsTotal: number;
-  };
-  polygons: BubblGeofencePolygon[];
-  circles: BubblGeofenceCircle[];
-};
-
-export type BubblTrackEvent = {
-  type: string;
-  activity: string;
-  locationId?: string | null;
-  curatedNotificationId?: string | null;
-  latitude?: number | null;
-  longitude?: number | null;
-};
-
-export type BubblSurveyAnswer = {
-  questionId: string;
-  type: string;
-  value?: string | null;
-  choiceIds?: string[];
-};
-
-export type BubblSurveyResponse = {
-  curatedNotificationId: string;
-  locationId?: string | null;
-  answers: BubblSurveyAnswer[];
-};
-
-export type BubblNotificationPayload = {
-  id: string;
-  title: string;
-  body: string;
-  source?: BubblNotificationSource;
-  locationId?: string | null;
-  curatedNotificationId?: string | null;
-  correlationId?: string | null;
-  media?: BubblNotificationMedia | null;
-  cta?: BubblNotificationCta | null;
-  survey?: BubblNotificationSurvey | null;
-  raw?: Record<string, string>;
-};
-
-export type BubblNotificationMedia = {
-  url: string;
-  type?: string | null;
-  altText?: string | null;
-};
-
-export type BubblNotificationCta = {
-  label: string;
-  url?: string | null;
-  action?: string | null;
-};
-
-export type BubblNotificationSurvey = {
-  questions?: BubblSurveyQuestion[];
-};
-
-export type BubblSurveyQuestion = {
-  id: string;
-  title: string;
-  type: string;
-  choices?: BubblSurveyChoice[];
-};
-
-export type BubblSurveyChoice = {
-  id: string;
-  label: string;
-};
-
-export type BubblNotificationDisplayResult = {
-  displayed: boolean;
-  reason?: string | null;
-};
+/** Why there's no native module, as specifically as can be told from here. */
+function missingReason(): string {
+  const globals = globalThis as Globals;
+  if (Platform.OS === 'web') {
+    return `${PACKAGE}: Bubbl is for Android and iOS; on the web its calls do nothing.`;
+  }
+  if (globals.process?.env?.JEST_WORKER_ID != null) {
+    return `${PACKAGE}: there's no native module in Jest, so Bubbl's calls do nothing. Mock it: ${JEST_MOCK}.`;
+  }
+  if (globals.__turboModuleProxy == null && globals.RN$Bridgeless !== true) {
+    return (
+      `${PACKAGE}: Bubbl needs React Native's New Architecture, and this app runs the old one, so ` +
+      "Bubbl's calls do nothing. Turn it on (newArchEnabled=true in android/gradle.properties, " +
+      'RCT_NEW_ARCH_ENABLED=1 for pod install, or newArchEnabled in the Expo config) and rebuild.'
+    );
+  }
+  return (
+    `${PACKAGE}: the native module isn't in this build, so Bubbl's calls do nothing. Rebuild the app ` +
+    "after installing (npx expo prebuild, or pod install / a Gradle sync); Expo Go can't load it."
+  );
+}
+let reportedMissing = false;
+
+/**
+ * The native module, or null where there isn't one (web, Expo Go, Jest, a build from before the
+ * install), said once in the console. Bubbl never stops the app, so without it calls do nothing.
+ */
+function native(): Spec | null {
+  if (!NativeBubblSdk && !reportedMissing) {
+    reportedMissing = true;
+    (Platform.OS === 'web' ? console.warn : console.error)(missingReason());
+  }
+  return NativeBubblSdk ?? null;
+}
 
-export type BubblDiagnostics = {
-  sdkVersion: string;
-  platform: 'react-native';
-  booted: boolean;
-  pendingIngestCount: number;
-  pushTokenSuffix?: string | null;
-};
+const eventListeners = new Set<EventListener>();
+let notificationListener: NotificationListener | null = null;
+let nativeSubscription: { remove(): void } | null = null;
+
+/**
+ * Listens to the native event once anything wants it: events go to every event listener, and
+ * "notification.handle" (a notification the native side held back for the app's listener, only
+ * ever while the app is in the foreground) goes to the notification listener.
+ */
+function listenToNative(): void {
+  if (nativeSubscription || !NativeBubblSdk) {
+    return;
+  }
+  nativeSubscription = new NativeEventEmitter(NativeBubblSdk as never).addListener(
+    NATIVE_EVENT,
+    (json: unknown) => {
+      let payload: { type?: string; token?: string; message?: unknown; locationId?: string };
+      try {
+        payload = JSON.parse(String(json));
+      } catch {
+        return;
+      }
+      if (payload.type === 'notification.handle') {
+        void handleNotification(String(payload.token), payload.message as BubblMessage);
+        return;
+      }
+      const event = payload as BubblEvent;
+      eventListeners.forEach((listener) => {
+        try {
+          listener(event);
+        } catch (error) {
+          console.error('Bubbl: an event listener threw', error);
+        }
+      });
+    },
+  );
+}
 
-export type BubblEvent =
-  | { type: 'ready' }
-  | { type: 'diagnostic'; diagnostics: BubblDiagnostics }
-  | { type: 'notificationReceived'; payload: BubblNotificationPayload }
-  | { type: 'notificationDisplayed'; payload: BubblNotificationPayload }
-  | { type: 'notificationTapped'; payload: BubblNotificationPayload; action?: string | null }
-  | { type: 'notificationCtaTapped'; payload: BubblNotificationPayload; action?: string | null }
-  | { type: 'notificationMediaViewed'; payload: BubblNotificationPayload }
-  | { type: 'notificationSurveyRequested'; payload: BubblNotificationPayload }
-  | { type: 'locationUpdated'; location: BubblLocation }
-  | { type: 'geofenceSnapshot'; snapshot: BubblGeofenceSnapshot }
-  | { type: 'geofenceEntered'; transition: BubblGeofenceTransition }
-  | { type: 'geofenceExited'; transition: BubblGeofenceTransition }
-  | { type: 'error'; code: string; message: string };
-
-export type BubblEventSubscription = Pick<EmitterSubscription, 'remove'>;
-
-const EVENT_NAME = 'BubblSdkEvent';
-
-type NativeBubblSdkShape = NonNullable<typeof NativeBubblSdk>;
-
-function nativeModule(): NativeBubblSdkShape {
-  const module = NativeBubblSdk ?? NativeModules.BubblSdk;
-  if (!module) {
-    throw new Error('BubblSdk native module is not linked.');
+function stopListeningIfIdle(): void {
+  if (eventListeners.size === 0 && !notificationListener) {
+    nativeSubscription?.remove();
+    nativeSubscription = null;
   }
+}
 
-  return module as NativeBubblSdkShape;
+/**
+ * The app's listener decides; anything but true (false, a throw, no listener any more) is Bubbl's
+ * to show. Claimed first, so native knows JS has it; finished after, so native shows it unless the
+ * app does. If JS goes away in between (a reload), native shows it: it's never lost.
+ */
+async function handleNotification(token: string, message: BubblMessage): Promise<void> {
+  native()?.claimNotification(token);
+  let showsItself = false;
+  try {
+    showsItself = notificationListener ? (await notificationListener(message)) === true : false;
+  } catch (error) {
+    console.error('Bubbl: the notification listener threw; Bubbl shows the notification', error);
+  }
+  native()?.finishNotification(token, showsItself);
 }
 
-function eventEmitter(): NativeEventEmitter {
-  return new NativeEventEmitter(NativeModules.BubblSdk ?? (NativeBubblSdk as object | null));
+/** Diagnostics where there's no native module: nothing runs, and lastError says why. */
+function unavailableDiagnostics(): BubblDiagnostics {
+  return {
+    started: false,
+    sdkVersion: '',
+    supported: false,
+    sdkSupported: true,
+    registered: false,
+    installId: null,
+    active: false,
+    pausedUntil: null,
+    consentRequired: false,
+    consent: null,
+    locationEnabled: false,
+    permissions: null,
+    hasPushToken: false,
+    geofences: 0,
+    queuedEvents: 0,
+    lastError: missingReason(),
+    credentialRejected: false,
+    environment: null,
+    testDevice: null,
+    backgroundLocation: false,
+    transitionsDroppedWhileLocked: 0,
+    backgroundRestricted: null,
+    batteryOptimized: null,
+    backgroundRefreshAvailable: null,
+    lowPowerMode: null,
+    osWatchesGeofences: null,
+  };
 }
 
-function validateApiKey(config: BubblConfig): void {
-  if (!config.apiKey?.trim()) {
-    throw new Error('apiKey is required');
-  }
+function parse<T>(json: string | null): T | null {
+  return json == null ? null : (JSON.parse(json) as T);
 }
 
+/**
+ * Bubbl for a React Native app: the same functions as the native SDKs (docs/PUBLIC_API.md).
+ * Install the package, then call start once, early, e.g. at the top of index.js:
+ *
+ *     Bubbl.start('pk_live_…', { baseUrl: 'https://…' });
+ *
+ * Bubbl never stops the app: a mistake (an empty key, an http:// URL) is logged natively, not
+ * thrown, calls before start do nothing, and so do calls where there's no native module (web,
+ * Expo Go, Jest), said once in the console. Geofences and pushes keep working with the app
+ * closed: the native SDK starts itself from its saved settings when the OS wakes the app.
+ */
 export const Bubbl = {
-  async boot(config: BubblConfig): Promise<BubblBootResult> {
-    validateApiKey(config);
-    return nativeModule().boot(config) as Promise<BubblBootResult>;
+  /**
+   * Whether Bubbl works on this device: iOS 17 and later, Android 8.1 (API 27) and later. The
+   * package installs on older versions too, and there every call does nothing (permissions give
+   * null, the listener is never asked, diagnostics say supported: false). False where there's no
+   * native module.
+   */
+  get isSupported(): boolean {
+    return native()?.isSupported() ?? false;
   },
-  async shutdown(): Promise<void> {
-    return nativeModule().shutdown();
-  },
-  async startLocationTracking(): Promise<void> {
-    return nativeModule().startLocationTracking();
-  },
-  async stopLocationTracking(): Promise<void> {
-    return nativeModule().stopLocationTracking();
-  },
-  async refresh(): Promise<void> {
-    return nativeModule().refresh();
-  },
-  async refreshGeofence(location: BubblLocation): Promise<void> {
-    return nativeModule().refreshGeofence(location.latitude, location.longitude);
-  },
-  async handleLocationUpdate(location: BubblLocation): Promise<void> {
-    return nativeModule().handleLocationUpdate(location.latitude, location.longitude);
-  },
-  async refreshPush(): Promise<void> {
-    return nativeModule().refreshPush();
+
+  /** Start Bubbl. Calling again with the same key and options changes nothing. */
+  start(apiKey: string, options: BubblOptions): void {
+    native()?.start(apiKey, JSON.stringify(options));
   },
-  async getConfiguration(): Promise<Record<string, unknown> | null> {
-    return nativeModule().getConfiguration() as Promise<Record<string, unknown> | null>;
+
+  /**
+   * Start with a device credential issued outside the app (installs provisioned ahead of time, an
+   * app's own pairing flow) instead of an API key: the device never registers itself. As start
+   * otherwise, at every launch. A different credential than last time starts afresh as a new
+   * device; if the server refuses it, Bubbl stops ('credential.rejected', diagnostics) until it's
+   * started with a new one. An incomplete credential is logged natively (without the secret).
+   */
+  startWithCredential(credential: BubblCredential, options: BubblOptions): void {
+    // The secret goes to the native SDK and nowhere else: not into JSON, not into a log.
+    native()?.startWithCredential(
+      credential.keyId,
+      credential.secret,
+      credential.installId,
+      JSON.stringify(options),
+    );
   },
-  async getPrivacyText(): Promise<string> {
-    return nativeModule().getPrivacyText();
+
+  /** Stop on this device until start is called again; the server isn't told, nothing is dropped. */
+  stop(): void {
+    native()?.stop();
   },
-  async updateSegments(tags: string[]): Promise<void> {
-    return nativeModule().updateSegments(tags);
+
+  /** For requireConsent: true starts everything, false is optOut. */
+  setConsent(granted: boolean): void {
+    native()?.setConsent(granted);
   },
-  async setCorrelationId(value: string): Promise<void> {
-    return nativeModule().setCorrelationId(value);
+
+  /** Stop for this user; the server is told. */
+  optOut(): void {
+    native()?.optOut();
   },
-  async clearCorrelationId(): Promise<void> {
-    return nativeModule().clearCorrelationId();
+
+  /** Erase the device on the server and here; Bubbl stays off afterwards. */
+  deleteMyData(): void {
+    native()?.deleteMyData();
   },
-  async setDefaultNotificationModalEnabled(enabled: boolean): Promise<void> {
-    return nativeModule().setDefaultNotificationModalEnabled(enabled);
+
+  /** Location (geofences) off or on; the rest carries on. */
+  setLocationEnabled(enabled: boolean): void {
+    native()?.setLocationEnabled(enabled);
   },
-  async setDefaultNotificationModalStyle(style: BubblNotificationModalStyle | null): Promise<void> {
-    return nativeModule().setDefaultNotificationModalStyle(style);
+
+  /**
+   * The permissions Bubbl uses. Asking shows the privacy view first when the dashboard says so,
+   * then the system prompt.
+   */
+  permissions: {
+    /** Where the device stands; null before start. */
+    async status(): Promise<BubblPermissionStatus | null> {
+      return parse((await native()?.permissionStatus()) ?? null);
+    },
+    async requestNotifications(): Promise<BubblPermissionStatus | null> {
+      return parse((await native()?.requestNotifications()) ?? null);
+    },
+    /** While the app is in use, or always (geofences with the app closed): a second step. */
+    async requestLocation(options: { always?: boolean } = {}): Promise<BubblPermissionStatus | null> {
+      return parse((await native()?.requestLocation(options.always === true)) ?? null);
+    },
+    /** The app's page in system settings, for a permission refused for good. */
+    openSettings(): void {
+      native()?.openSettings();
+    },
   },
-  async resetDefaultNotificationModalStyle(): Promise<void> {
-    return nativeModule().setDefaultNotificationModalStyle(null);
+
+  /** The device's segments (replaces any set before). */
+  setSegments(segments: string[]): void {
+    native()?.setSegments(segments);
   },
-  async disableDefaultNotificationModal(): Promise<void> {
-    return nativeModule().setDefaultNotificationModalEnabled(false);
+
+  /**
+   * A custom event: a name of letters, digits and . _ : - (at most 100), with up to 50 flat
+   * properties (text, numbers, true/false, null).
+   */
+  track(name: string, properties: Record<string, string | number | boolean | null> = {}): void {
+    native()?.track(name, JSON.stringify(properties));
   },
-  async enableDefaultNotificationModal(): Promise<void> {
-    return nativeModule().setDefaultNotificationModalEnabled(true);
+
+  /** BubblEvents as they happen. */
+  addEventListener(listener: EventListener): Subscription {
+    eventListeners.add(listener);
+    listenToNative();
+    return {
+      remove: () => {
+        eventListeners.delete(listener);
+        stopListeningIfIdle();
+      },
+    };
   },
-  async registerPushToken(token: string): Promise<void> {
-    return nativeModule().registerPushToken(token);
+
+  /**
+   * The app's say before Bubbl shows a notification while the app is open: return true to show it
+   * yourself (then report what happens with the report functions), false to let Bubbl. With the
+   * app in the background it isn't asked: Bubbl posts its system notification, whose tap opens
+   * Bubbl's card. Null goes back to Bubbl showing everything.
+   */
+  setNotificationListener(listener: NotificationListener | null): void {
+    notificationListener = listener;
+    if (listener) {
+      listenToNative();
+    }
+    native()?.setNotificationListenerEnabled(listener != null);
+    stopListeningIfIdle();
   },
-  async handleFirebasePayload(payload: Record<string, string>): Promise<BubblNotificationPayload | null> {
-    return nativeModule().handleFirebasePayload(payload) as Promise<BubblNotificationPayload | null>;
+
+  /** Show a message in Bubbl's notification screen (e.g. one kept from before). */
+  present(message: BubblMessage): void {
+    native()?.present(message.json);
   },
-  async showNotification(payload: BubblNotificationPayload): Promise<BubblNotificationDisplayResult> {
-    return nativeModule().showNotification(payload) as Promise<BubblNotificationDisplayResult>;
+
+  /** For an app drawing notifications itself: it's on screen. */
+  reportDisplayed(message: BubblMessage): void {
+    native()?.reportDisplayed(message.json);
   },
-  async handleNotificationPayload(payload: BubblNotificationPayload): Promise<BubblNotificationDisplayResult> {
-    return nativeModule().handleNotificationPayload(payload) as Promise<BubblNotificationDisplayResult>;
+  /** …the user opened it. */
+  reportOpened(message: BubblMessage): void {
+    native()?.reportOpened(message.json);
   },
-  async handleNotificationOpen(payload: BubblNotificationPayload, action?: string | null): Promise<void> {
-    return nativeModule().handleNotificationOpen(payload, action);
+  /** …the user tapped its call to action. */
+  reportCtaClicked(message: BubblMessage): void {
+    native()?.reportCtaClicked(message.json);
   },
-  async openNotificationModal(payload: BubblNotificationPayload, action?: string | null): Promise<boolean> {
-    return nativeModule().openNotificationModal(payload, action);
+  /** …the user closed it without acting. */
+  reportDismissed(message: BubblMessage): void {
+    native()?.reportDismissed(message.json);
   },
-  async handleNotificationCta(payload: BubblNotificationPayload, action?: string | null): Promise<void> {
-    return nativeModule().handleNotificationCta(payload, action);
+  /** …its media was shown or started playing. */
+  reportMediaViewed(message: BubblMessage): void {
+    native()?.reportMediaViewed(message.json);
   },
-  async handleNotificationMediaViewed(payload: BubblNotificationPayload): Promise<void> {
-    return nativeModule().handleNotificationMediaViewed(payload);
+  /** …its video or audio played to the end, durationSeconds long. */
+  reportMediaCompleted(message: BubblMessage, durationSeconds: number): void {
+    native()?.reportMediaCompleted(message.json, durationSeconds);
   },
-  async handleNotificationSurveyRequested(payload: BubblNotificationPayload): Promise<void> {
-    return nativeModule().handleNotificationSurveyRequested(payload);
+  /** …the user started answering its survey. */
+  reportSurveyStarted(message: BubblMessage): void {
+    native()?.reportSurveyStarted(message.json);
   },
-  async track(event: BubblTrackEvent): Promise<void> {
-    return nativeModule().track(event);
+
+  /**
+   * Send the answers to a survey the app showed itself, checked as the server checks them: false
+   * (with the reason logged natively) when they can't be sent.
+   */
+  async submitSurvey(message: BubblMessage, answers: SurveyAnswers): Promise<boolean> {
+    return (await native()?.submitSurvey(message.json, JSON.stringify(answers))) ?? false;
   },
-  async submitSurveyResponse(response: BubblSurveyResponse): Promise<void> {
-    return nativeModule().submitSurveyResponse(response);
+
+  /** Open the message's call to action as Bubbl would, and report it. */
+  openCta(message: BubblMessage): void {
+    native()?.openCta(message.json);
   },
-  async flush(): Promise<{ pendingCount: number }> {
-    return nativeModule().flush() as Promise<{ pendingCount: number }>;
+
+  /** Whether a push's data is Bubbl's, so the app's own push handling can skip it. */
+  isBubblMessage(data: Record<string, unknown> | null | undefined): boolean {
+    return data?.bubbl === '1';
   },
+
+  /**
+   * Sandbox: approve this device as a test device with the code the dashboard shows, so it gets
+   * the Sandbox's notifications. Never throws: not approved comes with the reason as message
+   * (a wrong or expired code, no network, before start, an unsupported device).
+   */
+  async registerTestDevice(code: string): Promise<BubblTestDeviceResult> {
+    const module = native();
+    if (!module) {
+      return { approved: false, message: missingReason() };
+    }
+    const result = JSON.parse(await module.registerTestDevice(code)) as { approved: boolean; message?: string | null };
+    return result.message ? { approved: result.approved, message: result.message } : { approved: result.approved };
+  },
+
+  /**
+   * Where Bubbl stands on this device. Where there's no native module (see above) it still
+   * resolves, like every other call: not started, with the reason as lastError.
+   */
   async diagnostics(): Promise<BubblDiagnostics> {
-    return nativeModule().diagnostics() as Promise<BubblDiagnostics>;
-  },
-  events: {
-    addListener(listener: (event: BubblEvent) => void): BubblEventSubscription {
-      return eventEmitter().addListener(EVENT_NAME, listener);
-    },
+    const module = native();
+    if (!module) {
+      return unavailableDiagnostics();
+    }
+    const diagnostics = JSON.parse(await module.diagnostics()) as BubblDiagnostics & {
+      testDevice: { status: 'pending' | 'approved'; code?: string | null } | null;
+    };
+    // The code only while there is one (native sends null).
+    const device = diagnostics.testDevice;
+    diagnostics.testDevice = device && (device.code ? { status: device.status, code: device.code } : { status: device.status });
+    return diagnostics;
   },
 };