Migrate fireperf content provider to component

firebase-common/src/main/java/com/google/firebase/FirebaseApp.java

@@ -426,15 +426,21 @@ protected FirebaseApp(Context applicationContext, String name, FirebaseOptions o
     FirebaseTrace.popTrace(); // ComponentDiscovery
 
     FirebaseTrace.pushTrace("Runtime");
-    componentRuntime =
+    ComponentRuntime.Builder builder =
         ComponentRuntime.builder(UI_EXECUTOR)
             .addLazyComponentRegistrars(registrars)
             .addComponentRegistrar(new FirebaseCommonRegistrar())
             .addComponent(Component.of(applicationContext, Context.class))
             .addComponent(Component.of(this, FirebaseApp.class))
             .addComponent(Component.of(options, FirebaseOptions.class))
-            .setProcessor(new ComponentMonitor())
-            .build();
+            .setProcessor(new ComponentMonitor());
+
+    // Don't provide StartupTime in direct boot mode
+    if (UserManagerCompat.isUserUnlocked(applicationContext)) {
+      builder.addComponent(Component.of(StartupTime.now(), StartupTime.class));
+    }
+
+    componentRuntime = builder.build();
     FirebaseTrace.popTrace(); // Runtime
 
     dataCollectionConfigStorage =

firebase-common/src/main/java/com/google/firebase/StartupTime.java

@@ -0,0 +1,50 @@
+// Copyright 2022 Google LLC
+//
+// 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
+//
+// 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.
+
+package com.google.firebase;
+
+import com.google.auto.value.AutoValue;
+
+/**
+ * Represents the time at which Firebase began initialization, both in unix time/epoch milliseconds
+ * and in nanoseconds since the startup of the JVM. The absence of a StartupTime indicates an
+ * unreliable or misleading time, such as a launch in direct boot mode. Because of this, StartupTime
+ * cannot be guarenteed to be present, and instead should be optionally depended on, and its absence
+ * handled.
+ */
+@AutoValue
+public abstract class StartupTime {
+
+  /** @return The epoch time that Firebase began initializing, in milliseconds */
+  public abstract long getEpochMillis();
+
+  /**
+   * @return The number of nanoseconds from the start of the program to when Firebase began
+   *     initializing, measured by the JVM
+   */
+  public abstract long getStartupNanos();
+
+  /**
+   * @param epochMillis Time in milliseconds since epoch
+   * @param startupNanos Time in nanoseconds since JVM start
+   */
+  public static StartupTime create(long epochMillis, long startupNanos) {
+    return new AutoValue_StartupTime(epochMillis, startupNanos);
+  }
+
+  /** @return A StartupTime represented by the current epoch time and JVM nano time */
+  public static StartupTime now() {
+    return create(System.currentTimeMillis(), System.nanoTime());
+  }
+}

firebase-perf/src/main/AndroidManifest.xml

@@ -6,11 +6,6 @@
   <uses-permission android:name="android.permission.INTERNET"/>
 
   <application>
-    <provider
-      android:authorities="${applicationId}.firebaseperfprovider"
-      android:exported="false"
-      android:initOrder="101"
-      android:name="com.google.firebase.perf.provider.FirebasePerfProvider"/>
 
     <service
       android:exported="false"

firebase-perf/src/main/java/com/google/firebase/perf/FirebasePerfEarly.java

@@ -0,0 +1,64 @@
+// Copyright 2022 Google LLC
+//
+// 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
+//
+// 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.
+
+package com.google.firebase.perf;
+
+import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+import androidx.annotation.NonNull;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.StartupTime;
+import com.google.firebase.perf.application.AppStateMonitor;
+import com.google.firebase.perf.config.ConfigResolver;
+import com.google.firebase.perf.metrics.AppStartTrace;
+import com.google.firebase.perf.session.SessionManager;
+
+/**
+ * The Firebase Performance early initialization.
+ *
+ * <p>Responsible for initializing the AppStartTrace, and early initialization of ConfigResolver
+ */
+public class FirebasePerfEarly {
+  private final Handler mainHandler = new Handler(Looper.getMainLooper());
+
+  @NonNull
+  public static FirebasePerfEarly getInstance() {
+    return FirebaseApp.getInstance().get(FirebasePerfEarly.class);
+  }
+
+  public FirebasePerfEarly(FirebaseApp app) {
+    Context context = app.getApplicationContext();
+
+    // Initialize ConfigResolver early for accessing device caching layer.
+    ConfigResolver configResolver = ConfigResolver.getInstance();
+    configResolver.setApplicationContext(context);
+
+    AppStateMonitor appStateMonitor = AppStateMonitor.getInstance();
+    appStateMonitor.registerActivityLifecycleCallbacks(context);
+    appStateMonitor.registerForAppColdStart(new FirebasePerformanceInitializer());
+
+    if (app.get(StartupTime.class) != null) {
+      AppStartTrace appStartTrace = AppStartTrace.getInstance();
+      appStartTrace.registerActivityLifecycleCallbacks(context);
+      mainHandler.post(new AppStartTrace.StartFromBackgroundRunnable(appStartTrace));
+    }
+
+    // In the case of cold start, we create a session and start collecting gauges as early as
+    // possible.
+    // There is code in SessionManager that prevents us from resetting the session twice in case
+    // of app cold start.
+    SessionManager.getInstance().initializeGaugeCollection();
+  }
+}

firebase-perf/src/main/java/com/google/firebase/perf/FirebasePerfRegistrar.java

@@ -17,6 +17,7 @@
 import androidx.annotation.Keep;
 import com.google.android.datatransport.TransportFactory;
 import com.google.firebase.FirebaseApp;
+import com.google.firebase.StartupTime;
 import com.google.firebase.components.Component;
 import com.google.firebase.components.ComponentContainer;
 import com.google.firebase.components.ComponentRegistrar;
@@ -54,6 +55,13 @@ public List<Component<?>> getComponents() {
             .add(Dependency.requiredProvider(TransportFactory.class))
             .factory(FirebasePerfRegistrar::providesFirebasePerformance)
             .build(),
+        Component.builder(FirebasePerfEarly.class)
+            .name(LIBRARY_NAME)
+            .add(Dependency.required(FirebaseApp.class))
+            .add(Dependency.optionalProvider(StartupTime.class))
+            .alwaysEager()
+            .factory(FirebasePerfRegistrar::providesFirebasePerformanceEarly)
+            .build(),
         /**
          * Fireperf SDK is lazily by {@link FirebasePerformanceInitializer} during {@link
          * com.google.firebase.perf.application.AppStateMonitor#onActivityResumed(Activity)}. we use
@@ -77,4 +85,8 @@ private static FirebasePerformance providesFirebasePerformance(ComponentContaine
 
     return component.getFirebasePerformance();
   }
+
+  private static FirebasePerfEarly providesFirebasePerformanceEarly(ComponentContainer container) {
+    return new FirebasePerfEarly(container.get(FirebaseApp.class));
+  }
 }

firebase-perf/src/main/java/com/google/firebase/perf/config/RemoteConfigManager.java

@@ -22,9 +22,10 @@
 import androidx.annotation.Keep;
 import androidx.annotation.Nullable;
 import com.google.android.gms.common.util.VisibleForTesting;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.StartupTime;
 import com.google.firebase.inject.Provider;
 import com.google.firebase.perf.logging.AndroidLogger;
-import com.google.firebase.perf.provider.FirebasePerfProvider;
 import com.google.firebase.perf.util.Optional;
 import com.google.firebase.remoteconfig.FirebaseRemoteConfig;
 import com.google.firebase.remoteconfig.FirebaseRemoteConfigValue;
@@ -93,8 +94,12 @@ private RemoteConfigManager() {
         firebaseRemoteConfig == null
             ? new ConcurrentHashMap<>()
             : new ConcurrentHashMap<>(firebaseRemoteConfig.getAll());
-    this.appStartTimeInMs =
-        TimeUnit.MICROSECONDS.toMillis(FirebasePerfProvider.getAppStartTime().getMicros());
+    StartupTime startupTime = FirebaseApp.getInstance().get(StartupTime.class);
+    if (startupTime != null) {
+      this.appStartTimeInMs = startupTime.getEpochMillis();
+    } else {
+      this.appStartTimeInMs = System.currentTimeMillis();
+    }
     this.appStartConfigFetchDelayInMs = appStartConfigFetchDelayInMs;
   }
 

firebase-perf/src/main/java/com/google/firebase/perf/metrics/AppStartTrace.java

@@ -26,9 +26,10 @@
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import com.google.android.gms.common.util.VisibleForTesting;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.StartupTime;
 import com.google.firebase.perf.config.ConfigResolver;
 import com.google.firebase.perf.logging.AndroidLogger;
-import com.google.firebase.perf.provider.FirebasePerfProvider;
 import com.google.firebase.perf.session.PerfSession;
 import com.google.firebase.perf.session.SessionManager;
 import com.google.firebase.perf.transport.TransportManager;
@@ -91,6 +92,8 @@ public class AppStartTrace implements ActivityLifecycleCallbacks {
    */
   private boolean isTooLateToInitUI = false;
 
+  private static Timer firebaseStartupTime = null;
+
   private Timer appStartTime = null;
   private Timer onCreateTime = null;
   private Timer onStartTime = null;
@@ -163,9 +166,16 @@ static AppStartTrace getInstance(TransportManager transportManager, Clock clock)
     this.clock = clock;
     this.configResolver = configResolver;
     this.executorService = executorService;
+
+    StartupTime startupTime = FirebaseApp.getInstance().get(StartupTime.class);
+    if (startupTime == null) {
+      firebaseStartupTime = new Timer();
+    }
+    firebaseStartupTime =
+        Timer.ofElapsedRealtime(TimeUnit.NANOSECONDS.toMillis(startupTime.getStartupNanos()));
   }
 
-  /** Called from FirebasePerfProvider to register this callback. */
+  /** Called from FirebasePerfEarly to register this callback. */
   public synchronized void registerActivityLifecycleCallbacks(@NonNull Context context) {
     // Make sure the callback is registered only once.
     if (isRegisteredForLifecycleCallbacks) {
@@ -190,15 +200,15 @@ public synchronized void unregisterActivityLifecycleCallbacks() {
 
   /**
    * Gets the timetamp that marks the beginning of app start, currently defined as the beginning of
-   * BIND_APPLICATION. Fallback to class-load time of {@link FirebasePerfProvider} when API < 24.
+   * BIND_APPLICATION. Fallback to class-load time of {@link StartupTime} when API < 24.
    *
    * @return {@link Timer} at the beginning of app start by Fireperf definition.
    */
   private static Timer getStartTimer() {
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
       return Timer.ofElapsedRealtime(Process.getStartElapsedRealtime());
     }
-    return FirebasePerfProvider.getAppStartTime();
+    return firebaseStartupTime;
   }
 
   private void recordFirstDrawDone() {
@@ -225,8 +235,7 @@ public synchronized void onActivityCreated(Activity activity, Bundle savedInstan
     launchActivity = new WeakReference<Activity>(activity);
     onCreateTime = clock.getTime();
 
-    if (FirebasePerfProvider.getAppStartTime().getDurationMicros(onCreateTime)
-        > MAX_LATENCY_BEFORE_UI_INIT) {
+    if (firebaseStartupTime.getDurationMicros(onCreateTime) > MAX_LATENCY_BEFORE_UI_INIT) {
       isTooLateToInitUI = true;
     }
   }
@@ -261,7 +270,7 @@ public synchronized void onActivityResumed(Activity activity) {
     appStartActivity = new WeakReference<Activity>(activity);
 
     onResumeTime = clock.getTime();
-    this.appStartTime = FirebasePerfProvider.getAppStartTime();
+    this.appStartTime = firebaseStartupTime;
     this.startSession = SessionManager.getInstance().perfSession();
     AndroidLogger.getInstance()
         .debug(
@@ -290,8 +299,8 @@ private void logColdStart(Timer start, Timer end, PerfSession session) {
     TraceMetric.Builder subtrace =
         TraceMetric.newBuilder()
             .setName("_experiment_classLoadTime")
-            .setClientStartTimeUs(FirebasePerfProvider.getAppStartTime().getMicros())
-            .setDurationUs(FirebasePerfProvider.getAppStartTime().getDurationMicros(end));
+            .setClientStartTimeUs(firebaseStartupTime.getMicros())
+            .setDurationUs(firebaseStartupTime.getDurationMicros(end));
 
     metric.addSubtraces(subtrace).addPerfSessions(this.startSession.build());
 
@@ -347,8 +356,8 @@ public void onActivitySaveInstanceState(Activity activity, Bundle outState) {}
   /**
    * We use StartFromBackgroundRunnable to detect if app is started from background or foreground.
    * If app is started from background, we do not generate AppStart trace. This runnable is posted
-   * to main UI thread from FirebasePerfProvider. If app is started from background, this runnable
-   * will be executed before any activity's onCreate() method. If app is started from foreground,
+   * to main UI thread from FirebasePerfEarly. If app is started from background, this runnable will
+   * be executed before any activity's onCreate() method. If app is started from foreground,
    * activity's onCreate() method is executed before this runnable.
    */
   public static class StartFromBackgroundRunnable implements Runnable {