Deep Linking in XML-Based Apps

Deep linking is a technique that allows users to directly navigate to a specific screen or content within a mobile application from an external source, such as a web page, email, or another application. While deep linking is a common feature in modern Android development with frameworks like Jetpack Navigation, it can also be implemented effectively in traditional XML-based Android apps.

What is Deep Linking?

Deep linking provides a seamless user experience by bypassing the app’s home screen and directly navigating users to the content they’re interested in. This is achieved by registering specific URIs or intent filters within the Android app that define how external links are handled.

Why Use Deep Linking?

• Enhanced User Experience: Directs users to specific content within the app.
• Improved Engagement: Facilitates sharing and promotion of in-app content.
• Seamless Navigation: Eliminates the need for users to manually navigate through the app.

How to Implement Deep Linking in XML-Based Android Apps

Implementing deep linking involves configuring intent filters in your AndroidManifest.xml file and handling the incoming intents in your Activities.

Step 1: Configure Intent Filters in AndroidManifest.xml

Define intent filters within the <activity> tags of your manifest file. These filters specify the types of URIs or intents that your activity can handle.

<activity
    android:name=".DeepLinkActivity"
    android:exported="true">
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />

        <data
            android:scheme="example"
            android:host="app.example.com"
            android:pathPrefix="/content" />
    </intent-filter>
</activity>

In this configuration:

• android.intent.action.VIEW indicates that this activity can display data.
• android.intent.category.DEFAULT is required for activities that are launched in response to an intent.
• android.intent.category.BROWSABLE allows the activity to be launched from a browser.
• The <data> tag specifies the URI schema, host, and path that the activity can handle.
  • android:scheme="example" specifies the URI scheme (e.g., example://).
  • android:host="app.example.com" specifies the host name.
  • android:pathPrefix="/content" specifies the path prefix.

With this configuration, the activity will handle URIs like example://app.example.com/content/item123.

Step 2: Handle Incoming Intents in Your Activity

In your Activity, retrieve the data from the incoming intent and navigate to the appropriate content within your app.

import android.app.Activity;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.widget.TextView;

public class DeepLinkActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_deep_link);

        TextView textView = findViewById(R.id.deepLinkTextView);

        Intent intent = getIntent();
        Uri data = intent.getData();

        if (data != null) {
            String path = data.getPath();
            String itemId = path.replace("/content/", "");

            textView.setText("Item ID: " + itemId);
        } else {
            textView.setText("No deep link data found.");
        }
    }
}

In this example:

• The activity retrieves the Intent using getIntent().
• It extracts the Uri from the intent using getData().
• It parses the path to extract the item ID and updates a TextView to display it.

Step 3: Creating a Layout (activity_deep_link.xml)

For the above activity you’ll need a simple layout, something like this:

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".DeepLinkActivity">

    <TextView
        android:id="@+id/deepLinkTextView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Deep Link Data Here"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"/>

</androidx.constraintlayout.widget.ConstraintLayout>

Testing Deep Linking

You can test your deep linking implementation using the adb command or by creating a link in a web page and opening it on an Android device.

Using adb:

adb shell am start -W -a android.intent.action.VIEW -d "example://app.example.com/content/item123" your.package.name

Replace example://app.example.com/content/item123 with your deep link URL and your.package.name with your app’s package name.

Creating a Web Link:

Create a simple HTML page with a link to your deep link URL:

<html>
<body>
    <a href="example://app.example.com/content/item123">Open App</a>
</body>
</html>

Open this HTML page on an Android device, and clicking the link should direct you to the specified activity in your app.

Handling Multiple Schemes and Hosts

Your app can handle multiple schemes and hosts by adding multiple <data> elements within the same <intent-filter>.

<activity
    android:name=".DeepLinkActivity"
    android:exported="true">
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />

        <data android:scheme="example"
              android:host="app.example.com" />
        <data android:scheme="https"
              android:host="www.example.com"
              android:pathPrefix="/app" />
    </intent-filter>
</activity>

In this example, the activity can handle both example://app.example.com and https://www.example.com/app.

Best Practices

• Handle Edge Cases: Ensure your app handles cases where the deep link is invalid or the content does not exist.
• Provide Fallback: Offer a fallback mechanism to navigate users to a relevant part of the app if the deep link fails.
• Secure Your Deep Links: If handling sensitive information, ensure that your deep links are secure to prevent malicious exploitation.

Conclusion

Deep linking is a valuable feature for directing users to specific content within your Android app from external sources. By configuring intent filters in the AndroidManifest.xml file and handling incoming intents in your Activities, you can seamlessly integrate deep linking into your XML-based Android applications, enhancing user experience and engagement. Properly implementing deep linking allows for direct navigation to content, streamlined user journeys, and more effective promotion of your app’s features.