> ## Documentation Index
> Fetch the complete documentation index at: https://docs.flashcat.cloud/llms.txt
> Use this file to discover all available pages before exploring further.

# Advanced Configuration

> Configure advanced features of Android RUM SDK, including custom events, user tracking, sampling control, and data security

<Note>
  **About Dependencies and Package Names**

  Flashduty Android SDK is fully compatible with the Datadog open-source protocol. In `build.gradle`, use `cloud.flashcat` group for dependencies, but in Kotlin/Java code, import classes from the `com.datadog.android` package. You can seamlessly leverage Datadog ecosystem documentation, examples, and best practices while enjoying Flashduty platform services.
</Note>

Flashduty Android RUM SDK provides rich advanced configuration options to help you customize data collection and context information based on business needs.

<Info>
  **Supported Configuration Scenarios:**

  * Enrich user sessions - Add custom views, actions, resources, and error information
  * Protect sensitive data - Mask personally identifiable information and sensitive data
  * Associate user sessions - Link user sessions with internal user identifiers
  * Control data volume - Optimize data collection through sampling and event filtering
  * Enhance context - Add custom attributes to data
</Info>

## Enrich User Sessions

### Custom Views

When using `ActivityViewTrackingStrategy` or `FragmentViewTrackingStrategy`, the RUM SDK automatically tracks views. You can also manually send custom RUM views when a view becomes visible or interactive.

<Tabs>
  <Tab title="Kotlin">
    ```kotlin theme={null}
    import com.datadog.android.rum.GlobalRumMonitor

    fun onResume() {
        GlobalRumMonitor.get().startView(viewKey, viewName, attributes)
    }

    fun onPause() {
        GlobalRumMonitor.get().stopView(viewKey, attributes)
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    import com.datadog.android.rum.GlobalRumMonitor;

    public void onResume() {
        GlobalRumMonitor.get().startView(viewKey, viewName, attributes);
    }

    public void onPause() {
        GlobalRumMonitor.get().stopView(viewKey, attributes);
    }
    ```
  </Tab>
</Tabs>

<Note>
  **Parameter Description:**

  * `viewKey` (String) - Unique identifier for the view, same `viewKey` used for `startView()` and `stopView()`
  * `viewName` (String) - Name of the view
  * `attributes` (`Map<String, Any?>`) - Attributes attached to the view (optional)
</Note>

### Custom Actions

In addition to auto-tracked user interactions, you can track specific custom user actions (like clicks, swipes, likes).

<Tabs>
  <Tab title="Kotlin">
    ```kotlin theme={null}
    import com.datadog.android.rum.GlobalRumMonitor
    import com.datadog.android.rum.RumActionType

    fun onUserInteraction() {
        GlobalRumMonitor.get().addAction(
            RumActionType.TAP,
            name,
            attributes
        )
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    import com.datadog.android.rum.GlobalRumMonitor;
    import com.datadog.android.rum.RumActionType;

    public void onUserInteraction() {
        GlobalRumMonitor.get().addAction(
            RumActionType.TAP,
            name,
            attributes
        );
    }
    ```
  </Tab>
</Tabs>

<Accordion title="RumActionType Enum Values">
  | Type                   | Description   | Use Case                    |
  | ---------------------- | ------------- | --------------------------- |
  | `RumActionType.TAP`    | Tap action    | Button, icon taps           |
  | `RumActionType.SCROLL` | Scroll action | List, page scrolling        |
  | `RumActionType.SWIPE`  | Swipe action  | Swipe transitions, gestures |
  | `RumActionType.CLICK`  | Click action  | General clicks              |
  | `RumActionType.CUSTOM` | Custom action | Business-specific actions   |
</Accordion>

### Custom Resources

In addition to auto-tracked resources, you can manually track specific custom resources (like network requests, third-party library loading).

