"
+ ).build()
+
+ Datadog.initialize(this, configuration, trackingConsent)
+ }
+}
+```
+{{% /tab %}}
+{{< /tabs >}}
+
+If you use reportFullyDrawn to identify the moment of full display, you can use getFullyDrawnReporter to subscribe to `reportFullyDrawn` and call `RumMonitor.reportFullyDrawn`. If you do not use reportFullyDrawn, you can still call `RumMonitor.reportFullyDrawn`, but it will make sense only for cold and warm starts, rather than hot starts.
+
+
+ If the time to full display is not defined, the Android SDK only collects the TTID.
+
+
+### RUM summary
+
+The TTID and TTFD are presented in the RUM Summary under Mobile Performance. The standalone Mobile Performance Dashboard also contains distribution visuals for TTID and TTFD.
+
+ {{< img src="real_user_monitoring/android/android-rum-summary-app-launch.png" alt="Android RUM Summary" style="width:90%;">}}
+
+### Vital events
+
+The time to initial display and time to full display are presented as vital events in the RUM session. They are also found under the first view after the `ApplicationLaunch` view. TTID and TTFD will be captured if the user launched the application in the session. Neither the TTID nor the TTFD will appear if the user did not launch the application during the session.
+
+ {{< img src="real_user_monitoring/android/android-app-launch-session.png" alt="Android session side panel" style="width:90%;">}}
+
+
+The TTID and TTFD can be queried in the RUM Sessions Explorer using the following attributes on the vital event type:
+- `@vital.type: app_launch`
+- `@vital.name: time_to_initial_display` or `@vital.name: time_to_full_display`
+
+Each TTID and TTFD side panel contains a distribution visualization, an indication of whether the launch was cold or warm, and an event waterfall.
+
+ {{< img src="real_user_monitoring/android/android-ttid-vital.png" alt="Time to initial display vital event" style="width:90%;">}}
+
+If Android profiling is enabled and the session is sampled, the time to initial display may include profiling data.
+
+### Metrics
+The time to initial display and time to full display are calculated as metrics:
+- `rum.measure.app.startup_to_initial_display`, which represents the time to initial display
+- `rum.measure.app.startup_to_full_display`, which represents the time to full display
+
+These metrics contain the `@vital.startup_type` attribute to specify the launch type for accurate monitoring.
+
+
+ The rum.measure.app.startup_to_full_display metric will not be calculated if the time to full display is not defined.
+
+
+## Further Reading
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+[1]: https://developer.android.com/topic/performance/vitals/launch-time#time-initial
+[2]: https://developer.android.com/topic/performance/vitals/launch-time#time-full
+[3]: https://developer.android.com/topic/performance/vitals/launch-time#cold
+[4]: https://developer.android.com/topic/performance/vitals/launch-time#warm
+[5]: https://developer.android.com/reference/android/app/Activity#reportFullyDrawn()
+[6]: https://developer.android.com/reference/androidx/activity/ComponentActivity#getFullyDrawnReporter%28%29
\ No newline at end of file
diff --git a/content/en/real_user_monitoring/application_monitoring/android/data_collected.md b/content/en/real_user_monitoring/application_monitoring/android/data_collected.md
index 4690535bf17..71dd87ab8df 100644
--- a/content/en/real_user_monitoring/application_monitoring/android/data_collected.md
+++ b/content/en/real_user_monitoring/application_monitoring/android/data_collected.md
@@ -35,15 +35,6 @@ The following diagram illustrates the RUM event hierarchy:
{{< img src="real_user_monitoring/data_collected/event-hierarchy.png" alt="RUM Event hierarchy" style="width:50%;" >}}
-## Application launch
-
-During initialization, the RUM Android SDK creates a view called "ApplicationLaunch". This view's start time matches the start of the Android process, and can be used to track your application launch time.
-
-The `ApplicationLaunch` view includes any logs, actions, and resources created before your first call to `startView`. Use the duration of this view to determine time to first view. This view has an action, `application_start`, with a duration that depends on Android version:
-
-- In *Android 7.0* and above, this view/action captures the period before any application code is executed (right before `Application.onCreate`) and when the first RUM event is recorded.
-- In versions before *Android 7.0*, the view/action captures the period between the `RumFeature` class loads and when the first RUM event is recorded.
-
## Views instrumentation versus app lifecycle
The Android RUM SDK offers various strategies to [automatically track views][2] like Activities, Fragments, or Navigation destinations. You can also track views manually by directly calling the RUM APIs. The precise moment a view starts or stops depends on the chosen tracking strategy or manual instrumentation:
diff --git a/content/en/real_user_monitoring/application_monitoring/ios/_index.md b/content/en/real_user_monitoring/application_monitoring/ios/_index.md
index 7b1688085e9..11dd6a5aa48 100644
--- a/content/en/real_user_monitoring/application_monitoring/ios/_index.md
+++ b/content/en/real_user_monitoring/application_monitoring/ios/_index.md
@@ -26,6 +26,7 @@ To get started with RUM for iOS, create an application and configure the iOS SDK
{{< whatsnext desc="This section includes the following topics:">}}
{{< nextlink href="/real_user_monitoring/application_monitoring/ios/setup">}}Setup: Learn how to set up the iOS SDK, track background events, and send data when devices are offline.{{< /nextlink >}}
{{< nextlink href="/real_user_monitoring/application_monitoring/ios/error_tracking">}}Crash Reporting: Add crash reporting, get deobfuscated stack traces, then test your implementation.{{< /nextlink >}}
+ {{< nextlink href="/real_user_monitoring/application_monitoring/ios/application_launch_monitoring">}}Application Launch Monitoring: Measure iOS mobile application launch performance, including the time to initial display and time to full display.{{< /nextlink >}}
{{< nextlink href="/real_user_monitoring/application_monitoring/ios/monitoring_app_performance">}}Monitoring App Performance: Monitor view timings to understand your app's performance from a user's perspective. {{< /nextlink >}}
{{< nextlink href="/real_user_monitoring/application_monitoring/ios/advanced_configuration">}}Advanced Configuration: Enrich user sessions, manage events and data, track custom global attributes, review initialization parameters, modify or drop RUM events, and more.{{< /nextlink >}}
{{< nextlink href="/real_user_monitoring/application_monitoring/ios/mobile_vitals">}}Data Collected: Review data that the RUM iOS SDK collects.{{< /nextlink >}}
diff --git a/content/en/real_user_monitoring/application_monitoring/ios/application_launch_monitoring.md b/content/en/real_user_monitoring/application_monitoring/ios/application_launch_monitoring.md
new file mode 100644
index 00000000000..e5f0ef75d98
--- /dev/null
+++ b/content/en/real_user_monitoring/application_monitoring/ios/application_launch_monitoring.md
@@ -0,0 +1,138 @@
+---
+title: iOS Mobile App Launch Monitoring
+description: "Measure Android mobile application launch performance, including the time to initial display and time to full display."
+aliases:
+- /real_user_monitoring/ios/data_collected/
+- /real_user_monitoring/mobile_and_tv_monitoring/application_launch_monitoring/ios/
+- /real_user_monitoring/mobile_and_tv_monitoring/ios/application_launch_monitoring/
+further_reading:
+ - link: "https://github.com/DataDog/dd-sdk-ios"
+ tag: "Source Code"
+ text: "Source code for dd-sdk-ios"
+ - link: "/real_user_monitoring/"
+ tag: "Documentation"
+ text: "Datadog Real User Monitoring"
+---
+
+
+ The application_start action is no longer collected starting from Android SDK version 3.5.0. The rum.measure.app.startup_time metric is marked as deprecated but continues to report data from devices running app versions that use older SDK versions.
+
+
+## Overview
+
+Application launch monitoring helps you understand how fast your iOS app becomes usable after a user taps the app icon. Use it to identify slow startup times, track performance regressions, and optimize the user’s first impression of your app.
+
+With this feature, you can:
+- Measure time to initial display (TTID) and time to full display (TTFD) for cold and warm starts
+- View launch performance trends in the RUM Summary and Mobile Performance Dashboard
+- Drill into individual launch events to diagnose bottlenecks
+
+## How it works
+
+During initialization, the RUM iOS SDK creates a view called `ApplicationLaunch`. This view’s start time matches the start of the iOS process. The `ApplicationLaunch` view includes any logs, actions, and resources created before your first call to `startView`.
+
+### Time to initial display and time to full display
+
+Starting from iOS SDK version 3.5.0, the time to initial display (TTID) and time to full display (TTFD) will be collected during the application launch period.
+
+| Measurement | Summary | Details |
+|----------------|----------|----------------------------------------------------------------------------------------------------------------------------------|
+| Time to initial display | The time it takes to display the first frame of the app's UI. | The time taken for an app to produce its first frame, including process initialization, scene and view hierarchy creation, and initial UI rendering. The splash screen, which the iOS manages, is not included in this calculation. |
+| Time to full display | The time it takes for an app to become interactive for the user. | The time it takes to display the first frame of the app's UI, as well as the content that loads asynchronously after the initial frame is displayed. |
+
+Each time to initial display and time to full display is categorized by launch type:
+- [Cold start][1]: Occurs when the system must fully initialize a new application process because no prior state or memory image can be reused. This includes launches after a first install, device reboot, application updates, or when the system has removed the application from memory.
+- [Warm start][1]: Occurs when the application process is relaunched, but the system can reuse some resources that were cached in memory. Warm starts typically occur in scenarios such as a user manually force-quitting the application, iOS terminating the application in the background due to memory or resource pressure, or an application crash.
+
+Either cold or warm starts can be [prewarmed][2], which is an iOS-specific optimization starting from iOS 15. In this scenario, the system proactively prepares the app process in the background to improve future launch times. Pre-warming typically occurs when:
+- The device has recently rebooted.
+- The system predicts that the user is likely to open the application soon.
+- The OS is executing background optimization routines.
+
+
+### Measuring the time to initial display
+The iOS SDK automatically measures the time to initial display. The time to initial display can be optionally profiled using the iOS Mobile Profiler.
+
+### Measuring the time to full display
+Since every application behaves differently, the iOS SDK does not automatically detect when to measure time to full display. As a result, the SDK needs to be notified when the application reaches the fully drawn state.
+
+The time to full display is manually defined using the `Monitor.reportAppFullyDisplayed()` API in the iOS SDK based on the application’s specific definition of “fully drawn.”
+
+The example below calls `Monitor.reportAppFullyDisplayed()` to measure the time to full display after the app finishes loading the data needed to render its initial UI. The signal is sent only once the UI has been updated with the received content or the error has been properly handled
+
+{{< tabs >}}
+{{% tab "Swift" %}}
+
+```swift
+@MainActor
+class HomeViewController: UIViewController {
+ override func viewDidLoad() {
+ super.viewDidLoad()
+ Task { await loadData() }
+ }
+
+ private func loadData() async {
+ let url = URL(string: "https://api.example.com/data")!
+ do {
+ let (data, _) = try await URLSession.shared.data(from: url)
+ updateUI(with: data)
+ } catch {
+ // Handle the error if needed
+ }
+
+ // Mark the app as fully displayed
+ RUMMonitor.shared().reportAppFullyDisplayed()
+ }
+}
+```
+{{% /tab %}}
+{{< /tabs >}}
+
+
+ If the time to full display is not defined, the iOS SDK will only collect the time to initial display.
+
+
+### RUM summary
+
+The time to initial display and time to full display are presented in the RUM Summary under Mobile Performance. The standalone Mobile Performance Dashboard also contains distribution visuals for time to initial display and time to full display.
+
+ {{< img src="real_user_monitoring/ios/ios-rum-summary-app-launch.png" alt="iOS RUM Summary" style="width:90%;">}}
+
+### Vital events
+
+The time to initial display and time to full display are presented as vital events in the RUM session. They are also found under the first view after the `ApplicationLaunch` view. TTID and TTFD will be captured if the user launched the application in the session. Neither TTID nor TTFD will appear if the user did not launch the application during the session.
+
+ {{< img src="real_user_monitoring/ios/ios-app-launch-session.png" alt="iOS session side panel" style="width:90%;">}}
+
+
+The TTID and TTFD can be queried in the RUM Sessions Explorer using the following attributes on the vital event type:
+- `@vital.type: app_launch`
+- `@vital.name: time_to_initial_display` or `@vital.name: time_to_full_display`
+
+Each TTID and TTFD side panel contains a distribution visualization, an indication of whether the launch was cold or warm, and an event waterfall.
+
+ {{< img src="real_user_monitoring/ios/ios-ttid-vital.png" alt="Time to initial display vital event" style="width:90%;">}}
+
+If iOS profiling is enabled and the session is sampled, the time to initial display may include profiling data.
+
+### Metrics
+The time to initial display and time to full display are calculated as metrics:
+- `rum.measure.app.startup_to_initial_display`, which represents the time to initial display
+- `rum.measure.app.startup_to_full_display`, which represents the time to full display
+
+
+These metrics contain attributes to specify the launch type for accurate monitoring:
+- `@vital.startup_type`
+- `@vital.is_prewarmed`
+
+
+
+ The rum.measure.app.startup_to_full_display metric will not be calculated if the time to full display is not defined.
+
+
+## Further Reading
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+[1]: https://developer.apple.com/documentation/xcode/reducing-your-app-s-launch-time
+[2]: https://developer.apple.com/documentation/uikit/about-the-app-launch-sequence#Prepare-your-app-for-prewarming
\ No newline at end of file
diff --git a/content/en/real_user_monitoring/application_monitoring/ios/data_collected.md b/content/en/real_user_monitoring/application_monitoring/ios/data_collected.md
index 36635e81b5b..67bd1b12bf5 100644
--- a/content/en/real_user_monitoring/application_monitoring/ios/data_collected.md
+++ b/content/en/real_user_monitoring/application_monitoring/ios/data_collected.md
@@ -36,14 +36,6 @@ The following diagram illustrates the RUM event hierarchy:
{{< img src="real_user_monitoring/data_collected/event-hierarchy.png" alt="RUM Event hierarchy" style="width:50%;border:none" >}}
-## Application launch
-
-During initialization, the RUM iOS SDK creates a view called "ApplicationLaunch". This view's start time matches the start of the iOS process, and can be used to track your application launch time.
-
-The ApplicationLaunch view includes any logs, actions, and resources created before your first call to `startView`. Use the duration of this view to determine time to first view. This view has an action, `application_start`, with a duration equal to the amount of time from process start until the call to `applicationDidBecomeActive`.
-
-In cases where iOS decides to [prewarm your application][2], the ApplicationLaunch view instead starts when the RUM iOS SDK is initialized, and the `application_start` event does not have a duration.
-
## Views instrumentation versus app lifecycle
RUM integrates seamlessly with `UIKit` and `SwiftUI` views and also provides APIs for manual view tracking. The timing of when a view starts and ends depends on the type of instrumentation used:
diff --git a/static/images/real_user_monitoring/android/android-app-launch-session.png b/static/images/real_user_monitoring/android/android-app-launch-session.png
new file mode 100644
index 00000000000..de0867cebf3
Binary files /dev/null and b/static/images/real_user_monitoring/android/android-app-launch-session.png differ
diff --git a/static/images/real_user_monitoring/android/android-rum-summary-app-launch.png b/static/images/real_user_monitoring/android/android-rum-summary-app-launch.png
new file mode 100644
index 00000000000..0f57815b760
Binary files /dev/null and b/static/images/real_user_monitoring/android/android-rum-summary-app-launch.png differ
diff --git a/static/images/real_user_monitoring/android/android-ttid-vital.png b/static/images/real_user_monitoring/android/android-ttid-vital.png
new file mode 100644
index 00000000000..4e63aa45af1
Binary files /dev/null and b/static/images/real_user_monitoring/android/android-ttid-vital.png differ
diff --git a/static/images/real_user_monitoring/ios/ios-app-launch-session.png b/static/images/real_user_monitoring/ios/ios-app-launch-session.png
new file mode 100644
index 00000000000..0b4c4591002
Binary files /dev/null and b/static/images/real_user_monitoring/ios/ios-app-launch-session.png differ
diff --git a/static/images/real_user_monitoring/ios/ios-rum-summary-app-launch.png b/static/images/real_user_monitoring/ios/ios-rum-summary-app-launch.png
new file mode 100644
index 00000000000..fd02b610c14
Binary files /dev/null and b/static/images/real_user_monitoring/ios/ios-rum-summary-app-launch.png differ
diff --git a/static/images/real_user_monitoring/ios/ios-ttid-vital.png b/static/images/real_user_monitoring/ios/ios-ttid-vital.png
new file mode 100644
index 00000000000..ee34dd28dc0
Binary files /dev/null and b/static/images/real_user_monitoring/ios/ios-ttid-vital.png differ