Follow a link in Android Studio: from basic Intent to Deep Link

Developing mobile applications on Android often requires organizing transitions between screens, external resources, or even other applications. One of the key scenarios is link processing: be it opening a web page in a browser, navigating to a specific screen within an application, or integrating with Deep Link for marketing campaigns. Without the correct implementation of these mechanisms, the user experience suffers, and the application loses functionality.

In this article we will analyze 5 ways to organize clicks on links in Android Studio - from the simplest Intent for opening a URL in the browser to complex schemes with PendingIntent and dynamic links Firebase. We will pay special attention to typical errors (for example, android.content.ActivityNotFoundException), code optimization for performance, and the nuances of working with Android 12+, where security policies have become more stringent. If you are just starting to develop software Android or want to systematize your knowledge, this guide will help you avoid pitfalls.

1. Basic transition: opening a link in a browser

The easiest way is to redirect the user to a web page through the device's standard browser. For this purpose it is used Intent.ACTION_VIEW with a URI parameter. This method is suitable for external links (for example, to a support site, terms of use or social networks).

Example code for a button in Activity:

val url = "https://example.com"
val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
startActivity(intent)

It is important to consider two points:

• 🔹 Checking browser availability: before calling startActivity check whether there is an application on the device that can handle Intent, otherwise the application will crash with an error. Use intent.resolveActivity(packageManager) != null.
• 🔹 HTTPS vs HTTP: starting from Android 9 (API 28), insecure connections (HTTP) are blocked by default. If your link does not support HTTPS, add android:usesCleartextTraffic="true" to AndroidManifest.xml.

⚠️ Attention: If your application targets Android 12 (API 31) and above, working with Intent to external resources may require a declaration <queries> in the manifest. For example, to open links in Chrome add:

<queries>
<intent>
<action android:name="android.intent.action.VIEW" />
<data android:scheme="https" />
</intent>
</queries>

2. Switching between screens within the application

If you need to open another screen (for example, a user profile or product details) by clicking on a link in the text or a button, use explicit Intent (Explicit Intent). This method is suitable for navigation within one application.

Example of transition from MainActivity to DetailActivity:

val intent = Intent(this, DetailActivity::class.java)
intent.putExtra("KEY_ID", 123) // Data transfer
startActivity(intent)

To process links in the text (for example, in TextView) use android:text="User profile" and configure the handler:

textView.movementMethod = LinkMovementMethod.getInstance()
textView.setOnClickListener {
val uri = Uri.parse("detail://user/123")
if (uri.scheme == "detail" && uri.host == "user") {
val intent = Intent(this, ProfileActivity::class.java)
intent.putExtra("USER_ID", uri.lastPathSegment?.toInt())
startActivity(intent)
}
}

• 📌 Data transfer: use putExtra to pass primitives or Parcelable for complex objects. Avoid transferring large data through Intent as this may lead to TransactionTooLargeException.
• 🔄 Processing the result: if you need to get data back (for example, after editing a profile), use startActivityForResult (obsolete since API 30) or Activity Result API.

3. Deep Link: following custom links

Deep Link allows you to open specific screens of your application using universal links (for example, myapp://product/42 or https://example.com/product/42). This is critical for marketing campaigns, push notifications and integration with other services.

To configure Deep Link:

1. Add intent-filter to AndroidManifest.xml for target Activity:

   <activity android:name=".DetailActivity">
   <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:host="example.com"
   android:pathPrefix="/product"
   android:scheme="https" />
   </intent-filter>
   </activity>

2. Process incoming Intent in Activity:

   override fun onCreate(savedInstanceState: Bundle?) {
   super.onCreate(savedInstanceState)
   handleIntent(intent)
   }
   
   override fun onNewIntent(intent: Intent?) {
   super.onNewIntent(intent)
   handleIntent(intent)
   }
   
   private fun handleIntent(intent: Intent?) {
   val data = intent?.data
   if (data != null && data.pathSegments.size > 1) {
   val productId = data.lastPathSegment
   // Load data for productId
   }
   }

⚠️ Attention: Starting from Android 12 (API 31), to work with Android App Links requires signing with a digital certificate and confirmation of domain ownership via Digital Asset Links. Without this, the system will not trust your links.

4. Firebase Dynamic Links: universal links

Firebase Dynamic Links is a solution from Googlethat allows you to create "smart" links that work in any scenario:

• 🔗 If the application is installed, it opens a specific screen.
• 🌐 If the application is not installed, it redirects to Play Market or to a web page.
• 📱 Supports delayed deep linking (for example, after installing an application).

An example of creating a dynamic link:

val dynamicLink = Firebase.dynamicLinks.dynamicLink {
link = Uri.parse("https://example.com/product/42")
domainUriPrefix = "https://myapp.page.link"
androidParameters("com.example.app") {
minimumVersion = 123
}
socialMetaTagParameters {
title = "Check out this product!"
description = "50% off today only"
imageUrl = Uri.parse("https://example.com/image.png")
}
}

val dynamicLinkUri = dynamicLink.uri
// Send a dynamicLinkUri to the user (for example, in a push notification)

To process an incoming link in the application:

FirebaseDynamicLinks.getInstance()
.getDynamicLink(intent)
.addOnSuccessListener { pendingDynamicLinkData ->
val deepLink = pendingDynamicLinkData?.link
if (deepLink != null) {
// Process a deepLink (for example, retrieve productId)
}
}

5. Handling links in WebView

If your application uses WebView to display content, you may want to intercept link clicks and process them within the application (for example, open some URLs in WebViewand others in the browser or deep links).

Example settings WebViewClient:

webView.webViewClient = object : WebViewClient() {
override fun shouldOverrideUrlLoading(view: WebView?, request: WebResourceRequest?): Boolean {
val url = request?.url.toString()
return when {
url.startsWith("https://example.com/") -> {
// Open in WebView
false
}
url.startsWith("myapp://") -> {
// Process as Deep Link
val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
startActivity(intent)
true
}
else -> {
// Open in browser
val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
startActivity(intent)
true
}
}
}
}

Important nuances:

• 🛡️ Security: always check the URL before processing to avoid Open Redirect type vulnerabilities (for example, when an attacker replaces a link to a phishing site).
• 🔄 Navigation back: if WebView supports history, implement processing of the "Back" button through webView.canGoBack().

6. Typical errors and their solutions

When working with link transitions, developers often encounter the following problems:

Another common problem is incorrect processing of links in Android 11+. Starting API 30, access to files and packages of other applications is limited. If your link leads to a local file (for example, file:///storage/emulated/0/...), use FileProvider or MediaStore API.

val intent = Intent(Intent.ACTION_VIEW, Uri.parse("myapp://test"))
val activities = packageManager.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY)
val isSupported = activities.isNotEmpty()

val intent = Intent(Intent.ACTION_VIEW, Uri.parse("https://example.com"))
intent.setPackage("com.android.chrome") // Chrome package
startActivity(intent)

class SharedViewModel : ViewModel() {
private val _data = MutableLiveData<String>()
val data: LiveData<String> = _data

fun setData(value: String) {
_data.value = value
}
}

// In the first Activity:
viewModel.setData("Hello");

// In the second Activity:
viewModel.data.observe(this) { value ->
textView.text = value
}