@react-native-firebase/app-check 23.8.0 → 23.8.1

package/RNFBAppCheck.podspec

@@ -0,0 +1,50 @@
+require 'json'
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+appPackage = JSON.parse(File.read(File.join('..', 'app', 'package.json')))
+
+coreVersionDetected = appPackage['version']
+coreVersionRequired = package['peerDependencies'][appPackage['name']]
+firebase_sdk_version = appPackage['sdkVersions']['ios']['firebase']
+if coreVersionDetected != coreVersionRequired
+  Pod::UI.warn "NPM package '#{package['name']}' depends on '#{appPackage['name']}' v#{coreVersionRequired} but found v#{coreVersionDetected}, this might cause build issues or runtime crashes."
+end
+firebase_ios_target = appPackage['sdkVersions']['ios']['iosTarget']
+firebase_macos_target = appPackage['sdkVersions']['ios']['macosTarget']
+firebase_tvos_target = appPackage['sdkVersions']['ios']['tvosTarget']
+
+Pod::Spec.new do |s|
+  s.name                = "RNFBAppCheck"
+  s.version             = package["version"]
+  s.description         = package["description"]
+  s.summary             = <<-DESC
+                            A well tested feature rich Firebase implementation for React Native, supporting iOS & Android.
+                          DESC
+  s.homepage            = "http://invertase.io/oss/react-native-firebase"
+  s.license             = package['license']
+  s.authors             = "Invertase Limited"
+  s.source              = { :git => "https://github.com/invertase/react-native-firebase.git", :tag => "v#{s.version}" }
+  s.social_media_url    = 'http://twitter.com/invertaseio'
+  s.ios.deployment_target = firebase_ios_target
+  s.macos.deployment_target = firebase_macos_target
+  s.tvos.deployment_target = firebase_tvos_target
+  s.source_files        = 'ios/**/*.{h,m}'
+
+  # React Native dependencies
+  s.dependency          'React-Core'
+  s.dependency          'RNFBApp'
+
+  if defined?($FirebaseSDKVersion)
+    Pod::UI.puts "#{s.name}: Using user specified Firebase SDK version '#{$FirebaseSDKVersion}'"
+    firebase_sdk_version = $FirebaseSDKVersion
+  end
+
+  # Firebase dependencies
+  s.dependency          'Firebase/AppCheck', firebase_sdk_version
+
+  if defined?($RNFirebaseAsStaticFramework)
+    Pod::UI.puts "#{s.name}: Using overridden static_framework value of '#{$RNFirebaseAsStaticFramework}'"
+    s.static_framework = $RNFirebaseAsStaticFramework
+  else
+    s.static_framework = false
+  end
+end

package/android/.editorconfig

@@ -0,0 +1,10 @@
+# editorconfig
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

package/android/build.gradle

