Event Monitoring for Android App

⚙️ Configure Event Monitoring for an Android Application

📖 Overview

The GermainUX Mobile App library can collect application lifecycle events and selected Android system events.

Application events provide reliable context about the monitored application itself. System-event availability varies according to:

Modern Android versions restrict many implicit broadcasts and device events. GermainUX can collect only events delivered to the monitored application and accessible through supported Android APIs.

✨ Application Events

After GermainUX initializes, it can automatically monitor supported application events such as:

The final uptime value requires GermainUX to observe or receive an end condition. Android does not always notify an application before terminating its process.

🚀 Application Launch Monitoring

GermainUX automatically starts application monitoring during initialization.

To obtain meaningful launch measurements:

1. Initialize GermainUX from the application’s Application subclass.

2. Initialize it only once per process.

3. Perform initialization early in the application lifecycle.

4. Avoid unnecessary blocking work before or during initialization.

5. Test cold, warm, and normal user launches.

Application launch performance can be analyzed by:

🔄 Foreground and Background Monitoring

GermainUX can record when the application transitions between foreground and background states.

These events help measure:

Android lifecycle events do not prove that a user intentionally closed the application. A transition to the background may result from navigation to another application, locking the device, receiving a system interruption, or Android lifecycle management.

Low-Memory Events

GermainUX can capture memory-pressure callbacks delivered to the application by Android.

These events can help investigate:

A low-memory callback indicates that Android requested the application to reduce memory usage. It does not necessarily mean that the application itself has a memory leak.

🔧 Configure System-Event Monitoring

Use setSystemEventsMonitoring() on GermainAPMConfiguration to enable or disable supported system-event monitoring.

☕ Java

GermainAPMConfiguration config =
    new GermainAPMConfiguration(
        "https://YOUR_GERMAINUX_HOST/ingestion/fact"
    );

config.setSystemEventsMonitoring(true);

GermainAPM.init(this, config);

🐍 Kotlin

val config = GermainAPMConfiguration(
    "https://YOUR_GERMAINUX_HOST/ingestion/fact"
)

config.setSystemEventsMonitoring(true)

GermainAPM.init(this, config)

When enabled, the library attempts to collect the system events supported by the installed library and delivered to the application.

The current configuration enables or disables system-event monitoring as a group. Review the installed library version for the precise events it supports.

📦 Possible System-Event Categories

Depending on Android and application permissions, GermainUX may receive events related to:

Do not assume that every event in these categories will be available on every device.

Events involving calls, messages, Bluetooth devices, media, other applications, or sensitive device state can require restricted permissions or may be unavailable to ordinary applications on modern Android versions.

Do not request sensitive permissions solely for monitoring unless the event is necessary, permitted by platform policy, and approved by the organization.

🚪 Application Exit and Uptime

Android does not provide a universal callback when an application is closed. The process can be terminated without allowing the application to execute final code.

GermainUX can complete application-uptime monitoring in the following situations:

Normal background transitions should not be reported as application exits.

📣 Report an Application-Controlled Exit

If the application deliberately ends its own workflow or process, call collectApplicationExit() before the termination logic.

☕ Java

boolean calledFromForeground = true;

GermainAPM.collectApplicationExit(
    calledFromForeground
);

// Application-controlled exit logic

🐍 Kotlin

val calledFromForeground = true

GermainAPM.collectApplicationExit(
    calledFromForeground
)

// Application-controlled exit logic

Set the parameter to:

Call this method only for an actual application-controlled exit. Do not call it for ordinary activity destruction, configuration changes, navigation, or background transitions.

Android applications generally should not terminate their own processes during normal operation.

🚫 Removal from Recent Applications

Swiping an application from the recent-applications screen is not a reliable application-termination signal on modern Android versions.

Behavior varies by:

Do not depend on recent-task removal to calculate complete application uptime or guarantee delivery of a final event. The legacy listener intended for older Android releases should not be presented as a supported solution for applications targeting current Android SDK versions.

🌟 Add Custom Business Events

System and lifecycle events describe application context. Add custom events or transactions for activities that have business meaning, such as:

Use transactions instead of events when duration, completion, or failure must be measured.

Keep event names stable and store dynamic information in approved attributes rather than generating a unique event name for every occurrence.

📈 Analyze Events

Use GermainUX dashboards to analyze events by:

Event context can help determine whether failures are concentrated around network changes, memory pressure, background transitions, particular devices, or application releases.

🔔 Alerts

Configure alerts only for events that require action, such as:

Most lifecycle and system events are informational and should be analyzed rather than individually alerted on.

🔒 Privacy and Permissions

Before enabling system-event monitoring:

Android permission approval does not automatically make data collection appropriate. Apply the organization’s privacy and security requirements independently.

✅ Validation

Test event monitoring on supported Android versions and representative devices:

1. Launch the application.

2. Move it between foreground and background.

3. Trigger an approved configuration change.

4. Connect and disconnect the device from power.

5. Change network state where safe.

6. Simulate a low-memory callback in a test environment.

7. Execute an application-controlled exit if the application supports one.

8. Confirm that each event reaches GermainUX.

9. Verify application, session, device, and version context.

10. Confirm that restricted or unnecessary data is not collected.

Do not validate production behavior based on a single emulator or Android version.

🐛 Troubleshooting

🔍 System events are missing

Verify that:

⌛ Application uptime has no final value

The application process may have been terminated without a final callback. This is expected behavior on Android and cannot always be prevented.

Use session, foreground, and background telemetry for usage analysis when no reliable application-exit event is available.

🔁 Duplicate lifecycle events appear

Confirm that:

📱 An event works on one device but not another

Compare:

ℹ️ Get More Information

GermainUX can help determine which monitoring, analytics and automation capabilities are appropriate for your Android App environment.

Contact GermainUX Support.