'Android TextView with Clickable Links: how to capture clicks?
I have a TextView which is rendering basic HTML, containing 2+ links. I need to capture clicks on the links and open the links -- in my own internal WebView (not in the default browser.)
The most common method to handle link rendering seems to be like this:
String str_links = "<a href='http://google.com'>Google</a><br /><a href='http://facebook.com'>Facebook</a>";
text_view.setLinksClickable(true);
text_view.setMovementMethod(LinkMovementMethod.getInstance());
text_view.setText( Html.fromHtml( str_links ) );
However, this causes the links to open in the default internal web browser (showing the "Complete Action Using..." dialog).
I tried implementing a onClickListener, which properly gets triggered when the link is clicked, but I don't know how to determine WHICH link was clicked...
text_view.setOnClickListener(new OnClickListener(){
public void onClick(View v) {
// what now...?
}
});
Alternatively, I tried creating a custom LinkMovementMethod class and implementing onTouchEvent...
public boolean onTouchEvent(TextView widget, Spannable text, MotionEvent event) {
String url = text.toString();
// this doesn't work because the text is not necessarily a URL, or even a single link...
// eg, I don't know how to extract the clicked link from the greater paragraph of text
return false;
}
Ideas?
Example solution
I came up with a solution which parses the links out of a HTML string and makes them clickable, and then lets you respond to the URL.
Solution 1:[1]
Based upon another answer, here's a function setTextViewHTML() which parses the links out of a HTML string and makes them clickable, and then lets you respond to the URL.
protected void makeLinkClickable(SpannableStringBuilder strBuilder, final URLSpan span)
{
int start = strBuilder.getSpanStart(span);
int end = strBuilder.getSpanEnd(span);
int flags = strBuilder.getSpanFlags(span);
ClickableSpan clickable = new ClickableSpan() {
public void onClick(View view) {
// Do something with span.getURL() to handle the link click...
}
};
strBuilder.setSpan(clickable, start, end, flags);
strBuilder.removeSpan(span);
}
protected void setTextViewHTML(TextView text, String html)
{
CharSequence sequence = Html.fromHtml(html);
SpannableStringBuilder strBuilder = new SpannableStringBuilder(sequence);
URLSpan[] urls = strBuilder.getSpans(0, sequence.length(), URLSpan.class);
for(URLSpan span : urls) {
makeLinkClickable(strBuilder, span);
}
text.setText(strBuilder);
text.setMovementMethod(LinkMovementMethod.getInstance());
}
Solution 2:[2]
I made an easy extension function in Kotlin to catch url link clicks in a TextView by applying a new callback to URLSpan elements.
strings.xml (example link in text)
<string name="link_string">this is my link: <a href="https://www.google.com/">CLICK</a></string>
Make sure your spanned text is set to the TextView before you call "handleUrlClicks"
textView.text = getString(R.string.link_string)
This is the extension function:
/**
* Searches for all URLSpans in current text replaces them with our own ClickableSpans
* forwards clicks to provided function.
*/
fun TextView.handleUrlClicks(onClicked: ((String) -> Unit)? = null) {
//create span builder and replaces current text with it
text = SpannableStringBuilder.valueOf(text).apply {
//search for all URL spans and replace all spans with our own clickable spans
getSpans(0, length, URLSpan::class.java).forEach {
//add new clickable span at the same position
setSpan(
object : ClickableSpan() {
override fun onClick(widget: View) {
onClicked?.invoke(it.url)
}
},
getSpanStart(it),
getSpanEnd(it),
Spanned.SPAN_INCLUSIVE_EXCLUSIVE
)
//remove old URLSpan
removeSpan(it)
}
}
//make sure movement method is set
movementMethod = LinkMovementMethod.getInstance()
}
This is how I call it:
textView.handleUrlClicks { url ->
Timber.d("click on found span: $url")
}
Solution 3:[3]
You've done as follows:
text_view.setMovementMethod(LinkMovementMethod.getInstance());
text_view.setText( Html.fromHtml( str_links ) );
have you tried in reverse order as shown below?
text_view.setText( Html.fromHtml( str_links ) );
text_view.setMovementMethod(LinkMovementMethod.getInstance());
and without:
text_view.setLinksClickable(true);
Solution 4:[4]
This can be simply solved by using Spannable String.What you really want to do (Business Requirement) is little bit unclear to me so following code will not give exact answer to your situation but i am petty sure that it will give you some idea and you will be able to solve your problem based on the following code.
As you do, i'm also getting some data via HTTP response and i have added some additional underlined text in my case "more" and this underlined text will open the web browser on click event.Hope this will help you.
TextView decription = (TextView)convertView.findViewById(R.id.library_rss_expan_chaild_des_textView);
String dec=d.get_description()+"<a href='"+d.get_link()+"'><u>more</u></a>";
CharSequence sequence = Html.fromHtml(dec);
SpannableStringBuilder strBuilder = new SpannableStringBuilder(sequence);
UnderlineSpan[] underlines = strBuilder.getSpans(0, 10, UnderlineSpan.class);
for(UnderlineSpan span : underlines) {
int start = strBuilder.getSpanStart(span);
int end = strBuilder.getSpanEnd(span);
int flags = strBuilder.getSpanFlags(span);
ClickableSpan myActivityLauncher = new ClickableSpan() {
public void onClick(View view) {
Log.e(TAG, "on click");
Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(d.get_link()));
mContext.startActivity(intent);
}
};
strBuilder.setSpan(myActivityLauncher, start, end, flags);
}
decription.setText(strBuilder);
decription.setLinksClickable(true);
decription.setMovementMethod(LinkMovementMethod.getInstance());
Solution 5:[5]
I've had the same problem but a lot of text mixed with few links and emails. I think using 'autoLink' is a easier and cleaner way to do it:
text_view.setText( Html.fromHtml( str_links ) );
text_view.setLinksClickable(true);
text_view.setAutoLinkMask(Linkify.ALL); //to open links
You can set Linkify.EMAIL_ADDRESSES or Linkify.WEB_URLS if there's only one of them you want to use or set from the XML layout
android:linksClickable="true"
android:autoLink="web|email"
The available options are: none, web, email, phone, map, all
Solution 6:[6]
Solution
I have implemented a small class with the help of which you can handle long clicks on TextView itself and Taps on the links in the TextView.
Layout
TextView android:id="@+id/text"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:autoLink="all"/>
TextViewClickMovement.java
import android.content.Context;
import android.text.Layout;
import android.text.Spannable;
import android.text.method.LinkMovementMethod;
import android.text.style.ClickableSpan;
import android.util.Patterns;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.widget.TextView;
public class TextViewClickMovement extends LinkMovementMethod {
private final String TAG = TextViewClickMovement.class.getSimpleName();
private final OnTextViewClickMovementListener mListener;
private final GestureDetector mGestureDetector;
private TextView mWidget;
private Spannable mBuffer;
public enum LinkType {
/** Indicates that phone link was clicked */
PHONE,
/** Identifies that URL was clicked */
WEB_URL,
/** Identifies that Email Address was clicked */
EMAIL_ADDRESS,
/** Indicates that none of above mentioned were clicked */
NONE
}
/**
* Interface used to handle Long clicks on the {@link TextView} and taps
* on the phone, web, mail links inside of {@link TextView}.
*/
public interface OnTextViewClickMovementListener {
/**
* This method will be invoked when user press and hold
* finger on the {@link TextView}
*
* @param linkText Text which contains link on which user presses.
* @param linkType Type of the link can be one of {@link LinkType} enumeration
*/
void onLinkClicked(final String linkText, final LinkType linkType);
/**
*
* @param text Whole text of {@link TextView}
*/
void onLongClick(final String text);
}
public TextViewClickMovement(final OnTextViewClickMovementListener listener, final Context context) {
mListener = listener;
mGestureDetector = new GestureDetector(context, new SimpleOnGestureListener());
}
@Override
public boolean onTouchEvent(final TextView widget, final Spannable buffer, final MotionEvent event) {
mWidget = widget;
mBuffer = buffer;
mGestureDetector.onTouchEvent(event);
return false;
}
/**
* Detects various gestures and events.
* Notify users when a particular motion event has occurred.
*/
class SimpleOnGestureListener extends GestureDetector.SimpleOnGestureListener {
@Override
public boolean onDown(MotionEvent event) {
// Notified when a tap occurs.
return true;
}
@Override
public void onLongPress(MotionEvent e) {
// Notified when a long press occurs.
final String text = mBuffer.toString();
if (mListener != null) {
Log.d(TAG, "----> Long Click Occurs on TextView with ID: " + mWidget.getId() + "\n" +
"Text: " + text + "\n<----");
mListener.onLongClick(text);
}
}
@Override
public boolean onSingleTapConfirmed(MotionEvent event) {
// Notified when tap occurs.
final String linkText = getLinkText(mWidget, mBuffer, event);
LinkType linkType = LinkType.NONE;
if (Patterns.PHONE.matcher(linkText).matches()) {
linkType = LinkType.PHONE;
}
else if (Patterns.WEB_URL.matcher(linkText).matches()) {
linkType = LinkType.WEB_URL;
}
else if (Patterns.EMAIL_ADDRESS.matcher(linkText).matches()) {
linkType = LinkType.EMAIL_ADDRESS;
}
if (mListener != null) {
Log.d(TAG, "----> Tap Occurs on TextView with ID: " + mWidget.getId() + "\n" +
"Link Text: " + linkText + "\n" +
"Link Type: " + linkType + "\n<----");
mListener.onLinkClicked(linkText, linkType);
}
return false;
}
private String getLinkText(final TextView widget, final Spannable buffer, final MotionEvent event) {
int x = (int) event.getX();
int y = (int) event.getY();
x -= widget.getTotalPaddingLeft();
y -= widget.getTotalPaddingTop();
x += widget.getScrollX();
y += widget.getScrollY();
Layout layout = widget.getLayout();
int line = layout.getLineForVertical(y);
int off = layout.getOffsetForHorizontal(line, x);
ClickableSpan[] link = buffer.getSpans(off, off, ClickableSpan.class);
if (link.length != 0) {
return buffer.subSequence(buffer.getSpanStart(link[0]),
buffer.getSpanEnd(link[0])).toString();
}
return "";
}
}
}
Usage
String str_links = "<a href='http://google.com'>Google</a><br /><a href='http://facebook.com'>Facebook</a>";
text_view.setText( Html.fromHtml( str_links ) );
text_view.setMovementMethod(new TextViewClickMovement(this, context));
Links
Hope this helops! You can find code here.
Solution 7:[7]
A way cleaner and better solution, using native's Linkify library.
Example:
Linkify.addLinks(mTextView, Linkify.ALL);
Solution 8:[8]
If you're using Kotlin, I wrote a simple extension for this case:
/**
* Enables click support for a TextView from a [fullText] String, which one containing one or multiple URLs.
* The [callback] will be called when a click is triggered.
*/
fun TextView.setTextWithLinkSupport(
fullText: String,
callback: (String) -> Unit
) {
val spannable = SpannableString(fullText)
val matcher = Patterns.WEB_URL.matcher(spannable)
while (matcher.find()) {
val url = spannable.toString().substring(matcher.start(), matcher.end())
val urlSpan = object : URLSpan(fullText) {
override fun onClick(widget: View) {
callback(url)
}
}
spannable.setSpan(urlSpan, matcher.start(), matcher.end(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
}
text = spannable
movementMethod = LinkMovementMethod.getInstance() // Make link clickable
}
Usage:
yourTextView.setTextWithLinkSupport("click on me: https://www.google.fr") {
Log.e("URL is $it")
}
Solution 9:[9]
An alternative, imho way simpler approach (for lazy developers like myself ;)
abstract class LinkAwareActivity : AppCompatActivity() {
override fun startActivity(intent: Intent?) {
if(Intent.ACTION_VIEW.equals(intent?.action) && onViewLink(intent?.data.toString(), intent)){
return
}
super.startActivity(intent)
}
// return true to consume the link (meaning to NOT call super.startActivity(intent))
abstract fun onViewLink(url: String?, intent: Intent?): Boolean
}
If required, you could also check for scheme / mimetype of the intent
Solution 10:[10]
Im using only textView, and set span for url and handle click.
I found very elegant solution here, without linkify - according to that I know which part of string I want to linkify
handle textview link click in my android app
in kotlin:
fun linkify(view: TextView, url: String, context: Context) {
val text = view.text
val string = text.toString()
val span = ClickSpan(object : ClickSpan.OnClickListener {
override fun onClick() {
// handle your click
}
})
val start = string.indexOf(url)
val end = start + url.length
if (start == -1) return
if (text is Spannable) {
text.setSpan(span, start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
text.setSpan(ForegroundColorSpan(ContextCompat.getColor(context, R.color.orange)),
start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
} else {
val s = SpannableString.valueOf(text)
s.setSpan(span, start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
s.setSpan(ForegroundColorSpan(ContextCompat.getColor(context, R.color.orange)),
start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
view.text = s
}
val m = view.movementMethod
if (m == null || m !is LinkMovementMethod) {
view.movementMethod = LinkMovementMethod.getInstance()
}
}
class ClickSpan(private val mListener: OnClickListener) : ClickableSpan() {
override fun onClick(widget: View) {
mListener.onClick()
}
interface OnClickListener {
fun onClick()
}
}
and usage: linkify(yourTextView, urlString, context)
Solution 11:[11]
You can do it more neatly using a simple library named Better-Link-Movement-Method.
TextView mTvUrl=findViewById(R.id.my_tv_url);
mTvUrl.setMovementMethod(BetterLinkMovementMethod.newInstance().setOnLinkClickListener((textView, url) -> {
if (Patterns.WEB_URL.matcher(url).matches()) {
//An web url is detected
return true;
}
else if(Patterns.PHONE.matcher(url).matches()){
//A phone number is detected
return true;
}
else if(Patterns.EMAIL_ADDRESS.matcher(url).matches()){
//An email address is detected
return true;
}
return false;
}));
Solution 12:[12]
This page solved my problem, but I had to figure something out myself. I was using android string resources to set the text of the TextView and obviously, they returned a CharSequence that has a link in between the text.
These were the resources:
<string name="license_agreement">By registering, you agree with our <b><ahref="www.privacy-options.com">Privacy Policy</a></b> and <b><a href="www.terms-and-conditions.com">Terms and Conditions</a></b></string>
<string name="sign_now">Already have an account? <b><a href="@login_page">Login</a></b></string>
I made changes to one of the code suggested. The code:
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// ...
// Make Licence agreement statements and login text clickable links
setLinkOnText(binding.txtLcAgree);
setLinkOnText(binding.signNow);
}
private void detectLinkClick(SpannableStringBuilder strBuilder, final URLSpan span) {
int start = strBuilder.getSpanStart(span);
int end = strBuilder.getSpanEnd(span);
int flags = strBuilder.getSpanFlags(span);
ClickableSpan clickable = new ClickableSpan() {
public void onClick(View view) {
// Do something with links retrieved from span.getURL(), to handle link click...
String clickedUrl = span.getURL();
switch (clickedUrl) {
case "@login_page":
startActivity(new Intent(RegistrationActivity.this, LoginActivity.class));
break;
case "http://www.privacy-options.com":
Uri link1 = Uri.parse("http://www.privacy-options.com");
startActivity(new Intent(Intent.ACTION_VIEW, link1));
break;
case "http://www.terms-and-conditions.com":
Uri link2 = Uri.parse("http://www.terms-and-conditions.com");
startActivity(new Intent(Intent.ACTION_VIEW, link2));
break;
default:
Log.w(getClass().getSimpleName(), "No action for this");
}
}
};
strBuilder.setSpan(clickable, start, end, flags);
strBuilder.removeSpan(span);
}
protected void setLinkOnText(TextView text) {
CharSequence sequence = text.getText();
SpannableStringBuilder strBuilder = new SpannableStringBuilder(sequence);
URLSpan[] urls = strBuilder.getSpans(0, sequence.length(), URLSpan.class);
for (URLSpan span : urls) {
detectLinkClick(strBuilder, span);
}
text.setText(strBuilder);
text.setMovementMethod(LinkMovementMethod.getInstance());
}
The links retrieved from span.getUrl() was the initial link I set in the string resource. And since the text in the TextView was already in link format, I just simply used that text in the SpannableStringBuilder.
Solution 13:[13]
For The amazing answer by Zane Claes on top. Simply add the below code before calling strBuilder.getSpans() works great for me.
Linkify.addLinks(strBuilder, Linkify.ALL)
Sources
This article follows the attribution requirements of Stack Overflow and is licensed under CC BY-SA 3.0.
Source: Stack Overflow