@@ -0,0 +1,110 @@
+import com.android.Version
+import io.invertase.gradle.common.PackageJson
+
+buildscript {
+  // The Android Gradle plugin is only required when opening the android folder stand-alone.
+  // This avoids unnecessary downloads and potential conflicts when the library is included as a
+  // module dependency in an application project.
+  if (project == rootProject) {
+    repositories {
+      google()
+      mavenCentral()
+    }
+
+    dependencies {
+      classpath("com.android.tools.build:gradle:8.4.0")
+    }
+  }
+}
+
+plugins {
+  id 'io.invertase.gradle.build' version '1.5'
+}
+
+def appProject
+if (findProject(':@react-native-firebase_app')) {
+  appProject = project(':@react-native-firebase_app')
+} else if (findProject(':react-native-firebase_app')) {
+  appProject = project(':react-native-firebase_app')
+} else {
+  throw new GradleException('Could not find the react-native-firebase/app package, have you installed it?')
+}
+def packageJson = PackageJson.getForProject(project)
+def appPackageJson = PackageJson.getForProject(appProject)
+def firebaseBomVersion = appPackageJson['sdkVersions']['android']['firebase']
+def jsonMinSdk = appPackageJson['sdkVersions']['android']['minSdk']
+def jsonTargetSdk = appPackageJson['sdkVersions']['android']['targetSdk']
+def jsonCompileSdk = appPackageJson['sdkVersions']['android']['compileSdk']
+def coreVersionDetected = appPackageJson['version']
+def coreVersionRequired = packageJson['peerDependencies'][appPackageJson['name']]
+if (coreVersionDetected != coreVersionRequired) {
+  project.logger.warn("ReactNativeFirebase WARNING: NPM package '${packageJson['name']}' depends on '${appPackageJson['name']}' v${coreVersionRequired} but found v${coreVersionDetected}, this might cause build issues or runtime crashes.")
+}
+
+project.ext {
+  set('react-native', [
+    versions: [
+      android : [
+        minSdk    : jsonMinSdk,
+        targetSdk : jsonTargetSdk,
+        compileSdk: jsonCompileSdk,
+      ],
+
+      firebase: [
+        bom: firebaseBomVersion,
+      ],
+    ],
+  ])
+}
+
+android {
+  def agpVersion = Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')[0].toInteger()
+  if (agpVersion >= 7) {
+    namespace = 'io.invertase.firebase.appcheck'
+  }
+
+  defaultConfig {
+    multiDexEnabled = true
+    // Here we add a build config field to allow devs to provide a
+    // FIREBASE_APP_CHECK_DEBUG_TOKEN to be used in debug mode.
+    buildConfigField "String", "FIREBASE_APP_CHECK_DEBUG_TOKEN", "\"${System.env.FIREBASE_APP_CHECK_DEBUG_TOKEN}\""
+  }
+
+  buildFeatures {
+    // AGP 8 no longer builds config by default
+    buildConfig = true
+  }
+
+  lintOptions {
+    disable 'GradleCompatible'
+    abortOnError = false
+  }
+  if (agpVersion < 8) {
+    compileOptions {
+      sourceCompatibility = JavaVersion.VERSION_11
+      targetCompatibility = JavaVersion.VERSION_11
+    }
+  }
+  sourceSets {
+    main {
+      java.srcDirs = ['src/main/java', 'src/reactnative/java']
+    }
+  }
+}
+
+repositories {
+  google()
+  mavenCentral()
+}
+
+dependencies {
+  api appProject
+  implementation platform("com.google.firebase:firebase-bom:${ReactNative.ext.getVersion('firebase', 'bom')}")
+  implementation 'com.google.firebase:firebase-appcheck-playintegrity'
+  implementation "com.google.firebase:firebase-appcheck-debug"
+}
+
+ReactNative.shared.applyPackageVersion()
+ReactNative.shared.applyDefaultExcludes()
+ReactNative.module.applyAndroidVersions()
+ReactNative.module.applyReactNativeDependency('api')

package/android/lint.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<lint>
+  <!-- Disable the given check in this project -->
+  <issue id="GradleCompatible" severity="ignore" />
+</lint>

package/android/settings.gradle

@@ -0,0 +1 @@
+rootProject.name = '@react-native-firebase_app-check'

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="io.invertase.firebase.appcheck">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+</manifest>

package/android/src/main/java/io/invertase/firebase/appcheck/ReactNativeFirebaseAppCheckModule.java

