Android integration

This section describes the process of integrating PLuG using the DevRev SDK with your Android app.

Requirements

• Android Studio 2022.1.1 or later
• Android Gradle plugin version 7.4 or later
• Gradle version 7.6 or later
• Minimum Android SDK 24

Integration

To integrate the latest version of our SDK into your app, follow these steps:

Set up the DevRev SDK

1. In DevRev, go to Settings > PLuG settings to obtain Your unique App ID (referred to as supportID in the code).
2. After obtaining the credentials, you can configure the DevRev SDK in your app. The SDK will be ready for use once you execute the configuration method.

1
DevRev.configure(context: Context, appId: String)

3. To configure the SDK, you need to call the following method inside your Application class:

1
import ai.devrev.sdk.DevRev
2
3
class MyApp : Application() {
4
5
    override fun onCreate() {
6
        super.onCreate()
7
        DevRev.configure(
8
            context = this,
9
            appId = "<APP_ID>"
10
        )
11
    }
12
}

4. In the onCreate method of your Application, configure the DevRev SDK with the required parameters using the credentials obtained earlier.

5. Ensure that the custom application is specified in the AndroidManifest.xml, as shown below:

   1
   <application
   2
       android:name=".ExampleApplication">
   3
   </application>

Identification

To use certain features of the DevRev SDK, user identification is required. You can select from the following methods to identify users within your application:

Anonymous identification

The anonymous identification method allows you to create an anonymous user with an optional or random user identifier, ensuring that no other data is stored or associated with the user.

1
DevRev.identifyAnonymousUser(
2
    userId: String
3
)

Unverified identification

The unverified identification method identifies users with a unique identifier, but it does not verify their identity with the DevRev backend.

1
DevRev.identifyUnverifiedUser(
2
    identity: Identity
3
)

The function accepts the Identity object, where the user identifier (userId) is the only required property; all other properties are optional.

For example:

1
// Identify an unverified user using their email address as the user identifier.
2
DevRev.identifyUnverifiedUser(Identity(userId = "user@example.org"))

Update user information

To update a user’s information, use the following method:

1
DevRev.updateUser(
2
 identity: Identity
3
)

The function accepts the DevRev.Identity ojbect.

PLuG support chat

Once user identification is complete, you can start using the chat (conversations) dialog supported by our DevRev SDK. To open the chat dialog, your application should use the showSupport API, as shown in the following example:

1
DevRev.showSupport(context: Context)

The DevRev SDK also provides a support button, which can be integrated into your application. To include it on the current screen, add the following code to your XML layout:

1
<ai.devrev.sdk.plug.view.PlugFloatingActionButton
2
    android:id="@+id/plug_fab"
3
    android:layout_width="wrap_content"
4
    android:layout_height="wrap_content"
5
    android:layout_margin="24dp"
6
    app:layout_constraintBottom_toBottomOf="parent"
7
    app:layout_constraintEnd_toEndOf="parent" />

The support button can be customized using default parameters, enabling you to tailor its appearance to your application’s design.

1
android:src="@your_drawable_here"

and

1
android:backgroundTint="@your_background_color"

At this stage, your app is fully configured to utilize all functionalities of the DevRev PLuG SDK. Pressing the support button directs the user to the chat interface, enabling effective interaction and support.

Analytics

The DevRev SDK allows you to send custom analytic events by using a name and a string hashmap. You can track these events using the following function:

1
DevRev.trackEvent(name: String, properties: HashMap<String, String>)

For example:

1
DevRev.trackEvent(name = "open-message-screen", properties = {"id": "message-1337"})

Session analytics

The DevRev SDK offers session analytics features to help you understand how users interact with your app.

Opt in or out

End users can opt in or out of the session analytics feature, enabling them to control whether their interactions are tracked for analytics.

1
DevRev.stopAllMonitoring()

This method terminates and deletes the current session recording and also disables future session recording by our SDK for this user.

1
DevRev.resumeAllMonitoring()

If session recording was disabled for the user using the stopAllMonitoring() method, you can enable recording at runtime with this method.

Session recording

You can enable session recording to capture user interactions with your app.

Here are the available methods to help you control the session recording feature:

Session properties

You can add custom properties to the session recording to help you understand the context of the session. The properties are defined as a hashmap of string values.

