पाठ दृश्य के भाग को कैसे सेट करें क्लिक करने योग्य है


213

मेरे पास " एंड्रॉइड एक सॉफ्टवेयर स्टैक " पाठ है । इस पाठ में मैं " स्टैक " पाठ सेट करना चाहता हूँ क्लिक करने योग्य है। इस अर्थ में कि अगर आप उस पर क्लिक करते हैं तो यह एक नई गतिविधि (ब्राउज़र में नहीं) पर रीडायरेक्ट होगा।

मैंने कोशिश की लेकिन मुझे नहीं मिल रहा है।


12
"मैंने कोशिश की, लेकिन मुझे नहीं मिल रहा है" मैं जानना चाहूंगा कि आपने क्या प्रयास किया और आप कहां असफल रहे
रश्मि

जवाबों:


535

android.text.style.ClickableSpan आपकी समस्या को हल कर सकता है।

SpannableString ss = new SpannableString("Android is a Software stack");
ClickableSpan clickableSpan = new ClickableSpan() {
    @Override
    public void onClick(View textView) {
        startActivity(new Intent(MyActivity.this, NextActivity.class));
    }
    @Override
    public void updateDrawState(TextPaint ds) {
        super.updateDrawState(ds);
        ds.setUnderlineText(false);
    }
};
ss.setSpan(clickableSpan, 22, 27, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);

TextView textView = (TextView) findViewById(R.id.hello);
textView.setText(ss);
textView.setMovementMethod(LinkMovementMethod.getInstance());
textView.setHighlightColor(Color.TRANSPARENT);

XML में:

<TextView 
  ...
  android:textColorLink="@drawable/your_selector"
/>

2
क्या आप एक क्लिकव्यू में कई ClickableSpan ऑब्जेक्ट सेट कर सकते हैं?
जोनाथन

4
हाँ, आप कई क्लिक करने योग्य स्पैन को सेट करने योग्य स्ट्रिंग में सेट कर सकते हैं।
degratnik

15
रंग को नीले रंग में बदलने के लिए, आप जोड़ सकते हैं: ForegroundColorSpan fcs = new ForegroundColorSpan(Color.BLUE); ss.setSpan(fcs, 22, 27, Spannable.SPAN_INCLUSIVE_INCLUSIVE);
xemacobra

4
यह मेरे मामले में हुआ, रंग को नीले से दूसरे में बदलने के लिए। सेट ForegroundColorSpanमें setSpan के बाद आप क्लिक करने योग्य अवधि निर्धारित किया है। क्लिक करने योग्य समय से पहले फोरग्राउंड रखने पर, नया रंग परिलक्षित नहीं होगा।
शुभम ए।

1
इस लाइन के लिए धन्यवाद stextView.setMovementMethod (LinkMovementMethod.getInstance ()); textView.setHighlightColor (Color.TRANSPARENT);
Sasuke Uchiha

99

अंदर कई लिंक बनाने के लिए मेरा कार्य TextView

