@npaw/forge-react-native 9.6.1

package/android/src/main/java/com/npaw/forge/reactnative/NPAWForgeModule.java

@@ -0,0 +1,735 @@
+/**
+ * Copyright (C) NPAW - All Rights Reserved
+ *
+ * This source code is protected under international copyright law. All rights
+ * reserved and protected by the copyright holders.
+ * This file is confidential and only available to authorized individuals with the
+ * permission of the copyright holders. If you encounter this file and do not have
+ * permission, please contact the copyright holders and delete this file.
+ *
+ *
+ * @author: Victor Soto <victor.soto@nicepeopleatwork.com>
+ * @description: Core Forge TurboModule for React Native Android - full facade surface over the Kotlin NPAWForge facade through its Java-facing API (sessions, identity, raw/business, network, diagnostics, video fire*, ad reporters, kernel event feed). Java on purpose: javac ignores Kotlin metadata, so the Kotlin-2.3-built Forge AAR imposes no Kotlin floor on host apps.
+ */
+
+package com.npaw.forge.reactnative;
+
+import android.app.Application;
+import android.content.Context;
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.npaw.forge.android.NPAWForge;
+import com.npaw.forge.android.core.ForgeEventSubscription;
+import com.npaw.forge.android.core.ForgeOutcome;
+import com.npaw.forge.android.core.ForgeRecordedEvent;
+import com.npaw.forge.android.video.ManualAdReporter;
+import com.npaw.forge.android.video.VideoAdapter;
+import com.npaw.forge.android.video.VideoOptions;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class NPAWForgeModule extends NativeNPAWForgeSpec {
+
+  public static final String NAME = "NPAWForgeRN";
+  public static final String FORGE_EVENT_CHANNEL = "NPAWForgeEvent";
+  private static final String E_UNKNOWN_INSTANCE = "E_FORGE_UNKNOWN_INSTANCE";
+  private static final String E_UNKNOWN_REPORTER = "E_FORGE_UNKNOWN_REPORTER";
+  private static final String E_BAD_ARGUMENT = "E_FORGE_BAD_ARGUMENT";
+
+  private interface ForgeCall {
+    ForgeOutcome apply(NPAWForge forge);
+  }
+
+  private interface VideoCall {
+    ForgeOutcome apply(VideoAdapter video);
+  }
+
+  private interface AdCall {
+    ForgeOutcome apply(ManualAdReporter reporter);
+  }
+
+  private final ConcurrentHashMap<String, ForgeEventSubscription> eventSubscriptions =
+      new ConcurrentHashMap<>();
+  private final ConcurrentHashMap<Integer, ManualAdReporter> adReporters = new ConcurrentHashMap<>();
+  private final AtomicInteger nextInstanceId = new AtomicInteger(1);
+  private final AtomicInteger nextReporterId = new AtomicInteger(1);
+  private final AtomicInteger listenerCount = new AtomicInteger(0);
+
+  public NPAWForgeModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public String getName() {
+    return NAME;
+  }
+
+  // ---- lifecycle ----
+
+  @Override
+  public void create(String accountCode, @Nullable ReadableMap config, Promise promise) {
+    try {
+      if (accountCode.trim().isEmpty()) {
+        promise.reject(E_BAD_ARGUMENT, "accountCode must not be blank");
+        return;
+      }
+      Context appContext = getReactApplicationContext().getApplicationContext();
+      NPAWForge.Builder builder =
+          appContext instanceof Application
+              ? new NPAWForge.Builder((Application) appContext, accountCode)
+              : new NPAWForge.Builder(accountCode);
+      ForgeDtoMapper.applyConfig(builder, config);
+      NPAWForge forge = builder.build();
+      String instanceId = "forge-" + nextInstanceId.getAndIncrement();
+      ForgeInstanceRegistry.register(instanceId, forge);
+      if (listenerCount.get() > 0) {
+        subscribeInstanceEvents(instanceId, forge);
+      }
+      promise.resolve(instanceId);
+    } catch (Throwable t) {
+      promise.reject(E_BAD_ARGUMENT, "Failed to create NPAWForge: " + t.getMessage(), t);
+    }
+  }
+
+  @Override
+  public void destroy(String instanceId, Promise promise) {
+    NPAWForge forge = ForgeInstanceRegistry.remove(instanceId);
+    if (forge == null) {
+      promise.reject(E_UNKNOWN_INSTANCE, "No NPAWForge instance '" + instanceId + "'");
+      return;
+    }
+    ForgeEventSubscription subscription = eventSubscriptions.remove(instanceId);
+    if (subscription != null) {
+      subscription.cancel();
+    }
+    promise.resolve(ForgeDtoMapper.outcomeToMap(forge.destroy()));
+  }
+
+  @Override
+  public void setLogLevel(String instanceId, String level, Promise promise) {
+    withForge(instanceId, promise, forge -> forge.setLogLevel(level));
+  }
+
+  // ---- app session ----
+
+  @Override
+  public void startSession(String instanceId, @Nullable ReadableMap metadata, Promise promise) {
+    withForge(instanceId, promise, forge -> forge.startSession(ForgeDtoMapper.toObjectMap(metadata)));
+  }
+
+  @Override
+  public void endSession(String instanceId, @Nullable ReadableMap metadata, Promise promise) {
+    withForge(instanceId, promise, forge -> forge.endSession(ForgeDtoMapper.toObjectMap(metadata)));
+  }
+
+  @Override
+  public void trackSessionNavigation(String instanceId, @Nullable ReadableMap metadata, Promise promise) {
+    withForge(
+        instanceId, promise, forge -> forge.trackSessionNavigation(ForgeDtoMapper.toObjectMap(metadata)));
+  }
+
+  @Override
+  public void trackSessionEvent(
+      String instanceId, String name, @Nullable ReadableMap metadata, Promise promise) {
+    withForge(
+        instanceId, promise, forge -> forge.trackSessionEvent(name, ForgeDtoMapper.toObjectMap(metadata)));
+  }
+
+  @Override
+  public void trackSessionEventStop(
+      String instanceId, String name, @Nullable ReadableMap metadata, Promise promise) {
+    withForge(
+        instanceId,
+        promise,
+        forge -> forge.trackSessionEventStop(name, ForgeDtoMapper.toObjectMap(metadata)));
+  }
+
+  @Override
+  public void trackSessionError(
+      String instanceId,
+      String errorCode,
+      String errorMessage,
+      @Nullable ReadableMap metadata,
+      Promise promise) {
+    withForge(
+        instanceId,
+        promise,
+        forge -> forge.trackSessionError(errorCode, errorMessage, ForgeDtoMapper.toObjectMap(metadata)));
+  }
+
+  // ---- identity ----
+
+  @Override
+  public void loginSuccess(String instanceId, String userId, @Nullable ReadableMap options, Promise promise) {
+    withForge(instanceId, promise, forge -> forge.loginSuccess(userId, ForgeDtoMapper.toObjectMap(options)));
+  }
+
+  @Override
+  public void loginFailed(String instanceId, @Nullable ReadableMap options, Promise promise) {
+    withForge(instanceId, promise, forge -> forge.loginFailed(ForgeDtoMapper.toObjectMap(options)));
+  }
+
+  @Override
+  public void logout(String instanceId, @Nullable ReadableMap options, Promise promise) {
+    withForge(instanceId, promise, forge -> forge.logout(ForgeDtoMapper.toObjectMap(options)));
+  }
+
+  @Override
+  public void profileCreated(
+      String instanceId, String profileId, @Nullable ReadableMap options, Promise promise) {
+    withForge(
+        instanceId, promise, forge -> forge.profileCreated(profileId, ForgeDtoMapper.toObjectMap(options)));
+  }
+
+  @Override
+  public void profileSelected(
+      String instanceId, String profileId, @Nullable ReadableMap options, Promise promise) {
+    withForge(
+        instanceId, promise, forge -> forge.profileSelected(profileId, ForgeDtoMapper.toObjectMap(options)));
+  }
+
+  @Override
+  public void profileDeleted(String instanceId, String profileId, Promise promise) {
+    withForge(instanceId, promise, forge -> forge.profileDeleted(profileId));
+  }
+
+  // ---- raw / business ----
+
+  @Override
+  public void trackRawEvent(String instanceId, String name, @Nullable ReadableMap params, Promise promise) {
+    withForge(instanceId, promise, forge -> forge.trackRawEvent(name, ForgeDtoMapper.toObjectMap(params)));
+  }
+
+  @Override
+  public void trackSearch(String instanceId, String query, double resultCount, Promise promise) {
+    withForge(
+        instanceId,
+        promise,
+        forge -> forge.trackSearch(query, resultCount < 0 ? null : (int) resultCount));
+  }
+
+  @Override
+  public void trackSearchResultClick(
+      String instanceId, String query, @Nullable ReadableMap options, Promise promise) {
+    withForge(
+        instanceId,
+        promise,
+        forge -> forge.trackSearchResultClick(query, ForgeDtoMapper.toObjectMap(options)));
+  }
+
+  @Override
+  public void trackBusinessEvent(
+      String instanceId, String name, @Nullable ReadableMap attributes, Promise promise) {
+    withForge(
+        instanceId,
+        promise,
+        forge -> forge.trackBusinessEvent(name, ForgeDtoMapper.toObjectMap(attributes)));
+  }
+
+  @Override
+  public void trackAttribution(String instanceId, @Nullable ReadableMap options, Promise promise) {
+    withForge(instanceId, promise, forge -> forge.trackAttribution(ForgeDtoMapper.toObjectMap(options)));
+  }
+
+  // ---- network ----
+
+  @Override
+  public void trackNetworkRequest(String instanceId, ReadableMap record, Promise promise) {
+    withForge(
+        instanceId,
+        promise,
+        forge -> forge.trackNetworkRequest(ForgeDtoMapper.toNetworkRequestRecord(record)));
+  }
+
+  @Override
+  public void installNetworkCapture(String instanceId, @Nullable ReadableMap options, Promise promise) {
+    NPAWForge forge = resolveOrReject(instanceId, promise);
+    if (forge == null) {
+      return;
+    }
+    try {
+      com.npaw.forge.android.networkcapture.ForgeNetworkCapture.INSTANCE.install(
+          forge, new com.npaw.forge.android.networkcapture.NetworkCaptureConfiguration(true));
+      // createClientBuilder(), not createClient(): the latter consults the
+      // installed factory and would recurse straight back into this lambda.
+      com.facebook.react.modules.network.OkHttpClientProvider.setOkHttpClientFactory(
+          () ->
+              com.npaw.forge.android.networkcapture.OkHttp3Instrumentation.INSTANCE
+                  .instrumentOkHttpClient(
+                      com.facebook.react.modules.network.OkHttpClientProvider.createClientBuilder()
+                          .build()));
+      promise.resolve(ForgeDtoMapper.outcomeToMap(ForgeOutcome.Accepted.INSTANCE));
+    } catch (Throwable t) {
+      promise.reject(E_BAD_ARGUMENT, "installNetworkCapture failed: " + t.getMessage(), t);
+    }
+  }
+
+  // ---- diagnostics ----
+
+  @Override
+  public void snapshotEvents(String instanceId, Promise promise) {
+    NPAWForge forge = resolveOrReject(instanceId, promise);
+    if (forge == null) {
+      return;
+    }
+    try {
+      promise.resolve(ForgeDtoMapper.snapshotToMap(instanceId, forge.snapshotEvents()));
+    } catch (Throwable t) {
+      promise.reject(E_BAD_ARGUMENT, "Forge call failed: " + t.getMessage(), t);
+    }
+  }
+
+  // ---- video ----
+
+  @Override
+  public void createVideo(
+      String instanceId, String identifier, @Nullable ReadableMap options, Promise promise) {
+    NPAWForge forge = resolveOrReject(instanceId, promise);
+    if (forge == null) {
+      return;
+    }
+    try {
+      VideoOptions videoOptions =
+          new VideoOptions.Builder().metadata(ForgeDtoMapper.toStringMap(options)).build();
+      forge.videoBuilder().setIdentifier(identifier).setOptions(videoOptions).build();
+      promise.resolve(ForgeDtoMapper.outcomeToMap(ForgeOutcome.Accepted.INSTANCE));
+    } catch (Throwable t) {
+      promise.reject(E_BAD_ARGUMENT, "createVideo failed: " + t.getMessage(), t);
+    }
+  }
+
+  @Override
+  public void videoDestroy(String instanceId, String identifier, Promise promise) {
+    withVideo(instanceId, identifier, promise, VideoAdapter::destroy);
+  }
+
+  @Override
+  public void videoFireInit(
+      String instanceId, String identifier, @Nullable ReadableMap params, Promise promise) {
+    withVideo(instanceId, identifier, promise, video -> video.fireInit(ForgeDtoMapper.toStringMap(params)));
+  }
+
+  @Override
+  public void videoFireStart(
+      String instanceId, String identifier, @Nullable ReadableMap params, boolean forceInit, Promise promise) {
+    withVideo(
+        instanceId,
+        identifier,
+        promise,
+        video -> video.fireStart(ForgeDtoMapper.toStringMap(params), forceInit ? Boolean.TRUE : null));
+  }
+
+  @Override
+  public void videoFireJoin(
+      String instanceId, String identifier, @Nullable ReadableMap params, Promise promise) {
+    withVideo(instanceId, identifier, promise, video -> video.fireJoin(ForgeDtoMapper.toStringMap(params)));
+  }
+
+  @Override
+  public void videoFirePause(
+      String instanceId, String identifier, @Nullable ReadableMap params, Promise promise) {
+    withVideo(instanceId, identifier, promise, video -> video.firePause(ForgeDtoMapper.toStringMap(params)));
+  }
+
+  @Override
+  public void videoFireResume(
+      String instanceId, String identifier, @Nullable ReadableMap params, Promise promise) {
+    withVideo(instanceId, identifier, promise, video -> video.fireResume(ForgeDtoMapper.toStringMap(params)));
+  }
+
+  @Override
+  public void videoFireSeekBegin(
+      String instanceId,
+      String identifier,
+      @Nullable ReadableMap params,
+      boolean convertFromBuffer,
+      Promise promise) {
+    withVideo(
+        instanceId,
+        identifier,
+        promise,
+        video ->
+            video.fireSeekBegin(
+                ForgeDtoMapper.toStringMap(params), convertFromBuffer ? Boolean.TRUE : null, 0L));
+  }
+
+  @Override
+  public void videoFireSeekEnd(
+      String instanceId, String identifier, @Nullable ReadableMap params, Promise promise) {
+    withVideo(instanceId, identifier, promise, video -> video.fireSeekEnd(ForgeDtoMapper.toStringMap(params)));
+  }
+
+  @Override
+  public void videoFireBufferBegin(
+      String instanceId,
+      String identifier,
+      @Nullable ReadableMap params,
+      boolean convertFromSeek,
+      Promise promise) {
+    withVideo(
+        instanceId,
+        identifier,
+        promise,
+        video ->
+            video.fireBufferBegin(
+                ForgeDtoMapper.toStringMap(params), convertFromSeek ? Boolean.TRUE : null, 0L));
+  }
+
+  @Override
+  public void videoFireBufferEnd(
+      String instanceId, String identifier, @Nullable ReadableMap params, Promise promise) {
+    withVideo(
+        instanceId, identifier, promise, video -> video.fireBufferEnd(ForgeDtoMapper.toStringMap(params)));
+  }
+
+  @Override
+  public void videoFireStop(
+      String instanceId, String identifier, @Nullable ReadableMap params, Promise promise) {
+    withVideo(instanceId, identifier, promise, video -> video.fireStop(ForgeDtoMapper.toStringMap(params)));
+  }
+
+  @Override
+  public void videoFireError(
+      String instanceId,
+      String identifier,
+      String errorCode,
+      String errorMessage,
+      String errorMetadata,
+      Promise promise) {
+    withVideo(
+        instanceId,
+        identifier,
+        promise,
+        video ->
+            video.fireError(
+                ForgeDtoMapper.emptyToNull(errorCode),
+                ForgeDtoMapper.emptyToNull(errorMessage),
+                ForgeDtoMapper.emptyToNull(errorMetadata),
+                0L));
+  }
+
+  @Override
+  public void videoFireFatalError(
+      String instanceId,
+      String identifier,
+      String errorCode,
+      String errorMessage,
+      String errorMetadata,
+      Promise promise) {
+    withVideo(
+        instanceId,
+        identifier,
+        promise,
+        video ->
+            video.fireFatalError(
+                ForgeDtoMapper.emptyToNull(errorCode),
+                ForgeDtoMapper.emptyToNull(errorMessage),
+                ForgeDtoMapper.emptyToNull(errorMetadata),
+                0L));
+  }
+
+  @Override
+  public void videoFireDestroy(String instanceId, String identifier, Promise promise) {
+    withVideo(instanceId, identifier, promise, video -> video.fireDestroy(0L));
+  }
+
+  @Override
+  public void videoFireEvent(
+      String instanceId,
+      String identifier,
+      String eventName,
+      @Nullable ReadableMap dimensions,
+      @Nullable ReadableMap values,
+      @Nullable ReadableMap topLevelDimensions,
+      boolean hasEndDatetime,
+      Promise promise) {
+    withVideo(
+        instanceId,
+        identifier,
+        promise,
+        video ->
+            video.fireEvent(
+                eventName,
+                ForgeDtoMapper.toStringMap(dimensions),
+                ForgeDtoMapper.toDoubleMap(values),
+                ForgeDtoMapper.toStringMap(topLevelDimensions),
+                hasEndDatetime,
+                0L));
+  }
+
+  @Override
+  public void videoFireEventEnd(
+      String instanceId,
+      String identifier,
+      String eventName,
+      @Nullable ReadableMap dimensions,
+      @Nullable ReadableMap values,
+      @Nullable ReadableMap topLevelDimensions,
+      Promise promise) {
+    withVideo(
+        instanceId,
+        identifier,
+        promise,
+        video ->
+            video.fireEventEnd(
+                eventName,
+                ForgeDtoMapper.toStringMap(dimensions),
+                ForgeDtoMapper.toDoubleMap(values),
+                ForgeDtoMapper.toStringMap(topLevelDimensions),
+                0L));
+  }
+
+  @Override
+  public void videoFireMetadataUpdate(String instanceId, String identifier, Promise promise) {
+    withVideo(instanceId, identifier, promise, VideoAdapter::fireMetadataUpdate);
+  }
+
+  // ---- ads ----
+
+  @Override
+  public void createAdReporter(String instanceId, String identifier, String adapterVersion, Promise promise) {
+    if (resolveOrReject(instanceId, promise) == null) {
+      return;
+    }
+    VideoAdapter video = ForgeInstanceRegistry.resolveVideoAdapter(instanceId, identifier);
+    if (video == null) {
+      promise.reject(E_BAD_ARGUMENT, "No video '" + identifier + "' on instance '" + instanceId + "'");
+      return;
+    }
+    try {
+      ManualAdReporter reporter = video.createAdReporter(ForgeDtoMapper.emptyToNull(adapterVersion));
+      int reporterId = nextReporterId.getAndIncrement();
+      adReporters.put(reporterId, reporter);
+      promise.resolve(reporterId);
+    } catch (Throwable t) {
+      promise.reject(E_BAD_ARGUMENT, "createAdReporter failed: " + t.getMessage(), t);
+    }
+  }
+
+  @Override
+  public void releaseAdReporter(double reporterId, Promise promise) {
+    ManualAdReporter reporter = adReporters.remove((int) reporterId);
+    if (reporter == null) {
+      promise.reject(E_UNKNOWN_REPORTER, "No ad reporter " + (int) reporterId);
+      return;
+    }
+    promise.resolve(ForgeDtoMapper.outcomeToMap(ForgeOutcome.Accepted.INSTANCE));
+  }
+
+  @Override
+  public void adFireManifest(double reporterId, @Nullable ReadableMap params, Promise promise) {
+    withReporter(reporterId, promise, reporter -> reporter.fireManifest(ForgeDtoMapper.toStringMap(params)));
+  }
+
+  @Override
+  public void adFireBreakStart(double reporterId, @Nullable ReadableMap params, Promise promise) {
+    withReporter(
+        reporterId, promise, reporter -> reporter.fireBreakStart(ForgeDtoMapper.toStringMap(params)));
+  }
+
+  @Override
+  public void adFireAdInit(double reporterId, @Nullable ReadableMap params, Promise promise) {
+    withReporter(reporterId, promise, reporter -> reporter.fireAdInit(ForgeDtoMapper.toStringMap(params)));
+  }
+
+  @Override
+  public void adFireStart(double reporterId, @Nullable ReadableMap params, Promise promise) {
+    withReporter(reporterId, promise, reporter -> reporter.fireStart(ForgeDtoMapper.toStringMap(params)));
+  }
+
+  @Override
+  public void adFireJoin(double reporterId, @Nullable ReadableMap params, Promise promise) {
+    withReporter(reporterId, promise, reporter -> reporter.fireJoin(ForgeDtoMapper.toStringMap(params)));
+  }
+
+  @Override
+  public void adFirePause(double reporterId, @Nullable ReadableMap params, Promise promise) {
+    withReporter(reporterId, promise, reporter -> reporter.firePause(ForgeDtoMapper.toStringMap(params)));
+  }
+
+  @Override
+  public void adFireResume(double reporterId, @Nullable ReadableMap params, Promise promise) {
+    withReporter(reporterId, promise, reporter -> reporter.fireResume(ForgeDtoMapper.toStringMap(params)));
+  }
+
+  @Override
+  public void adFireBufferBegin(double reporterId, @Nullable ReadableMap params, Promise promise) {
+    withReporter(
+        reporterId, promise, reporter -> reporter.fireBufferBegin(ForgeDtoMapper.toStringMap(params)));
+  }
+
+  @Override
+  public void adFireBufferEnd(double reporterId, @Nullable ReadableMap params, Promise promise) {
+    withReporter(
+        reporterId, promise, reporter -> reporter.fireBufferEnd(ForgeDtoMapper.toStringMap(params)));
+  }
+
+  @Override
+  public void adFireQuartile(double reporterId, double quartile, Promise promise) {
+    withReporter(
+        reporterId, promise, reporter -> reporter.fireQuartile(quartile < 0 ? null : (int) quartile, 0L));
+  }
+
+  @Override
+  public void adFireClick(double reporterId, @Nullable ReadableMap params, Promise promise) {
+    withReporter(reporterId, promise, reporter -> reporter.fireClick(ForgeDtoMapper.toStringMap(params)));
+  }
+
+  @Override
+  public void adFireSkip(double reporterId, Promise promise) {
+    withReporter(reporterId, promise, reporter -> reporter.fireSkip(0L));
+  }
+
+  @Override
+  public void adFireStop(double reporterId, @Nullable ReadableMap params, Promise promise) {
+    withReporter(reporterId, promise, reporter -> reporter.fireStop(ForgeDtoMapper.toStringMap(params)));
+  }
+
+  @Override
+  public void adFireError(
+      double reporterId, String errorCode, String errorMessage, String errorMetadata, Promise promise) {
+    withReporter(
+        reporterId,
+        promise,
+        reporter ->
+            reporter.fireError(
+                ForgeDtoMapper.emptyToNull(errorCode),
+                ForgeDtoMapper.emptyToNull(errorMessage),
+                ForgeDtoMapper.emptyToNull(errorMetadata),
+                0L));
+  }
+
+  @Override
+  public void adFireFatalError(
+      double reporterId, String errorCode, String errorMessage, String errorMetadata, Promise promise) {
+    withReporter(
+        reporterId,
+        promise,
+        reporter ->
+            reporter.fireFatalError(
+                ForgeDtoMapper.emptyToNull(errorCode),
+                ForgeDtoMapper.emptyToNull(errorMessage),
+                ForgeDtoMapper.emptyToNull(errorMetadata),
+                0L));
+  }
+
+  @Override
+  public void adFireBreakStop(double reporterId, @Nullable ReadableMap params, Promise promise) {
+    withReporter(
+        reporterId, promise, reporter -> reporter.fireBreakStop(ForgeDtoMapper.toStringMap(params)));
+  }
+
+  @Override
+  public void adFireDestroy(double reporterId, Promise promise) {
+    withReporter(reporterId, promise, reporter -> reporter.fireDestroy(0L));
+  }
+
+  // ---- event feed ----
+
+  @Override
+  public void addListener(String eventName) {
+    if (listenerCount.getAndIncrement() == 0) {
+      for (Map.Entry<String, NPAWForge> entry : ForgeInstanceRegistry.snapshot().entrySet()) {
+        subscribeInstanceEvents(entry.getKey(), entry.getValue());
+      }
+    }
+  }
+
+  @Override
+  public void removeListeners(double count) {
+    if (listenerCount.addAndGet(-(int) count) <= 0) {
+      listenerCount.set(0);
+      cancelAllSubscriptions();
+    }
+  }
+
+  @Override
+  public void invalidate() {
+    cancelAllSubscriptions();
+    adReporters.clear();
+    for (NPAWForge forge : ForgeInstanceRegistry.clear()) {
+      forge.destroy();
+    }
+    super.invalidate();
+  }
+
+  // ---- internals ----
+
+  private void cancelAllSubscriptions() {
+    for (ForgeEventSubscription subscription : eventSubscriptions.values()) {
+      subscription.cancel();
+    }
+    eventSubscriptions.clear();
+  }
+
+  private void subscribeInstanceEvents(final String instanceId, NPAWForge forge) {
+    eventSubscriptions.computeIfAbsent(
+        instanceId, key -> forge.subscribeEvents((event, outcome) -> emitForgeEvent(instanceId, event)));
+  }
+
+  private void emitForgeEvent(String instanceId, ForgeRecordedEvent event) {
+    ReactApplicationContext context = getReactApplicationContext();
+    if (!context.hasActiveReactInstance()) {
+      return;
+    }
+    context
+        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+        .emit(FORGE_EVENT_CHANNEL, ForgeDtoMapper.recordedEventToMap(instanceId, event));
+  }
+
+  @Nullable
+  private NPAWForge resolveOrReject(String instanceId, Promise promise) {
+    NPAWForge forge = ForgeInstanceRegistry.resolve(instanceId);
+    if (forge == null) {
+      promise.reject(E_UNKNOWN_INSTANCE, "No NPAWForge instance '" + instanceId + "'");
+    }
+    return forge;
+  }
+
+  private void withForge(String instanceId, Promise promise, ForgeCall call) {
+    NPAWForge forge = resolveOrReject(instanceId, promise);
+    if (forge == null) {
+      return;
+    }
+    try {
+      promise.resolve(ForgeDtoMapper.outcomeToMap(call.apply(forge)));
+    } catch (Throwable t) {
+      promise.reject(E_BAD_ARGUMENT, "Forge call failed: " + t.getMessage(), t);
+    }
+  }
+
+  private void withVideo(String instanceId, String identifier, Promise promise, VideoCall call) {
+    if (resolveOrReject(instanceId, promise) == null) {
+      return;
+    }
+    VideoAdapter video = ForgeInstanceRegistry.resolveVideoAdapter(instanceId, identifier);
+    if (video == null) {
+      // The video may have been legitimately destroyed; report facade state
+      // semantics instead of a programmer error.
+      promise.resolve(ForgeDtoMapper.outcomeToMap(ForgeOutcome.IgnoredInvalidState.INSTANCE));
+      return;
+    }
+    try {
+      promise.resolve(ForgeDtoMapper.outcomeToMap(call.apply(video)));
+    } catch (Throwable t) {
+      promise.reject(E_BAD_ARGUMENT, "Forge video call failed: " + t.getMessage(), t);
+    }
+  }
+
+  private void withReporter(double reporterId, Promise promise, AdCall call) {
+    ManualAdReporter reporter = adReporters.get((int) reporterId);
+    if (reporter == null) {
+      promise.reject(E_UNKNOWN_REPORTER, "No ad reporter " + (int) reporterId);
+      return;
+    }
+    try {
+      promise.resolve(ForgeDtoMapper.outcomeToMap(call.apply(reporter)));
+    } catch (Throwable t) {
+      promise.reject(E_BAD_ARGUMENT, "Forge ad call failed: " + t.getMessage(), t);
+    }
+  }
+}