@react-native-firebase/perf 16.7.0 → 17.1.0

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [17.1.0](https://github.com/invertase/react-native-firebase/compare/v17.0.0...v17.1.0) (2023-02-09)
+
+### Features
+
+- **perf:** Expose modular API that matches the Firebase web JS SDK v9 API ([#6771](https://github.com/invertase/react-native-firebase/issues/6771)) ([4e170ea](https://github.com/invertase/react-native-firebase/commit/4e170ead24035cd0154b153dcf1e8d69d6ab7ac9))
+
+## [17.0.0](https://github.com/invertase/react-native-firebase/compare/v16.7.0...v17.0.0) (2023-02-02)
+
+**Note:** Version bump only for package @react-native-firebase/perf
+
 ## [16.7.0](https://github.com/invertase/react-native-firebase/compare/v16.6.0...v16.7.0) (2023-01-28)
 
 ### Features

package/android/src/main/java/io/invertase/firebase/perf/ScreenTrace.java

@@ -3,53 +3,48 @@ package io.invertase.firebase.perf;
 /**
  * Copyright 2021 Google Inc. All Rights Reserved.
  *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
+ * <p>Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
  *
- * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>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
+ * <p>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.app.Activity;
 import android.os.Build;
 import android.util.Log;
 import android.util.SparseIntArray;
 import android.view.WindowManager;
-
 import androidx.core.app.FrameMetricsAggregator;
-
 import com.google.firebase.perf.FirebasePerformance;
 import com.google.firebase.perf.metrics.Trace;
 import com.google.firebase.perf.util.Constants;
 
 /**
- * Utility class to capture Screen rendering information (Slow/Frozen frames) for the
- * {@code Activity} passed to the constructor {@link io.invertase.firebase.perf.ScreenTrace#ScreenTrace(Activity, String)}.
- * <p>
- * Learn more at https://firebase.google.com/docs/perf-mon/screen-traces?platform=android.
- * <p>
- * A slow screen rendering often leads to a UI Jank which creates a bad user experience. Below are
- * some tips and references to understand and fix common UI Jank issues:
- * - https://developer.android.com/topic/performance/vitals/render.html#fixing_jank
- * - https://youtu.be/CaMTIgxCSqU (Why 60fps?)
- * - https://youtu.be/HXQhu6qfTVU (Rendering Performance)
- * - https://youtu.be/1iaHxmfZGGc (Understanding VSYNC)
- * - https://www.youtube.com/playlist?list=PLOU2XLYxmsIKEOXh5TwZEv89aofHzNCiu (Android Performance Patterns)
- * <p>
- * References:
- * - Fireperf Source Code
+ * Utility class to capture Screen rendering information (Slow/Frozen frames) for the {@code
+ * Activity} passed to the constructor {@link
+ * io.invertase.firebase.perf.ScreenTrace#ScreenTrace(Activity, String)}.
+ *
+ * <p>Learn more at https://firebase.google.com/docs/perf-mon/screen-traces?platform=android.
+ *
+ * <p>A slow screen rendering often leads to a UI Jank which creates a bad user experience. Below
+ * are some tips and references to understand and fix common UI Jank issues: -
+ * https://developer.android.com/topic/performance/vitals/render.html#fixing_jank -
+ * https://youtu.be/CaMTIgxCSqU (Why 60fps?) - https://youtu.be/HXQhu6qfTVU (Rendering Performance)
+ * - https://youtu.be/1iaHxmfZGGc (Understanding VSYNC) -
+ * https://www.youtube.com/playlist?list=PLOU2XLYxmsIKEOXh5TwZEv89aofHzNCiu (Android Performance
+ * Patterns)
+ *
+ * <p>References: - Fireperf Source Code
  */
 public class ScreenTrace {
 
   private static final String TAG = "RNFirebasePerf";
   private static final String FRAME_METRICS_AGGREGATOR_CLASSNAME =
-    "androidx.core.app.FrameMetricsAggregator";
+      "androidx.core.app.FrameMetricsAggregator";
 
   private final Activity activity;
   private final String traceName;
@@ -61,8 +56,8 @@ public class ScreenTrace {
    * Default constructor for this class.
    *
    * @param activity for which the screen traces should be recorded.
-   * @param tag      used as an identifier for the name to be used to log screen rendering
-   *                 information (like "MyFancyScreen").
+   * @param tag used as an identifier for the name to be used to log screen rendering information
+   *     (like "MyFancyScreen").
    * @implNote It requires hardware acceleration to be on or it throws.
    */
   public ScreenTrace(Activity activity, String tag) throws IllegalStateException {
@@ -75,7 +70,9 @@ public class ScreenTrace {
     boolean isScreenTraceSupported = checkScreenTraceSupport(activity);
 
     if (!isScreenTraceSupported) {
-      throw new IllegalStateException("Device does not support screen traces. Hardware acceleration must be enabled and Android must not be 8.0 or 8.1.");
+      throw new IllegalStateException(
+          "Device does not support screen traces. Hardware acceleration must be enabled and Android"
+              + " must not be 8.0 or 8.1.");
     }
 
     frameMetricsAggregator = new FrameMetricsAggregator();
@@ -83,9 +80,7 @@ public class ScreenTrace {
 
   // region Public APIs
 
-  /**
-   * Starts recording the frame metrics for the screen traces.
-   */
+  /** Starts recording the frame metrics for the screen traces. */
   public void recordScreenTrace() {
     Log.d(TAG, "Recording screen trace " + traceName);
 
@@ -97,7 +92,7 @@ public class ScreenTrace {
    * Stops recording screen traces and dispatches the trace capturing information on %age of
    * Slow/Frozen frames.
    *
-   * Inspired by fireperf source.
+   * <p>Inspired by fireperf source.
    */
   public void sendScreenTrace() {
     if (perfScreenTrace == null) return;
@@ -143,12 +138,20 @@ public class ScreenTrace {
       perfScreenTrace.putMetric(Constants.CounterNames.FRAMES_FROZEN.toString(), frozenFrames);
     }
 
-    Log.d(TAG, new StringBuilder()
-      .append("sendScreenTrace ").append(traceName)
-      .append(", name: ").append(getScreenTraceName())
-      .append(", total_frames: ").append(totalFrames)
-      .append(", slow_frames: ").append(slowFrames)
-      .append(", frozen_frames: ").append(frozenFrames).toString());
+    Log.d(
+        TAG,
+        new StringBuilder()
+            .append("sendScreenTrace ")
+            .append(traceName)
+            .append(", name: ")
+            .append(getScreenTraceName())
+            .append(", total_frames: ")
+            .append(totalFrames)
+            .append(", slow_frames: ")
+            .append(slowFrames)
+            .append(", frozen_frames: ")
+            .append(frozenFrames)
+            .toString());
 
     // Stop and record trace
     perfScreenTrace.stop();
@@ -161,17 +164,30 @@ public class ScreenTrace {
   private static boolean checkScreenTraceSupport(Activity activity) {
     boolean isValidSDKVersion = checkSDKVersion();
     boolean hasFrameMetricsAggregatorClass = checkFrameMetricsAggregatorClass();
-    boolean isActivityHardwareAccelerated = activity.getWindow() != null
-      && ((activity.getWindow().getAttributes().flags & WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED) != 0);
-
-
-    boolean supported = isValidSDKVersion && hasFrameMetricsAggregatorClass && isActivityHardwareAccelerated;
-
-    Log.d(TAG, new StringBuilder()
-      .append("isValidSDKVersion: ").append(isValidSDKVersion)
-      .append("isScreenTraceSupported(").append(activity).append("): ").append(supported)
-      .append(" [hasFrameMetricsAggregatorClass: ").append(hasFrameMetricsAggregatorClass)
-      .append(", isActivityHardwareAccelerated: ").append(isActivityHardwareAccelerated).append("]").toString());
+    boolean isActivityHardwareAccelerated =
+        activity.getWindow() != null
+            && ((activity.getWindow().getAttributes().flags
+                    & WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED)
+                != 0);
+
+    boolean supported =
+        isValidSDKVersion && hasFrameMetricsAggregatorClass && isActivityHardwareAccelerated;
+
+    Log.d(
+        TAG,
+        new StringBuilder()
+            .append("isValidSDKVersion: ")
+            .append(isValidSDKVersion)
+            .append("isScreenTraceSupported(")
+            .append(activity)
+            .append("): ")
+            .append(supported)
+            .append(" [hasFrameMetricsAggregatorClass: ")
+            .append(hasFrameMetricsAggregatorClass)
+            .append(", isActivityHardwareAccelerated: ")
+            .append(isActivityHardwareAccelerated)
+            .append("]")
+            .toString());
 
     return supported;
   }
@@ -184,9 +200,7 @@ public class ScreenTrace {
     return true;
   }
 
-  /**
-   * Inspired by fireperf source.
-   */
+  /** Inspired by fireperf source. */
   private static boolean checkFrameMetricsAggregatorClass() {
     try {
       Class<?> initializerClass = Class.forName(FRAME_METRICS_AGGREGATOR_CLASSNAME);
@@ -196,9 +210,7 @@ public class ScreenTrace {
     }
   }
 
-  /**
-   * Inspired by fireperf source.
-   */
+  /** Inspired by fireperf source. */
   private String getScreenTraceName() {
     return Constants.SCREEN_TRACE_PREFIX + traceName;
   }

package/android/src/main/java/io/invertase/firebase/perf/UniversalFirebasePerfModule.java

@@ -55,6 +55,9 @@ public class UniversalFirebasePerfModule extends UniversalFirebaseModule {
     constants.put(
         "isPerformanceCollectionEnabled",
         FirebasePerformance.getInstance().isPerformanceCollectionEnabled());
+        constants.put(
+          "isInstrumentationEnabled",
+          true);    
     return constants;
   }
 
@@ -105,24 +108,24 @@ public class UniversalFirebasePerfModule extends UniversalFirebaseModule {
 
   Task<Void> startScreenTrace(Activity activity, int id, String identifier) {
     return Tasks.call(
-      () -> {
-        ScreenTrace screenTrace = new ScreenTrace(activity, identifier);
-        screenTrace.recordScreenTrace();
-        screenTraces.put(id, screenTrace);
+        () -> {
+          ScreenTrace screenTrace = new ScreenTrace(activity, identifier);
+          screenTrace.recordScreenTrace();
+          screenTraces.put(id, screenTrace);
 
-        return null;
-      });
+          return null;
+        });
   }
 
   Task<Void> stopScreenTrace(int id) {
     return Tasks.call(
-      () -> {
-        ScreenTrace trace = screenTraces.get(id);
-        trace.sendScreenTrace();
-        screenTraces.remove(id);
+        () -> {
+          ScreenTrace trace = screenTraces.get(id);
+          trace.sendScreenTrace();
+          screenTraces.remove(id);
 
-        return null;
-      });
+          return null;
+        });
   }
 
   Task<Void> startHttpMetric(int id, String url, String httpMethod) {

package/android/src/reactnative/java/io/invertase/firebase/perf/ReactNativeFirebasePerfModule.java

@@ -97,29 +97,29 @@ public class ReactNativeFirebasePerfModule extends ReactNativeFirebaseModule {
     }
 
     module
-      .startScreenTrace(currentActivity, id, identifier)
-      .addOnCompleteListener(
-        task -> {
-          if (task.isSuccessful()) {
-            promise.resolve(task.getResult());
-          } else {
-            rejectPromiseWithExceptionMap(promise, task.getException());
-          }
-        });
+        .startScreenTrace(currentActivity, id, identifier)
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(task.getResult());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
   }
 
   @ReactMethod
   public void stopScreenTrace(int id, Promise promise) {
     module
-      .stopScreenTrace(id)
-      .addOnCompleteListener(
-        task -> {
-          if (task.isSuccessful()) {
-            promise.resolve(task.getResult());
-          } else {
-            rejectPromiseWithExceptionMap(promise, task.getException());
-          }
-        });
+        .stopScreenTrace(id)
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(task.getResult());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
   }
 
   @ReactMethod

package/ios/RNFBPerf/RNFBPerfModule.m

@@ -58,6 +58,8 @@ RCT_EXPORT_MODULE();
   NSMutableDictionary *constants = [NSMutableDictionary new];
   constants[@"isPerformanceCollectionEnabled"] =
       @([RCTConvert BOOL:@([FIRPerformance sharedInstance].dataCollectionEnabled)]);
+  constants[@"isInstrumentationEnabled"] =
+      @([RCTConvert BOOL:@([FIRPerformance sharedInstance].instrumentationEnabled)]);
   return constants;
 }
 
@@ -73,7 +75,6 @@ RCT_EXPORT_METHOD(setPerformanceCollectionEnabled
                   : (RCTPromiseResolveBlock)resolve rejecter
                   : (RCTPromiseRejectBlock)reject) {
   [FIRPerformance sharedInstance].dataCollectionEnabled = (BOOL)enabled;
-  [FIRPerformance sharedInstance].instrumentationEnabled = (BOOL)enabled;
   resolve([NSNull null]);
 }
 
@@ -203,4 +204,12 @@ RCT_EXPORT_METHOD(stopHttpMetric
   resolve([NSNull null]);
 }
 
+RCT_EXPORT_METHOD(instrumentationEnabled
+                  : (BOOL)enabled resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+  [FIRPerformance sharedInstance].instrumentationEnabled = (BOOL)enabled;
+  resolve([NSNull null]);
+}
+
 @end

package/lib/index.d.ts

@@ -426,7 +426,22 @@ export namespace FirebasePerformanceTypes {
      * ```
      */
     isPerformanceCollectionEnabled: boolean;
-
+    /**
+     * Determines whether to collect 'out of the box' (i.e already setup for Firebase Performance) events.
+     * This can be set for iOS. Android will always return "true" as it has to be set at gradle level.
+     */
+    instrumentationEnabled: boolean;
+    /**
+     * Determines whether performance monitoring is enabled or disabled.
+     *
+     * #### Example
+     *
+     * ```js
+     * const isEnabled = firebase.perf().dataCollectionEnabled;
+     * console.log('Performance collection enabled: ', isEnabled);
+     * ```
+     */
+    dataCollectionEnabled: boolean;
     /**
      * Enables or disables performance monitoring.
      *
@@ -436,8 +451,9 @@ export namespace FirebasePerformanceTypes {
      * // Disable performance monitoring collection
      * await firebase.perf().setPerformanceCollectionEnabled(false);
      * ```
-     *
-     * @param enabled Should performance monitoring be enabled
+     * @deprecated prefer setting `dataCollectionEnabled = boolean`.
+     * @param enabled Should performance monitoring be enabled. For iOS only, this also toggles whether instrumentation
+     * is enabled. See: https://firebase.google.com/docs/reference/ios/firebaseperformance/api/reference/Classes/FIRPerformance#instrumentationenabled
      */
     setPerformanceCollectionEnabled(enabled: boolean): Promise<null>;
 
@@ -470,7 +486,7 @@ export namespace FirebasePerformanceTypes {
 
     /**
      * Creates a ScreenTrace instance with the given identifier.
-     * Throws if hardware acceleration is diabled or if Android is 9.0 or 9.1.
+     * Throws if hardware acceleration is disabled or if Android is 9.0 or 9.1.
      *
      * #### Example
      *
@@ -489,7 +505,7 @@ export namespace FirebasePerformanceTypes {
 
     /**
      * Creates a ScreenTrace instance with the given identifier and immediately starts it.
-     * Throws if hardware acceleration is diabled or if Android is 9.0 or 9.1.
+     * Throws if hardware acceleration is disabled or if Android is 9.0 or 9.1.
      *
      * #### Example
      *

package/lib/index.js

@@ -21,11 +21,21 @@ import {
   FirebaseModule,
   getFirebaseRoot,
 } from '@react-native-firebase/app/lib/internal';
+import { Platform } from 'react-native';
 import HttpMetric from './HttpMetric';
 import Trace from './Trace';
 import ScreenTrace from './ScreenTrace';
 import version from './version';
 
+export {
+  getPerformance,
+  initializePerformance,
+  trace,
+  httpMetric,
+  newScreenTrace,
+  startScreenTrace,
+} from './modular/index';
+
 const statics = {};
 
 const namespace = 'perf';
@@ -48,19 +58,55 @@ class FirebasePerfModule extends FirebaseModule {
   constructor(...args) {
     super(...args);
     this._isPerformanceCollectionEnabled = this.native.isPerformanceCollectionEnabled;
+    this._instrumentationEnabled = this.native.isInstrumentationEnabled;
   }
 
   get isPerformanceCollectionEnabled() {
     return this._isPerformanceCollectionEnabled;
   }
 
-  setPerformanceCollectionEnabled(enabled) {
+  get instrumentationEnabled() {
+    return this._instrumentationEnabled;
+  }
+
+  set instrumentationEnabled(enabled) {
+    if (!isBoolean(enabled)) {
+      throw new Error("firebase.perf().instrumentationEnabled = 'enabled' must be a boolean.");
+    }
+    if (Platform.OS == 'ios') {
+      // We don't change for android as it cannot be set from code, it is set at gradle build time.
+      this._instrumentationEnabled = enabled;
+      // No need to await, as it only takes effect on the next app run.
+      this.native.instrumentationEnabled(enabled);
+    }
+  }
+
+  get dataCollectionEnabled() {
+    return this._isPerformanceCollectionEnabled;
+  }
+
+  set dataCollectionEnabled(enabled) {
+    if (!isBoolean(enabled)) {
+      throw new Error("firebase.perf().dataCollectionEnabled = 'enabled' must be a boolean.");
+    }
+    this._isPerformanceCollectionEnabled = enabled;
+    this.native.setPerformanceCollectionEnabled(enabled);
+  }
+
+  async setPerformanceCollectionEnabled(enabled) {
     if (!isBoolean(enabled)) {
       throw new Error(
         "firebase.perf().setPerformanceCollectionEnabled(*) 'enabled' must be a boolean.",
       );
     }
 
+    if (Platform.OS == 'ios') {
+      // '_instrumentationEnabled' is updated here as well to maintain backward compatibility. See:
+      // https://github.com/invertase/react-native-firebase/commit/b705622e64d6ebf4ee026d50841e2404cf692f85
+      this._instrumentationEnabled = enabled;
+      await this.native.instrumentationEnabled(enabled);
+    }
+
     this._isPerformanceCollectionEnabled = enabled;
     return this.native.setPerformanceCollectionEnabled(enabled);
   }

package/lib/modular/index.js

@@ -0,0 +1,89 @@
+/*
+ * 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 { isBoolean } from '@react-native-firebase/app/lib/common';
+import { firebase } from '..';
+
+/**
+ * Returns a Performance instance for the given app.
+ * @param app - FirebaseApp. Optional.
+ * @returns {Performance}
+ */
+export function getPerformance(app) {
+  if (app) {
+    return firebase.app(app.name).perf();
+  }
+
+  return firebase.app().perf();
+}
+
+/**
+ * Returns a Performance instance for the given app.
+ * @param app - FirebaseApp. Required.
+ * @param settings - PerformanceSettings. Set "dataCollectionEnabled" which will enable/disable Performance collection.
+ * @returns {Performance}
+ */
+export async function initializePerformance(app, settings) {
+  const perf = firebase.app(app.name).perf();
+
+  if (settings && isBoolean(settings.dataCollectionEnabled)) {
+    await perf.setPerformanceCollectionEnabled(settings.dataCollectionEnabled);
+  }
+
+  return perf;
+}
+
+/**
+ * Returns a Trace instance.
+ * @param perf - Performance instance
+ * @param identifier - A String to identify the Trace instance
+ * @returns {Trace}
+ */
+export function trace(perf, identifier) {
+  return perf.newTrace(identifier);
+}
+
+/**
+ * Returns a HttpMetric instance.
+ * @param perf - Performance instance
+ * @param identifier - A String to identify the HttpMetric instance
+ * @returns {HttpMetric}
+ */
+export function httpMetric(perf, identifier, httpMethod) {
+  return perf.newHttpMetric(identifier, httpMethod);
+}
+
+/**
+ * Creates a ScreenTrace instance with the given identifier.
+ * Throws if hardware acceleration is disabled or if Android is 9.0 or 9.1.
+ * @platform android Android !== 9.0.0 && Android !== 9.1.0
+ * @param perf - Performance instance
+ * @param identifier Name of the trace, no leading or trailing whitespace allowed, no leading underscore '_' character allowed, max length is 100.
+ */
+export function newScreenTrace(perf, identifier) {
+  return perf.newScreenTrace(identifier);
+}
+/**
+ * Creates a ScreenTrace instance with the given identifier and immediately starts it.
+ * Throws if hardware acceleration is disabled or if Android is 9.0 or 9.1.
+ * @platform android Android !== 9.0.0 && Android !== 9.1.0
+ * @param perf - Performance instance
+ * @param identifier Name of the screen
+ */
+export function startScreenTrace(perf, identifier) {
+  return perf.startScreenTrace(identifier);
+}

package/lib/version.js

@@ -1,2 +1,2 @@
 // Generated by genversion.
-module.exports = '16.7.0';
+module.exports = '17.1.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-firebase/perf",
-  "version": "16.7.0",
+  "version": "17.1.0",
   "author": "Invertase <oss@invertase.io> (http://invertase.io)",
   "description": "React Native Firebase - React Native Firebase provides native integration with Performance Monitoring to gain insight into key performance characteristics within your React Native application.",
   "main": "lib/index.js",
@@ -29,7 +29,7 @@
     "performance monitoring"
   ],
   "peerDependencies": {
-    "@react-native-firebase/app": "16.7.0"
+    "@react-native-firebase/app": "17.1.0"
   },
   "dependencies": {
     "@expo/config-plugins": "^5.0.4"
@@ -37,5 +37,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "a94f371da16f9bf873c18b09541cbeb19960978d"
+  "gitHead": "635d595389bfb224fc530681627fb2180fea6e26"
 }