fun TextView.makeLinks(vararg links: Pair<String, View.OnClickListener>) {
    val spannableString = SpannableString(this.text)
    for (link in links) {
        val clickableSpan = object : ClickableSpan() {
            override fun onClick(view: View) {
                Selection.setSelection((view as TextView).text as Spannable, 0)
                view.invalidate()
                link.second.onClick(view)
            }
        }
        val startIndexOfLink = this.text.toString().indexOf(link.first)
        spannableString.setSpan(clickableSpan, startIndexOfLink, startIndexOfLink + link.first.length,
                Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
    }
    this.movementMethod = LinkMovementMethod.getInstance() // without LinkMovementMethod, link can not click
    this.setText(spannableString, TextView.BufferType.SPANNABLE)
}

का उपयोग करते हुए

my_text_view.makeLinks(
        Pair("Terms of Service", View.OnClickListener {
            Toast.makeText(applicationContext, "Terms of Service Clicked", Toast.LENGTH_SHORT).show()
        }),
        Pair("Privacy Policy", View.OnClickListener {
            Toast.makeText(applicationContext, "Privacy Policy Clicked", Toast.LENGTH_SHORT).show()
        }))

एक्सएमएल

<TextView
    android:id="@+id/my_text_view"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Please accept Terms of Service and Privacy Policy"
    android:textColorHighlight="#f00" // background color when pressed
    android:textColorLink="#0f0"
    android:textSize="20sp" />

डेमो

संदर्भ

लिंक हाइलाइट चयन के लिए समाधान https://stackoverflow.com/a/19445108/5381331 पर जाएं


यह पूरी तरह से काम कर रहा है। लेकिन कुछ अजीब व्यवहार दिखाई दे रहा है। मेरे पास "नीति" के साथ एक पाठ है। जहां "।" क्लिक करने योग्य spannable द्वारा छोड़ दिया जाएगा। किसी को भी एक ही मुद्दा था? ""। यदि यह पाठ दृश्य का अंतिम वर्ण है तो केवल छोड़ दिया जाता है।
निखिल

महान समाधान, लेकिन किसी को ध्यान रखने की जरूरत है अगर तार का स्थानीयकरण (एकाधिक भाषा ऐप) हो
हिमांशु मोरी

धन्यवाद। यह बढ़िया काम कर रहा है। मैं बताना चाहता हूं कि अगर आप <string name = "string"> कुछ% 1 $ s संपादित करें </ string> जैसे स्वरूपित स्ट्रिंग सेट कर रहे हैं। % 1 $ s के स्थान पर जो भी आप चाहते हैं उसे पहले सेट करें और फिर मेकलिंक विधि को कॉल करें।
राजन मौर्य

क्या आप बता सकते हैं कि मैं इस फ़ंक्शन का उपयोग कैसे कर सकता हूं क्योंकि जब मैं आपके ऑनक्रिट विधि में सिर्फ पेस्ट कर रहा हूं तो यह त्रुटि दिखाता है।
ब्लैकबाइंड

1
@BlackBlind आपको कौन सी त्रुटि मिलती है? यदि यह आयात में कुछ त्रुटि है, तो कृपया इसे सही ढंग से आयात करें। इसके अलावा, आपको समारोह को ऑनक्रिएट में नहीं रखना चाहिए, इसे बाहर रखना चाहिए
फान वान

35

आप इस पोस्ट में वर्णित ClickableSpan का उपयोग कर सकते हैं

नमूना कोड:

TextView myTextView = new TextView(this);
String myString = "Some text [clickable]";
int i1 = myString.indexOf("[");
int i2 = myString.indexOf("]");
myTextView.setMovementMethod(LinkMovementMethod.getInstance());
myTextView.setText(myString, BufferType.SPANNABLE);
Spannable mySpannable = (Spannable)myTextView.getText();
ClickableSpan myClickableSpan = new ClickableSpan() {
   @Override
   public void onClick(View widget) { /* do something */ }
};
mySpannable.setSpan(myClickableSpan, i1, i2 + 1, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);

संदर्भ


thx @ImranRana, के लिए Upvoted startIndexऔर endIndexतर्क।
रवि वानीया जूल

12

आप नमूना कोड का उपयोग कर सकते हैं। आप ClickableSpan के बारे में विस्तार से जानना चाहते हैं। कृपया इस दस्तावेज़ की जाँच करें

  SpannableString myString = new SpannableString("This is example");

            ClickableSpan clickableSpan = new ClickableSpan() {
                    @Override
                    public void onClick(View textView) {
                        ToastUtil.show(getContext(),"Clicked Smile ");
                    }
                };

        //For Click
         myString.setSpan(clickableSpan,startIndex,lastIndex,Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)

        //For UnderLine
         myString.setSpan(new UnderlineSpan(),startIndex,lastIndex,0);

        //For Bold
        myString.setSpan(new StyleSpan(Typeface.BOLD),startIndex,lastIndex,0);

        //Finally you can set to textView. 

        TextView textView = (TextView) findViewById(R.id.txtSpan);
        textView.setText(myString);
        textView.setMovementMethod(LinkMovementMethod.getInstance());

10

मैंने इस सहायक विधि को उस स्थिति में बनाया जब किसी को एक स्ट्रिंग से शुरू और अंत स्थिति की आवश्यकता थी।

public static TextView createLink(TextView targetTextView, String completeString,
    String partToClick, ClickableSpan clickableAction) {

    SpannableString spannableString = new SpannableString(completeString);

    // make sure the String is exist, if it doesn't exist
    // it will throw IndexOutOfBoundException
    int startPosition = completeString.indexOf(partToClick);
    int endPosition = completeString.lastIndexOf(partToClick) + partToClick.length();

    spannableString.setSpan(clickableAction, startPosition, endPosition,
        Spanned.SPAN_INCLUSIVE_EXCLUSIVE);

    targetTextView.setText(spannableString);
    targetTextView.setMovementMethod(LinkMovementMethod.getInstance());

    return targetTextView;
}

और यहां बताया गया है कि आप इसका उपयोग कैसे करते हैं

private void initSignUp() {
    String completeString = "New to Reddit? Sign up here.";
    String partToClick = "Sign up";
    ClickableTextUtil
        .createLink(signUpEditText, completeString, partToClick,
            new ClickableSpan() {
                @Override
                public void onClick(View widget) {
                    // your action
                    Toast.makeText(activity, "Start Sign up activity",
                        Toast.LENGTH_SHORT).show();
                }

                @Override
                public void updateDrawState(TextPaint ds) {
                    super.updateDrawState(ds);
                    // this is where you set link color, underline, typeface etc.
                    int linkColor = ContextCompat.getColor(activity, R.color.blumine);
                    ds.setColor(linkColor);
                    ds.setUnderlineText(false);
                }
            });
}

यह बेहतर है क्योंकि यह स्थानीयकरण को ध्यान में रखता है
Hideeyes02

7
 t= (TextView) findViewById(R.id.PP1);

 t.setText(Html.fromHtml("<bThis is normal text </b>" +
                "<a href=\"http://www.xyz-zyyx.com\">This is cliclable text</a> "));
 t.setMovementMethod(LinkMovementMethod.getInstance());

2
क्या आप कृपया अपना उत्तर बता सकते हैं। स्पष्टीकरण के साथ उत्तर हमेशा बेहतर होते हैं। मैंने भी संपादित किया क्योंकि आपका कोड स्निपेट सही प्रारूप में नहीं था।
पोपेय

1
ऐसा लगता है कि लिंक वेब पेज के लिए होगा, ओपी के अनुरोध के अनुसार नहीं।
विलियम टी। मलार्ड

5

यहाँ क्लिक करने योग्य Kotlinभागों को बनाने की एक विधि दी गई है TextView:

private fun makeTextLink(textView: TextView, str: String, underlined: Boolean, color: Int?, action: (() -> Unit)? = null) {
    val spannableString = SpannableString(textView.text)
    val textColor = color ?: textView.currentTextColor
    val clickableSpan = object : ClickableSpan() {
        override fun onClick(textView: View) {
            action?.invoke()
        }
        override fun updateDrawState(drawState: TextPaint) {
            super.updateDrawState(drawState)
            drawState.isUnderlineText = underlined
            drawState.color = textColor
        }
    }
    val index = spannableString.indexOf(str)
    spannableString.setSpan(clickableSpan, index, index + str.length, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
    textView.text = spannableString
    textView.movementMethod = LinkMovementMethod.getInstance()
    textView.highlightColor = Color.TRANSPARENT
}

यह एक TextView के भीतर कई लिंक बनाने के लिए कई बार कहा जा सकता है:

makeTextLink(myTextView, str, false, Color.RED, action = { Log.d("onClick", "link") })
makeTextLink(myTextView, str1, true, null, action = { Log.d("onClick", "link1") })

3

फान वान लिन्ह के जवाब का कोटलिन संस्करण

कृपया ध्यान दें कि इसमें कुछ मामूली संशोधन हैं।

fun makeLinks(textView: TextView, links: Array<String>, clickableSpans: Array<ClickableSpan>) {
    val spannableString = SpannableString(textView.text)

    for (i in links.indices) {
        val clickableSpan = clickableSpans[i]
        val link = links[i]

        val startIndexOfLink = textView.text.indexOf(link)

        spannableString.setSpan(clickableSpan, startIndexOfLink, startIndexOfLink + link.length,
                Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
    }

    textView.movementMethod = LinkMovementMethod.getInstance()
    textView.setText(spannableString, TextView.BufferType.SPANNABLE)
}

fun setupClickableTextView() {
    val termsOfServicesClick = object : ClickableSpan() {
        override fun onClick(p0: View?) {
            Toast.makeText(applicationContext, "ToS clicked", Toast.LENGTH_SHORT).show()
        }
    }

    val privacyPolicyClick = object : ClickableSpan() {
        override fun onClick(p0: View?) {
            Toast.makeText(applicationContext, "PP clicked", Toast.LENGTH_SHORT).show()
        }
    }

    makeLinks(termsTextView, arrayOf("terms", "privacy policy"), arrayOf(termsOfServicesClick, privacyPolicyClick))
}

1

बोल्ड के लिए,

mySpannable.setSpan(new StyleSpan(Typeface.BOLD),termStart,termStop,Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);

1

मैं एक अलग दृष्टिकोण का सुझाव दूंगा जो मुझे लगता है कि कम कोड की आवश्यकता है और अधिक "स्थानीयकरण-अनुकूल" है।

यह मानते हुए कि आपकी गंतव्य गतिविधि को "एक्टिविटीस्टैक" कहा जाता है, AndroidManifest.xml में एक कस्टम स्कीम (उदाहरण के लिए "myappscheme") के साथ इसके लिए एक आशय फ़िल्टर को परिभाषित करें।

<activity
    android:name=".ActivityStack">
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <data android:host="stack"/>
        <data android:scheme="myappscheme" />
    </intent-filter>
</activity>

बिना किसी विशेष टैग के TextView को परिभाषित करें ("android: autoLink" टैग का उपयोग न करना महत्वपूर्ण है, देखें: https://stackoverflow.com/a/20647011/1699702 ):

<TextView
    android:id="@+id/stackView"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@string/stack_string" />

फिर कस्टम स्कीम के लिंक का उपयोग करें और टेक्स्ट व्यू के पाठ में होस्ट करें (जैसे String.xml में):

<string name="stack_string">Android is a Software <a href="myappscheme://stack">stack</a></string>

और "सक्रिय करें" सेटमूवमेंटमैथोड के साथ लिंक () (onCreate () गतिविधियों के लिए या onCreateView (टुकड़े के लिए)):

TextView stack = findViewById(R.id.stackView);
stack.setMovementMethod(LinkMovementMethod.getInstance());

यह "स्टैक" शब्द पर टैप के साथ स्टैक गतिविधि को खोलेगा।


0

क्लिक करने योग्य मान सेट करने के लिए आप यह विधि कर सकते हैं

public void setClickableString(String clickableValue, String wholeValue, TextView yourTextView){
    String value = wholeValue;
    SpannableString spannableString = new SpannableString(value);
    int startIndex = value.indexOf(clickableValue);
    int endIndex = startIndex + clickableValue.length();
    spannableString.setSpan(new ClickableSpan() {
                                @Override
                                public void updateDrawState(TextPaint ds) {
                                    super.updateDrawState(ds);
                                    ds.setUnderlineText(false); // <-- this will remove automatic underline in set span
                                }

                                @Override
                                public void onClick(View widget) {
                                    // do what you want with clickable value
                                }
                            }, startIndex, endIndex, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
    yourTextView.setText(spannableString);
    yourTextView.setMovementMethod(LinkMovementMethod.getInstance()); // <-- important, onClick in ClickableSpan won't work without this
}

यह इसका उपयोग करने का तरीका है:

TextView myTextView = findViewById(R.id.myTextView);
setClickableString("stack", "Android is a Software stack", myTextView);

0

यह MovementMethodलिंक / टेक्स्ट / इमेज क्लिक्स का पता लगाने के लिए है। इसे संशोधित किया गया है LinkMovementMethod

import android.text.Layout;
import android.text.NoCopySpan;
import android.text.Selection;
import android.text.Spannable;
import android.text.method.ScrollingMovementMethod;
import android.text.style.ClickableSpan;
import android.text.style.ImageSpan;
import android.text.style.URLSpan;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;
import android.widget.TextView;

public class ClickMovementMethod extends ScrollingMovementMethod {
private Object FROM_BELOW = new NoCopySpan.Concrete();

private static final int CLICK = 1;
private static final int UP = 2;
private static final int DOWN = 3;

private Listener listener;

public void setListener(Listener listener) {
    this.listener = listener;
}

@Override
public boolean canSelectArbitrarily() {
    return true;
}

@Override
protected boolean handleMovementKey(TextView widget, Spannable buffer, int keyCode,
                                    int movementMetaState, KeyEvent event) {
    switch (keyCode) {
        case KeyEvent.KEYCODE_DPAD_CENTER:
        case KeyEvent.KEYCODE_ENTER:
            if (KeyEvent.metaStateHasNoModifiers(movementMetaState)) {
                if (event.getAction() == KeyEvent.ACTION_DOWN &&
                        event.getRepeatCount() == 0 && action(CLICK, widget, buffer)) {
                    return true;
                }
            }
            break;
    }
    return super.handleMovementKey(widget, buffer, keyCode, movementMetaState, event);
}

@Override
protected boolean up(TextView widget, Spannable buffer) {
    if (action(UP, widget, buffer)) {
        return true;
    }

    return super.up(widget, buffer);
}

@Override
protected boolean down(TextView widget, Spannable buffer) {
    if (action(DOWN, widget, buffer)) {
        return true;
    }

    return super.down(widget, buffer);
}

@Override
protected boolean left(TextView widget, Spannable buffer) {
    if (action(UP, widget, buffer)) {
        return true;
    }

    return super.left(widget, buffer);
}

@Override
protected boolean right(TextView widget, Spannable buffer) {
    if (action(DOWN, widget, buffer)) {
        return true;
    }

    return super.right(widget, buffer);
}

private boolean action(int what, TextView widget, Spannable buffer) {
    Layout layout = widget.getLayout();

    int padding = widget.getTotalPaddingTop() +
            widget.getTotalPaddingBottom();
    int areatop = widget.getScrollY();
    int areabot = areatop + widget.getHeight() - padding;

    int linetop = layout.getLineForVertical(areatop);
    int linebot = layout.getLineForVertical(areabot);

    int first = layout.getLineStart(linetop);
    int last = layout.getLineEnd(linebot);

    ClickableSpan[] candidates = buffer.getSpans(first, last, URLSpan.class);

    int a = Selection.getSelectionStart(buffer);
    int b = Selection.getSelectionEnd(buffer);

    int selStart = Math.min(a, b);
    int selEnd = Math.max(a, b);

    if (selStart < 0) {
        if (buffer.getSpanStart(FROM_BELOW) >= 0) {
            selStart = selEnd = buffer.length();
        }
    }

    if (selStart > last)
        selStart = selEnd = Integer.MAX_VALUE;
    if (selEnd < first)
        selStart = selEnd = -1;

    switch (what) {
        case CLICK:
            if (selStart == selEnd) {
                return false;
            }

            if (listener != null) {
                URLSpan[] link = buffer.getSpans(selStart, selEnd, URLSpan.class);
                if (link.length >= 1) {
                    listener.onClick(link[0].getURL());
                } else {
                    ImageSpan[] image = buffer.getSpans(selStart, selEnd, ImageSpan.class);
                    if (image.length >= 1) {
                        listener.onImageClicked(image[0].getSource());
                    } else {
                        listener.onTextClicked();
                    }
                }
            }
            break;

        case UP:
            int beststart, bestend;

            beststart = -1;
            bestend = -1;

            for (int i = 0; i < candidates.length; i++) {
                int end = buffer.getSpanEnd(candidates[i]);

                if (end < selEnd || selStart == selEnd) {
                    if (end > bestend) {
                        beststart = buffer.getSpanStart(candidates[i]);
                        bestend = end;
                    }
                }
            }

            if (beststart >= 0) {
                Selection.setSelection(buffer, bestend, beststart);
                return true;
            }

            break;

        case DOWN:
            beststart = Integer.MAX_VALUE;
            bestend = Integer.MAX_VALUE;

            for (int i = 0; i < candidates.length; i++) {
                int start = buffer.getSpanStart(candidates[i]);

                if (start > selStart || selStart == selEnd) {
                    if (start < beststart) {
                        beststart = start;
                        bestend = buffer.getSpanEnd(candidates[i]);
                    }
                }
            }

            if (bestend < Integer.MAX_VALUE) {
                Selection.setSelection(buffer, beststart, bestend);
                return true;
            }

            break;
    }

    return false;
}

@Override
public boolean onTouchEvent(TextView widget, Spannable buffer,
                            MotionEvent event) {
    int action = event.getAction();

    if (action == MotionEvent.ACTION_UP ||
            action == MotionEvent.ACTION_DOWN) {
        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);

        URLSpan[] link = buffer.getSpans(off, off, URLSpan.class);

        if (action == MotionEvent.ACTION_UP) {
            if (listener != null) {
                if (link.length >= 1) {
                    listener.onClick(link[0].getURL());
                } else {
                    ImageSpan[] image = buffer.getSpans(off, off, ImageSpan.class);
                    if (image.length >= 1) {
                        listener.onImageClicked(image[0].getSource());
                    } else if (Selection.getSelectionStart(buffer) == Selection.getSelectionEnd(buffer)) {
                        listener.onTextClicked();
                    }
                }
            }
        }

        if (action == MotionEvent.ACTION_DOWN && link.length != 0) {
            Selection.setSelection(buffer,
                    buffer.getSpanStart(link[0]),
                    buffer.getSpanEnd(link[0]));
            return true;
        }

        if (link.length == 0) {
            Selection.removeSelection(buffer);
        }
    }

    return super.onTouchEvent(widget, buffer, event);
}

@Override
public void initialize(TextView widget, Spannable text) {
    Selection.removeSelection(text);
    text.removeSpan(FROM_BELOW);
}

@Override
public void onTakeFocus(TextView view, Spannable text, int dir) {
    Selection.removeSelection(text);

    if ((dir & View.FOCUS_BACKWARD) != 0) {
        text.setSpan(FROM_BELOW, 0, 0, Spannable.SPAN_POINT_POINT);
    } else {
        text.removeSpan(FROM_BELOW);
    }
}

public interface Listener {

    void onClick(String clicked);

    void onTextClicked();

    void onImageClicked(String source);

}

}

0

कोटलिन में अधिक सामान्य उत्तर

   fun setClickableText(view: TextView, firstSpan: String, secondSpan: String) {
    val context = view.context
    val builder = SpannableStringBuilder()
    val unClickableSpan = SpannableString(firstSpan)
    val span = SpannableString(" "+secondSpan)

    builder.append(unClickableSpan);
    val clickableSpan: ClickableSpan = object : ClickableSpan() {
        override fun onClick(textView: View) {
            val intent = Intent(context, HomeActivity::class.java)
         context.startActivity(intent)
        }

        override fun updateDrawState(ds: TextPaint) {
            super.updateDrawState(ds)
            ds.isUnderlineText = true
            ds.setTypeface(Typeface.create(Typeface.DEFAULT, Typeface.ITALIC));
        }
    }
    builder.append(span);
    builder.setSpan(clickableSpan, firstSpan.length, firstSpan.length+secondSpan.length+1, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)

    view.setText(builder,TextView.BufferType.SPANNABLE)
    view.setMovementMethod(LinkMovementMethod.getInstance());


}

0

पाठ दृश्य में लिंक किए गए पाठ को जोड़ने के लिए, आप नीचे दिए गए "footer_text" स्ट्रिंग संसाधन उदाहरण का उपयोग कर सकते हैं और अपनी गतिविधि के लिए अपनी ऑनक्रिट विधि को भी संपादित कर सकते हैं, आप नीचे दिए गए उदाहरण का उपयोग कर सकते हैं

string.xml

<?xml version="1.0" charset="utf-8"?>
<resources>
     <string name="app_name">Name of My Application</string>

    <string name="footer_text">
        <a href="https://www.google.com/tos">Terms of Service</a>
        <a href="https://www.google.com/contact">Contact</a>
        <a href="https://www.google.com/privacy">Privacy Policy</a>
    </string>
</resources>

MainActivity.java

...

@Override
public void onCreate(Bundle savedInstance) {
    super.onCreate(savedInstance);
    setContentView(R.layout.activity_main);

    TextView textView = findViewById(R.id.textViewLink);
    textView.setMovementMethod(LinkMovermentMethod.getInstance());
}

....

0

प्रदान किए गए समाधान बहुत अच्छे हैं। हालांकि, मैं आमतौर पर एक अधिक सरल समाधान का उपयोग करता हूं।

यहां एक लिंक यूटिलिटी फ़ंक्शन है

/**
 * Method is used to Linkify words in a TextView
 *
 * @param textView TextView who's text you want to change
 * @param textToLink The text to turn into a link
 * @param url   The url you want to send the user to
 */
fun linkify(textView: TextView, textToLink: String, url: String) {
    val pattern = Pattern.compile(textToLink)
    Linkify.addLinks(textView, pattern, url, { _, _, _ -> true })
    { _, _ -> "" }
}

इस फ़ंक्शन का उपयोग करना बहुत सरल है। यहाँ एक उदाहरण है

    // terms and privacy
    val tvTerms = findViewById<TextView>(R.id.tv_terms)
    val tvPrivacy = findViewById<TextView>(R.id.tv_privacy)
    Utils.linkify(tvTerms, resources.getString(R.string.terms),
            Constants.TERMS_URL)
    Utils.linkify(tvPrivacy, resources.getString(R.string.privacy),
            Constants.PRIVACY_URL)

0

मैंने कोटलिन में आपके प्रश्न को हल करने के लिए एक उदाहरण कोडित किया है।

यह कोड है:

    val completeText = getString(R.string.terms_description)
    val textToFind = getString(R.string.show_terms)
    val spannableString: Spannable = SpannableString(completeText)
    val startFocus = completeText.indexOf(textToFind)
    val endFocus = startFocus + textToFind.length

    spannableString.setSpan(object: ClickableSpan() {
        override fun onClick(p0: View) {
            showMessage()
        }
    }, startFocus, endFocus, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
    show_terms.text = spannableString
    show_terms.movementMethod = LinkMovementMethod.getInstance();
    show_terms.highlightColor = Color.TRANSPARENT;

यह एक्सएमएल है

    <CheckBox
            android:id="@+id/check_agree_terms"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"/>

    <TextView
            android:id="@+id/show_terms"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:textColorLink="@color/colorPrimary"
            android:layout_toEndOf="@id/check_agree_terms"/>

यह कैसा दिखता है

यहां छवि विवरण दर्ज करें


-1

यह वास्तव में पाठ के कुछ हिस्से के लिए क्लिक करने योग्य भाग के लिए सहायक है।

नियमित अभिव्यक्ति में डॉट एक विशेष चरित्र है। यदि आप डॉट को अलग करना चाहते हैं तो डॉट को भागने की जरूरत है \\। बजाय केवल " ." को पाठनीय विधि में पास करने के लिए। वैकल्पिक रूप से, आप [.]जावा में एक डॉट द्वारा स्ट्रिंग को बदलने के लिए नियमित अभिव्यक्ति का भी उपयोग कर सकते हैं ।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.