1
DevRev.addSessionProperties(properties: HashMap<String, Any>)

To clear the session properties in scenarios such as user logout or when the session ends, use the following method:

1
DevRev.clearSessionProperties()

Timers

The DevRev SDK offers a timer mechanism to measure the time spent on specific tasks, allowing you to track events such as response time, loading time, or any other duration-based metrics.

The mechanism utilizes balanced start and stop methods, both of which accept a timer name and an optional hashmap of properties.

To start a timer, use the following method:

1
DevRev.startTimer(name: String, properties: HashMap<String, String>)

To stop a timer, use the following method:

1
DevRev.endTimer(name: String, properties: HashMap<String, String>)

For example:

1
DevRev.startTimer("response-time", properties: {"id": "task-1337"})
2
3
// Perform the task that you want to measure.
4
5
DevRev.endTimer("response-time", properties: {"id": "task-1337"})

Screen tracking

The DevRev SDK offers automatic screen tracking to help you understand how users navigate through your app. Although activities are automatically tracked, you can manually track screens or fragments using the following method:

1
DevRev.trackScreenName(screenName: String)

For example:

1
DevRev.trackScreenName("profile-screen")

Push notifications

You can configure your app to receive push notifications from the DevRev SDK. The SDK is designed to handle push notifications and execute actions based on the notification’s content.

DevRev sends push notifications to your app to alert users about new messages in the PLuG support chat.

To receive push notifications, you need to configure your DevRev organization by following the instructions in the push notifications section.

You need to ensure that your Android app is configured to receive push notifications. To set it up, follow the Firebase documentation.

Register for push notifications

The DevRev SDK offers a method to register your device for receiving push notifications. You can register for push notifications using the following method:

1
DevRev.registerDeviceToken(
2
  context: Context,
3
  deviceId: String,
4
  deviceToken: String
5
)

The method requires a device identifier that persists across device restarts and app launches. This could be a Firebase installation ID, Android ID, or a unique system identifier. To obtain the device token for Firebase Cloud Messaging, follow these steps:

1. Use the FirebaseMessaging object.
2. Call the firebaseMessaging.token.await() method.

This method will generate and return the device token.

1
val firebaseMessaging = FirebaseMessaging.getInstance()
2
val token = firebaseMessaging.token.await()
3
// Use the token as needed

Unregister from push notifications

If your app no longer needs to receive push notifications, you can unregister the device.

Use the following method to unregister the device:

1
DevRev.unregisterDevice(
2
  context: Context, 
3
  deviceId: String
4
)

The method requires the device identifier, which should be the same as the one used when registering the device.

Handle push notifications

The DevRev SDK currently does not support automatic handling of push notifications. To open the PLuG chat and manage navigation internally, you must pass the message payload received in the notification to the SDK.

1
DevRev.processPushNotification(
2
    context: Context,
3
    userInfo: String
4
)

To extract the notification payload, do the following:

1. In Firebase Cloud Messaging (FCM), when a push notification is received, it triggers the onMessageReceived function in your FirebaseMessagingService class.

2. This function receives a RemoteMessage object as a parameter, which contains the notification data.

3. The RemoteMessage object has a data property, which is a map containing key-value pairs of the notification payload.

4. To extract a specific piece of data from the payload, use the key to access the value in the data map.

5. To retrieve the “message” from the payload:

1
val message = remoteMessage.data["message"]

For example:

1
class MyFirebaseMessagingService: FirebaseMessagingService {
2
    // ...
3
  
4
    override fun onMessageReceived(remoteMessage: RemoteMessage) {
5
        // ...
6
        val messageData = remoteMessage.data["message"]
7
        DevRev.processPushNotification(messageData)
8
    }
9
}

Troubleshooting

• Issue: Encountering problems with DevRev SDK integration.
  Solution: Verify the correct SDK dependency setup in the project. Ensure mavenCentral is accessible from the IDE, and confirm accurate detection of the selected DevRev PLuG SDK version.

• Issue: The showSupport() function or XML button is unresponsive.
  Solution: Confirm that user identification is performed before using the showSupport() function or XML button.

• Issue: Incorrect operation due to App ID and secret misconfiguration.
  Solution: Ensure correct functionality by double-checking that both App ID and secret values are accurately configured in your application or sample app.