<Tabs>
  <Tab title="Kotlin">
    ```kotlin theme={null}
    import com.datadog.android.rum.GlobalRumMonitor
    import com.datadog.android.rum.RumResourceKind

    fun loadResource() {
        GlobalRumMonitor.get().startResource(resourceKey, method, url, attributes)
    }

    fun resourceLoadSuccess() {
        GlobalRumMonitor.get().stopResource(
            resourceKey, statusCode, size, 
            RumResourceKind.NATIVE, attributes
        )
    }

    fun resourceLoadError() {
        GlobalRumMonitor.get().stopResourceWithError(
            resourceKey, statusCode, message, source, throwable
        )
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    import com.datadog.android.rum.GlobalRumMonitor;
    import com.datadog.android.rum.RumResourceKind;

    public void loadResource() {
        GlobalRumMonitor.get().startResource(resourceKey, method, url, attributes);
    }

    public void resourceLoadSuccess() {
        GlobalRumMonitor.get().stopResource(
            resourceKey, statusCode, size, 
            RumResourceKind.NATIVE, attributes
        );
    }

    public void resourceLoadError() {
        GlobalRumMonitor.get().stopResourceWithError(
            resourceKey, statusCode, message, source, throwable
        );
    }
    ```
  </Tab>
</Tabs>

<Accordion title="RumResourceKind Resource Types">
  | Type       | Description         | Use Case                |
  | ---------- | ------------------- | ----------------------- |
  | `BEACON`   | Beacon request      | Analytics reporting     |
  | `FETCH`    | Fetch request       | Modern async requests   |
  | `XHR`      | XHR request         | Traditional Ajax        |
  | `DOCUMENT` | Document resource   | HTML documents          |
  | `IMAGE`    | Image resource      | Image loading           |
  | `JS`       | JavaScript resource | JS files                |
  | `FONT`     | Font resource       | Font files              |
  | `CSS`      | CSS resource        | Style files             |
  | `MEDIA`    | Media resource      | Audio/video files       |
  | `NATIVE`   | Native resource     | Native module loading   |
  | `OTHER`    | Other resource      | Uncategorized resources |
</Accordion>

### Custom Errors

To record specific errors, notify the RUM SDK when an exception occurs:

<Tabs>
  <Tab title="Kotlin">
    ```kotlin theme={null}
    import com.datadog.android.rum.GlobalRumMonitor

    GlobalRumMonitor.get().addError(
        message,
        source,
        throwable,
        attributes
    )
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    import com.datadog.android.rum.GlobalRumMonitor;

    GlobalRumMonitor.get().addError(
        message,
        source,
        throwable,
        attributes
    );
    ```
  </Tab>
</Tabs>

<Note>
  For more error reporting details, see [Android Error Reporting](/en/rum/error-tracking/erro-reporting/android).
</Note>

### Custom Timing

In addition to RUM SDK's default performance metrics, you can use the `addTiming` API to measure the duration of key operations. Timing is an offset relative to the current RUM view start time.

<Tabs>
  <Tab title="Kotlin">
    ```kotlin theme={null}
    import com.datadog.android.rum.GlobalRumMonitor

    fun onHeroImageLoaded() {
        GlobalRumMonitor.get().addTiming("hero_image")
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    import com.datadog.android.rum.GlobalRumMonitor;

    public void onHeroImageLoaded() {
        GlobalRumMonitor.get().addTiming("hero_image");
    }
    ```
  </Tab>
</Tabs>

<Tip>
  After setting timing, access it via `@view.custom_timings.<timing_name>`, e.g., `@view.custom_timings.hero_image`.
</Tip>

### Set User Information

The RUM SDK supports standard user information.

<Tabs>
  <Tab title="Kotlin">
    ```kotlin theme={null}
    import com.datadog.android.rum.GlobalRumMonitor

    GlobalRumMonitor.get().setUserInfo(
        id = "1234",
        name = "John Doe",
        email = "john@doe.com"
    )
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    import com.datadog.android.rum.GlobalRumMonitor;

    GlobalRumMonitor.get().setUserInfo(
        "1234",
        "John Doe",
        "john@doe.com",
        null
    );
    ```
  </Tab>
