How to use

getSpanStart

method

in

android.text.SpannableStringBuilder

public static void replaceUnderlineSpans(SpannableStringBuilder builder, Resources resources) {
 UnderlineSpan[] underlineSpans = builder.getSpans(0, builder.length(), UnderlineSpan.class);
 for (UnderlineSpan span : underlineSpans) {
  int start = builder.getSpanStart(span);
  int end = builder.getSpanEnd(span);
  builder.removeSpan(span);
  builder.setSpan(new SquigglySpan(resources), start, end, 0);
 }
}

private static void end(SpannableStringBuilder text, Class kind,
    Object repl) {
  int len = text.length();
  Object obj = getLast(text, kind);
  int where = text.getSpanStart(obj);
  text.removeSpan(obj);
  if (where != len) {
    text.setSpan(repl, where, len, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
  }
}

private static void endA(SpannableStringBuilder text) {
  int len = text.length();
  Object obj = getLast(text, Href.class);
  int where = text.getSpanStart(obj);
  text.removeSpan(obj);
  if (where != len) {
    Href h = (Href) obj;
    if (h.mHref != null) {
      text.setSpan(new URLSpan(h.mHref), where, len,
          Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
    }
  }
}

int start = mSpannableStringBuilder.getSpanStart(obj[i]);
int end = mSpannableStringBuilder.getSpanEnd(obj[i]);

private static void endFont(SpannableStringBuilder text) {
  int len = text.length();
  Object obj = getLast(text, Font.class);
  int where = text.getSpanStart(obj);

private static void endHeader(SpannableStringBuilder text) {
  int len = text.length();
  Object obj = getLast(text, Header.class);
  int where = text.getSpanStart(obj);
  text.removeSpan(obj);
  // Back off not to change only the text, not the blank line.
  while (len > where && text.charAt(len - 1) == '\n') {
    len--;
  }
  if (where != len) {
    Header h = (Header) obj;
    text.setSpan(new RelativeSizeSpan(HEADER_SIZES[h.mLevel]),
        where, len, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
    text.setSpan(new StyleSpan(Typeface.BOLD),
        where, len, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
  }
}

 final Context context = ... // whereever your context is
CharSequence sequence = Html.fromSource(context.getString(R.string.clickable_string));
SpannableStringBuilder strBuilder = new SpannableStringBuilder(sequence);
UnderlineSpan[] underlines = strBuilder.getSpans(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) {
    context.startActivity(getIntentForActivityToStart());
   }
  };

  strBuilder.setSpan(myActivityLauncher, start, end, flags);
}

TextView textView = ...
textView.setText(strBuilder);
textView.setMovementMethod(LinkMovementMethod.getInstance());

private FixingResult addSpacesAroundSpansUntilFixed(SpannableStringBuilder builder,
                          int widthMeasureSpec, int heightMeasureSpec) {
  Object[] spans = builder.getSpans(0, builder.length(), Object.class);
  List<Object> spansWithSpacesBefore = new ArrayList<>(spans.length);
  List<Object> spansWithSpacesAfter = new ArrayList<>(spans.length);
  for (Object span : spans) {
    int spanStart = builder.getSpanStart(span);
    if (isNotSpace(builder, spanStart - 1)) {
      builder.insert(spanStart, " ");
      spansWithSpacesBefore.add(span);
    }
    int spanEnd = builder.getSpanEnd(span);
    if (isNotSpace(builder, spanEnd)) {
      builder.insert(spanEnd, " ");
      spansWithSpacesAfter.add(span);
    }
    try {
      setTextAndMeasure(builder, widthMeasureSpec, heightMeasureSpec);
      return FixingResult.fixed(spansWithSpacesBefore, spansWithSpacesAfter);
    } catch (IndexOutOfBoundsException ignored) {
    }
  }
  if (HtmlTextView.DEBUG) {
    Log.d(HtmlTextView.TAG, "Could not fix the Spanned by adding spaces around spans");
  }
  return FixingResult.notFixed();
}

@SuppressLint("WrongCall")
private void removeUnneededSpaces(int widthMeasureSpec, int heightMeasureSpec,
                 SpannableStringBuilder builder, FixingResult result) {
  for (Object span : result.spansWithSpacesAfter) {
    int spanEnd = builder.getSpanEnd(span);
    builder.delete(spanEnd, spanEnd + 1);
    try {
      setTextAndMeasure(builder, widthMeasureSpec, heightMeasureSpec);
    } catch (IndexOutOfBoundsException ignored) {
      builder.insert(spanEnd, " ");
    }
  }
  boolean needReset = true;
  for (Object span : result.spansWithSpacesBefore) {
    int spanStart = builder.getSpanStart(span);
    builder.delete(spanStart - 1, spanStart);
    try {
      setTextAndMeasure(builder, widthMeasureSpec, heightMeasureSpec);
      needReset = false;
    } catch (IndexOutOfBoundsException ignored) {
      needReset = true;
      int newSpanStart = spanStart - 1;
      builder.insert(newSpanStart, " ");
    }
  }
  if (needReset) {
    setText(builder);
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
  }
}

 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());

private boolean checkDuplicateSpan(SpannableStringBuilder text, int where, Class<?> kind) {
  Object[] spans = text.getSpans(where, where, kind);
  if (spans != null && spans.length > 0) {
    for (int i = 0; i < spans.length; i++) {
      if (text.getSpanStart(spans[i]) == where) {
        return true;
      }
    }
  }
  return false;
}

private void makeLinkClickable(SpannableStringBuilder strBuilder, final URLSpan span, Runnable runnable) {
  int start = strBuilder.getSpanStart(span);
  int end = strBuilder.getSpanEnd(span);
  int flags = strBuilder.getSpanFlags(span);
  ClickableSpan clickable = new ClickableSpan() {
    public void onClick(View view) {
      runnable.run();
    }
  };
  strBuilder.setSpan(clickable, start, end, flags);
  strBuilder.removeSpan(span);
}

private static void end(SpannableStringBuilder text, Class kind, Object repl) {
  int len = text.length();
  Object obj = getLast(text, kind);
  int where = text.getSpanStart(obj);
  text.removeSpan(obj);
  if (where != len) {
    text.setSpan(repl, where, len, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
  }
}

private static void end(SpannableStringBuilder text, Class<?> kind,
            Object repl) {
  int len = text.length();
  Object obj = getLast(text, kind);
  int where = text.getSpanStart(obj);
  text.removeSpan(obj);
  if (where != len) {
    text.setSpan(repl, where, len, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
  }
  return;
}

private void end(Class<? extends Object> kind, Object repl) {
  int len = mResult.length();
  Object obj = getLast(kind);
  int where = mResult.getSpanStart(obj);
  mResult.removeSpan(obj);
  if (where != len) {
    // Note: use SPAN_EXCLUSIVE_EXCLUSIVE, the TemporarySpan will be replaced by a SPAN_EXCLUSIVE_INCLUSIVE span
    mResult.setSpan(new TemporarySpan(repl), where, len, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
  }
}

private static void endA(SpannableStringBuilder text) {
  int len = text.length();
  Object obj = getLast(text, Href.class);
  int where = text.getSpanStart(obj);
  text.removeSpan(obj);
  if (where != len) {
    Href h = (Href) obj;
    if (h.mHref != null) {
      text.setSpan(new URLSpan(h.mHref), where, len,
          Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
    }
  }
}

private static void endA(SpannableStringBuilder text) {
  int len = text.length();
  Object obj = getLast(text, Href.class);
  int where = text.getSpanStart(obj);
  text.removeSpan(obj);
  if (where != len) {
    Href h = (Href) obj;
    if (h.mHref != null) {
      text.setSpan(new URLSpan(h.mHref), where, len,
          Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
    }
  }
}

 SpannableStringBuilder builder = ...
URLSpan[] spans = builder .getSpans(0, builder .length(), URLSpan.class);
for (URLSpan span : spans) {
  int start = builder .getSpanStart(span);
  int end = builder .getSpanEnd(span);
  s.removeSpan(span);
  span = new CustomURLSpan(span.getURL().replace("http://", "scheme://"));
  s.setSpan(span, start, end, 0);
}
textView.setText(builder);

private void endAHref() {
  int len = mResult.length();
  Object obj = getLast(Href.class);
  int where = mResult.getSpanStart(obj);
  mResult.removeSpan(obj);
  if (where != len) {
    Href h = (Href) obj;
    if (h.mHref != null) {
      mResult.setSpan(new LinkSpan(h.mHref), where, len, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
    }
  }
}

private static String getTextWithPasswords(CharSequence seq) {
  SpannableStringBuilder lstr = new SpannableStringBuilder(seq);
  for (PasswordSpan span : lstr.getSpans(0, lstr.length(), PasswordSpan.class)) {
    lstr.replace(lstr.getSpanStart(span), lstr.getSpanEnd(span), span.mPassword);
    lstr.removeSpan(span);
  }
  return lstr.toString();
}