@@ -0,0 +1,281 @@
+package io.invertase.firebase.appcheck;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.util.Log;
+import com.facebook.react.bridge.*;
+import com.google.android.gms.tasks.Tasks;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.appcheck.FirebaseAppCheck;
+import io.invertase.firebase.common.ReactNativeFirebaseEvent;
+import io.invertase.firebase.common.ReactNativeFirebaseEventEmitter;
+import io.invertase.firebase.common.ReactNativeFirebaseJSON;
+import io.invertase.firebase.common.ReactNativeFirebaseMeta;
+import io.invertase.firebase.common.ReactNativeFirebaseModule;
+import io.invertase.firebase.common.ReactNativeFirebasePreferences;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+public class ReactNativeFirebaseAppCheckModule extends ReactNativeFirebaseModule {
+  private static final String TAG = "AppCheck";
+  private static final String LOGTAG = "RNFBAppCheck";
+  private static final String KEY_APPCHECK_TOKEN_REFRESH_ENABLED = "app_check_token_auto_refresh";
+
+  private static HashMap<String, FirebaseAppCheck.AppCheckListener> mAppCheckListeners =
+      new HashMap<>();
+
+  ReactNativeFirebaseAppCheckProviderFactory providerFactory =
+      new ReactNativeFirebaseAppCheckProviderFactory();
+
+  static boolean isAppCheckTokenRefreshEnabled() {
+    boolean enabled;
+    ReactNativeFirebaseJSON json = ReactNativeFirebaseJSON.getSharedInstance();
+    ReactNativeFirebaseMeta meta = ReactNativeFirebaseMeta.getSharedInstance();
+    ReactNativeFirebasePreferences prefs = ReactNativeFirebasePreferences.getSharedInstance();
+
+    if (prefs.contains(KEY_APPCHECK_TOKEN_REFRESH_ENABLED)) {
+      enabled = prefs.getBooleanValue(KEY_APPCHECK_TOKEN_REFRESH_ENABLED, true);
+      Log.d(LOGTAG, "isAppCheckCollectionEnabled via RNFBPreferences: " + enabled);
+    } else if (json.contains(KEY_APPCHECK_TOKEN_REFRESH_ENABLED)) {
+      enabled = json.getBooleanValue(KEY_APPCHECK_TOKEN_REFRESH_ENABLED, true);
+      Log.d(LOGTAG, "isAppCheckCollectionEnabled via RNFBJSON: " + enabled);
+    } else {
+      enabled = meta.getBooleanValue(KEY_APPCHECK_TOKEN_REFRESH_ENABLED, true);
+      Log.d(LOGTAG, "isAppCheckCollectionEnabled via RNFBMeta: " + enabled);
+    }
+
+    if (BuildConfig.DEBUG) {
+      if (!json.getBooleanValue(KEY_APPCHECK_TOKEN_REFRESH_ENABLED, false)) {
+        enabled = false;
+      }
+      Log.d(
+          LOGTAG,
+          "isAppCheckTokenRefreshEnabled after checking "
+              + KEY_APPCHECK_TOKEN_REFRESH_ENABLED
+              + ": "
+              + enabled);
+    }
+
+    Log.d(LOGTAG, "isAppCheckTokenRefreshEnabled final value: " + enabled);
+    return enabled;
+  }
+
+  private boolean isAppDebuggable() throws Exception {
+    boolean isDebuggable = false;
+    PackageManager pm = getContext().getPackageManager();
+    if (pm != null) {
+      isDebuggable =
+          (0
+              != (pm.getApplicationInfo(getContext().getPackageName(), 0).flags
+                  & ApplicationInfo.FLAG_DEBUGGABLE));
+    }
+    Log.d(LOGTAG, "debuggable status? " + isDebuggable);
+    return isDebuggable;
+  }
+
+  ReactNativeFirebaseAppCheckModule(ReactApplicationContext reactContext) {
+    super(reactContext, TAG);
+
+    // Our default token refresh config comes from config files, set it
+    FirebaseAppCheck firebaseAppCheck = FirebaseAppCheck.getInstance();
+    firebaseAppCheck.setTokenAutoRefreshEnabled(isAppCheckTokenRefreshEnabled());
+  }
+
+  @Override
+  public void invalidate() {
+    super.invalidate();
+    Log.d(TAG, "instance-destroyed");
+
+    Iterator appCheckListenerIterator = mAppCheckListeners.entrySet().iterator();
+
+    while (appCheckListenerIterator.hasNext()) {
+      Map.Entry pair = (Map.Entry) appCheckListenerIterator.next();
+      String appName = (String) pair.getKey();
+      FirebaseApp firebaseApp = FirebaseApp.getInstance(appName);
+      FirebaseAppCheck firebaseAppCheck = FirebaseAppCheck.getInstance(firebaseApp);
+      FirebaseAppCheck.AppCheckListener mAppCheckListener =
+          (FirebaseAppCheck.AppCheckListener) pair.getValue();
+      firebaseAppCheck.removeAppCheckListener(mAppCheckListener);
+      appCheckListenerIterator.remove();
+    }
+  }
+
+  @ReactMethod
+  public void configureProvider(
+      String appName, String providerName, String debugToken, Promise promise) {
+    Log.d(
+        LOGTAG,
+        "configureProvider - appName/providerName/debugToken: "
+            + appName
+            + "/"
+            + providerName
+            + (debugToken != null ? "/(not shown)" : "/null"));
+    try {
+      providerFactory.configure(appName, providerName, debugToken);
+      FirebaseAppCheck.getInstance(FirebaseApp.getInstance(appName))
+          .installAppCheckProviderFactory(providerFactory);
+      promise.resolve(null);
+    } catch (Exception e) {
+      rejectPromiseWithCodeAndMessage(promise, "unknown", "internal-error", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void activate(
+      String appName, String siteKeyProvider, boolean isTokenAutoRefreshEnabled, Promise promise) {
+    try {
+
+      FirebaseAppCheck firebaseAppCheck =
+          FirebaseAppCheck.getInstance(FirebaseApp.getInstance(appName));
+      firebaseAppCheck.setTokenAutoRefreshEnabled(isTokenAutoRefreshEnabled);
+
+      // Configure our new proxy factory in a backwards-compatible way for old API
+      if (isAppDebuggable()) {
+        Log.d(LOGTAG, "app is debuggable, configuring AppCheck for testing mode");
+        if (BuildConfig.FIREBASE_APP_CHECK_DEBUG_TOKEN != "null") {
+          Log.d(LOGTAG, "debug app check token found in BuildConfig. Installing known token.");
+          providerFactory.configure(appName, "debug", BuildConfig.FIREBASE_APP_CHECK_DEBUG_TOKEN);
+        } else {
+          Log.d(
+              LOGTAG,
+              "no debug app check token found in BuildConfig. Check Log for dynamic test token to"
+                  + " configure in console.");
+          providerFactory.configure(appName, "debug", null);
+        }
+      } else {
+        providerFactory.configure(appName, "safetyNet", null);
+      }
+
+      FirebaseAppCheck.getInstance(FirebaseApp.getInstance(appName))
+          .installAppCheckProviderFactory(providerFactory);
+      promise.resolve(null);
+    } catch (Exception e) {
+      rejectPromiseWithCodeAndMessage(promise, "unknown", "internal-error", e.getMessage());
+    }
+  }
+
+  @ReactMethod
+  public void setTokenAutoRefreshEnabled(String appName, boolean isTokenAutoRefreshEnabled) {
+    FirebaseApp firebaseApp = FirebaseApp.getInstance(appName);
+    FirebaseAppCheck.getInstance(firebaseApp).setTokenAutoRefreshEnabled(isTokenAutoRefreshEnabled);
+  }
+
+  @ReactMethod
+  public void getToken(String appName, boolean forceRefresh, Promise promise) {
+    Log.d(LOGTAG, "getToken appName/forceRefresh: " + appName + "/" + forceRefresh);
+    FirebaseApp firebaseApp = FirebaseApp.getInstance(appName);
+    Tasks.call(
+            getExecutor(),
+            () -> {
+              return Tasks.await(
+                  FirebaseAppCheck.getInstance(firebaseApp).getAppCheckToken(forceRefresh));
+            })
+        .addOnCompleteListener(
+            getExecutor(),
+            (task) -> {
+              if (task.isSuccessful()) {
+                WritableMap tokenResultMap = Arguments.createMap();
+                tokenResultMap.putString("token", task.getResult().getToken());
+                promise.resolve(tokenResultMap);
+              } else {
+                Log.e(
+                    LOGTAG,
+                    "RNFB: Unknown error while fetching AppCheck token "
+                        + task.getException().getMessage());
+                rejectPromiseWithCodeAndMessage(
+                    promise, "token-error", task.getException().getMessage());
+              }
+            });
+  }
+
+  @ReactMethod
+  public void getLimitedUseToken(String appName, Promise promise) {
+    Log.d(LOGTAG, "getLimitedUseToken appName: " + appName);
+    FirebaseApp firebaseApp = FirebaseApp.getInstance(appName);
+
+    Tasks.call(
+            getExecutor(),
+            () -> {
+              return Tasks.await(
+                  FirebaseAppCheck.getInstance(firebaseApp).getLimitedUseAppCheckToken());
+            })
+        .addOnCompleteListener(
+            getExecutor(),
+            (task) -> {
+              if (task.isSuccessful()) {
+                WritableMap tokenResultMap = Arguments.createMap();
+                tokenResultMap.putString("token", task.getResult().getToken());
+                promise.resolve(tokenResultMap);
+              } else {
+                Log.e(
+                    LOGTAG,
+                    "Unknown error while fetching limited-use AppCheck token "
+                        + task.getException().getMessage());
+                rejectPromiseWithCodeAndMessage(
+                    promise, "token-error", task.getException().getMessage());
+              }
+            });
+  }
+
+  /** Add a new token change listener - if one doesn't exist already */
+  @ReactMethod
+  public void addAppCheckListener(final String appName) {
+    Log.d(TAG, "addAppCheckListener " + appName);
+
+    FirebaseApp firebaseApp = FirebaseApp.getInstance(appName);
+    FirebaseAppCheck firebaseAppCheck = FirebaseAppCheck.getInstance(firebaseApp);
+
+    if (mAppCheckListeners.get(appName) == null) {
+      FirebaseAppCheck.AppCheckListener newAppCheckListener =
+          appCheckToken -> {
+            WritableMap eventBody = Arguments.createMap();
+            eventBody.putString("appName", appName); // for js side distribution
+            eventBody.putString("token", appCheckToken.getToken());
+            eventBody.putDouble("expireTimeMillis", appCheckToken.getExpireTimeMillis());
+
+            ReactNativeFirebaseEventEmitter emitter =
+                ReactNativeFirebaseEventEmitter.getSharedInstance();
+            ReactNativeFirebaseEvent event =
+                new ReactNativeFirebaseEvent("appCheck_token_changed", eventBody, appName);
+            emitter.sendEvent(event);
+          };
+
+      firebaseAppCheck.addAppCheckListener(newAppCheckListener);
+      mAppCheckListeners.put(appName, newAppCheckListener);
+    }
+  }
+
+  /** Removes the current token change listener */
+  @ReactMethod
+  public void removeAppCheckListener(String appName) {
+    Log.d(TAG, "removeAppCheckListener " + appName);
+
+    FirebaseApp firebaseApp = FirebaseApp.getInstance(appName);
+    FirebaseAppCheck firebaseAppCheck = FirebaseAppCheck.getInstance(firebaseApp);
+
+    FirebaseAppCheck.AppCheckListener mAppCheckListener = mAppCheckListeners.get(appName);
+
+    if (mAppCheckListener != null) {
+      firebaseAppCheck.removeAppCheckListener(mAppCheckListener);
+      mAppCheckListeners.remove(appName);
+    }
+  }
+}

package/android/src/main/java/io/invertase/firebase/appcheck/ReactNativeFirebaseAppCheckPackage.java

@@ -0,0 +1,41 @@
+package io.invertase.firebase.appcheck;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+@SuppressWarnings("unused")
+public class ReactNativeFirebaseAppCheckPackage implements ReactPackage {
+  @Override
+  public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+    List<NativeModule> modules = new ArrayList<>();
+    modules.add(new ReactNativeFirebaseAppCheckModule(reactContext));
+    return modules;
+  }
+
+  @Override
+  public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+    return Collections.emptyList();
+  }
+}

package/android/src/main/java/io/invertase/firebase/appcheck/ReactNativeFirebaseAppCheckProvider.java

@@ -0,0 +1,97 @@
+package io.invertase.firebase.appcheck;
+
+/*
+ * Copyright (c) 2023-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import android.util.Log;
+import androidx.annotation.NonNull;
+import com.google.android.gms.tasks.Task;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.appcheck.AppCheckProvider;
+import com.google.firebase.appcheck.AppCheckToken;
+import com.google.firebase.appcheck.debug.DebugAppCheckProviderFactory;
+import com.google.firebase.appcheck.debug.InternalDebugSecretProvider;
+import com.google.firebase.appcheck.debug.internal.DebugAppCheckProvider;
+import com.google.firebase.appcheck.playintegrity.PlayIntegrityAppCheckProviderFactory;
+import com.google.firebase.inject.Provider;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+// Facade for all possible provider factory delegates,
+// configurable dynamically instead of at startup
+public class ReactNativeFirebaseAppCheckProvider implements AppCheckProvider {
+  private static final String LOGTAG = "RNFBAppCheck";
+
+  AppCheckProvider delegateProvider;
+
+  @NonNull
+  @Override
+  public Task<AppCheckToken> getToken() {
+    Log.d(LOGTAG, "Provider::getToken - delegating to native provider");
+    return delegateProvider.getToken();
+  }
+
+  public void configure(String appName, String providerName, String debugToken) {
+    Log.d(
+        LOGTAG,
+        "Provider::configure with appName/providerName/debugToken: "
+            + appName
+            + "/"
+            + providerName
+            + "/"
+            + (debugToken != null ? "(not shown)" : "null"));
+
+    try {
+      FirebaseApp app = FirebaseApp.getInstance(appName);
+
+      if ("debug".equals(providerName)) {
+
+        // the debug configuration may have a token, or may not
+        if (debugToken != null) {
+          // To use this token, create debug provider using local secret provider + standard thread
+          // pool
+          ExecutorService executor = Executors.newCachedThreadPool();
+          delegateProvider =
+              new DebugAppCheckProvider(
+                  app,
+                  new Provider<InternalDebugSecretProvider>() {
+                    public InternalDebugSecretProvider get() {
+                      return new InternalDebugSecretProvider() {
+                        public String getDebugSecret() {
+                          return debugToken;
+                        }
+                      };
+                    }
+                  },
+                  executor,
+                  executor,
+                  executor);
+
+        } else {
+          delegateProvider = DebugAppCheckProviderFactory.getInstance().create(app);
+        }
+      }
+
+      if ("playIntegrity".equals(providerName)) {
+        delegateProvider = PlayIntegrityAppCheckProviderFactory.getInstance().create(app);
+      }
+    } catch (Exception e) {
+      // This will bubble up and result in a rejected promise with the underlying message
+      throw new RuntimeException(e.getMessage());
+    }
+  }
+}

package/android/src/main/java/io/invertase/firebase/appcheck/ReactNativeFirebaseAppCheckProviderFactory.java

@@ -0,0 +1,67 @@
+package io.invertase.firebase.appcheck;
+
+/*
+ * Copyright (c) 2023-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import android.util.Log;
+import androidx.annotation.NonNull;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.appcheck.AppCheckProvider;
+import com.google.firebase.appcheck.AppCheckProviderFactory;
+import java.util.HashMap;
+
+public class ReactNativeFirebaseAppCheckProviderFactory implements AppCheckProviderFactory {
+  private static final String LOGTAG = "RNFBAppCheck";
+
+  // This object has one job - create + maintain control over one provider per app
+  public HashMap<String, ReactNativeFirebaseAppCheckProvider> providers = new HashMap<>();
+
+  // Our provider will serve as a facade to all the supported native providers,
+  // we will just pass through configuration calls to it
+  public void configure(String appName, String providerName, String debugToken) {
+    Log.d(
+        LOGTAG,
+        "ProviderFactory::configure - appName/providerName/debugToken: "
+            + appName
+            + "/"
+            + providerName
+            + (debugToken != null ? "/(not shown)" : "/null"));
+
+    ReactNativeFirebaseAppCheckProvider provider;
+
+    // Look up the correct provider for the given appName, create it if not created
+    provider = providers.get(appName);
+    if (provider == null) {
+      provider = new ReactNativeFirebaseAppCheckProvider();
+      providers.put(appName, provider);
+    }
+    provider.configure(appName, providerName, debugToken);
+  }
+
+  @NonNull
+  public AppCheckProvider create(FirebaseApp firebaseApp) {
+    String appName = firebaseApp.getName();
+    Log.d(LOGTAG, "ProviderFactory::create - fetching provider for app " + appName);
+    ReactNativeFirebaseAppCheckProvider provider = providers.get(appName);
+    if (provider == null) {
+      Log.d(LOGTAG, "ProviderFactory::create - provider not configured for this app.");
+      throw new RuntimeException(
+          "ReactNativeFirebaseAppCheckProvider not configured for app " + appName);
+    }
+    return provider;
+  }
+}

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./plugin/build');