How to use

removeSpan

method

in

android.text.SpannableStringBuilder

private void setScrollOffsetMultiLine() {
  // loop over each line and check/set an appropriate alpha for the current scroll offset
  for (int i = 1; i < lineCount; i++) {
    Line line = lines[i];
    float lineAlpha = 1f;
    if (scrollOffset >= line.zeroAlphaScrollOffset) {
      lineAlpha = 0f;
    } else if (scrollOffset <= line.fullAlphaScrollOffset) {
      lineAlpha = 1f;
    } else if (scrollOffset > line.fullAlphaScrollOffset
        && scrollOffset < line.zeroAlphaScrollOffset) {
      lineAlpha = 1f - (scrollOffset - line.fullAlphaScrollOffset)
          / (line.zeroAlphaScrollOffset - line.fullAlphaScrollOffset);
    }
    if (line.currentAlpha != lineAlpha) {
      // mutating a span does not re-draw, need to remove and re-set it
      displayText.removeSpan(line.span);
      line.span.setAlpha(lineAlpha);
      displayText.setSpan(line.span, line.startIndex, line.endIndex,
          Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
      line.currentAlpha = lineAlpha;
    }
  }
}

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

static SpannableStringBuilder linkifyPlainLinks(
    CharSequence input,
    ColorStateList linkTextColor,
    @ColorInt int linkHighlightColor) {
  final SpannableString plainLinks = new SpannableString(input); // copy of input
  // Linkify doesn't seem to work as expected on M+
  // TODO: figure out why
  //Linkify.addLinks(plainLinks, Linkify.WEB_URLS);
  final URLSpan[] urlSpans = plainLinks.getSpans(0, plainLinks.length(), URLSpan.class);
  // add any plain links to the output
  final SpannableStringBuilder ssb = new SpannableStringBuilder(input);
  for (URLSpan urlSpan : urlSpans) {
    ssb.removeSpan(urlSpan);
    ssb.setSpan(new TouchableUrlSpan(urlSpan.getURL(), linkTextColor, linkHighlightColor),
        plainLinks.getSpanStart(urlSpan),
        plainLinks.getSpanEnd(urlSpan),
        Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
  }
  return ssb;
}

  mSpannableStringBuilder.removeSpan(obj[i]);
} else {
  mSpannableStringBuilder.setSpan(obj[i], start, end, Spannable.SPAN_PARAGRAPH);

int where = text.getSpanStart(obj);
text.removeSpan(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);
  }
}

RelativeSizeSpan[] relSpans = newCueText.getSpans(0, cueLength, RelativeSizeSpan.class);
for (AbsoluteSizeSpan absSpan : absSpans) {
 newCueText.removeSpan(absSpan);
 newCueText.removeSpan(relSpan);

private <T> void remove(SpannableStringBuilder sb,Class<T> c){
  T[] spans = sb.getSpans(0,sb.length(), c);
  if(spans!=null){
    for (int i = 0; i < spans.length; i++) {
      sb.removeSpan(spans[i]);
    }
  }
}

/**
 * @return the text as an {@link Editable} (note: not a {@link MentionsEditable} and does not contain mentions)
 */
private Editable getTextWithoutMentions() {
  Editable text = getText();
  SpannableStringBuilder sb = new SpannableStringBuilder(text);
  MentionSpan[] spans = sb.getSpans(0, sb.length(), MentionSpan.class);
  for (MentionSpan span: spans) {
    sb.removeSpan(span);
  }
  return sb;
}

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 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, @SuppressWarnings("rawtypes") 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;
}

  void swapIn(SpannableStringBuilder builder) {
    int start = builder.getSpanStart(this);
    int end = builder.getSpanEnd(this);
    builder.removeSpan(this);
    if (start >= 0 && end > start && end <= builder.length()) {
      builder.setSpan(mSpan, start, end, Spanned.SPAN_EXCLUSIVE_INCLUSIVE);
    }
  }
}

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

  @Override
  public void onImageReady(String source, int start, int end, Drawable d) {
    Image[] is = spannedBuilder.getSpans(start, end, Image.class);
    for (Image i : is) {
      spannedBuilder.removeSpan(i);
    }
    setSpan(start, end, new Image(source, d));
    notify.notifyViewChange();
  }
}

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