</Tabs>

<Warning>
  Only standard user fields are supported: `id`, `name`, `email`, and `anonymous_id`. Other user attributes are not supported. If needed, configure them under `context`.
</Warning>

## Event and Data Management

### Clear All Data

Use `clearAllData` to clear all unsent data currently stored in the SDK:

<Tabs>
  <Tab title="Kotlin">
    ```kotlin theme={null}
    import com.datadog.android.Datadog

    Datadog.clearAllData()
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    import com.datadog.android.Datadog;

    Datadog.clearAllData();
    ```
  </Tab>
</Tabs>

## Sampling

You can control the percentage of sessions that collect RUM data:

```kotlin theme={null}
val rumConfig = RumConfiguration.Builder(applicationId)
    .setSessionSampleRate(80f)  // Collect 80% of sessions
    .build()
```

<Warning>
  Sampled-out sessions will not collect any page views or related telemetry data.
</Warning>

## User Tracking Consent

To comply with privacy regulations like GDPR and CCPA, you can set user tracking consent state:

```kotlin theme={null}
// Set consent state during initialization
Datadog.initialize(this, configuration, TrackingConsent.PENDING)

// Update consent state when user grants permission
Datadog.setTrackingConsent(TrackingConsent.GRANTED)

// Update consent state when user revokes permission
Datadog.setTrackingConsent(TrackingConsent.NOT_GRANTED)
```

| State         | Behavior                                        |
| ------------- | ----------------------------------------------- |
| `GRANTED`     | Start collecting data and send to Flashduty     |
| `NOT_GRANTED` | Do not collect any data                         |
| `PENDING`     | Collect but do not send, wait for user decision |

## Global Context

Add global context attributes that will be attached to all RUM events:

<Tabs>
  <Tab title="Kotlin">
    ```kotlin theme={null}
    import com.datadog.android.rum.GlobalRumMonitor

    // Add attribute
    GlobalRumMonitor.get().addAttribute("user_type", "premium")

    // Remove attribute
    GlobalRumMonitor.get().removeAttribute("user_type")
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    import com.datadog.android.rum.GlobalRumMonitor;

    // Add attribute
    GlobalRumMonitor.get().addAttribute("user_type", "premium");

    // Remove attribute
    GlobalRumMonitor.get().removeAttribute("user_type");
    ```
  </Tab>
</Tabs>

## Event Mappers

Use Event Mappers to modify or filter events before they are sent:

```kotlin theme={null}
val rumConfig = RumConfiguration.Builder(applicationId)
    .setViewEventMapper { viewEvent ->
        // Modify view event
        viewEvent.view.url = viewEvent.view.url.replace("sensitive", "redacted")
        viewEvent
    }
    .setActionEventMapper { actionEvent ->
        // Filter specific actions
        if (actionEvent.action.target?.name?.contains("password") == true) {
            null  // Discard this event
        } else {
            actionEvent
        }
    }
    .setErrorEventMapper { errorEvent ->
        // Modify error event
        errorEvent
    }
    .setResourceEventMapper { resourceEvent ->
        // Modify resource event
        resourceEvent
    }
    .build()
```

<Warning>
  View events cannot be discarded (returning null has no effect).
</Warning>

## Related Documentation

<CardGroup cols={3}>
  <Card title="SDK Integration" icon="plug" href="/en/rum/sdk/android/sdk-integration">
    Learn how to quickly integrate the RUM SDK
  </Card>

  <Card title="Data Collection" icon="database" href="/en/rum/sdk/android/data-collection">
    Learn about data types and attributes collected by the SDK
  </Card>

  <Card title="Compatibility" icon="check" href="/en/rum/sdk/android/compatible">
    Learn about SDK compatibility requirements
  </Card>
</CardGroup>