Java 类android.text.style.ReplacementSpan 实例源码

/**
 * Do not support cross Span.
 *
 * @param text       text
 * @param parentSpan parentSpan
 * @param start      start index of parentSpan
 * @param end        end index of parentSpan
 * @param paint      TextPaint
 * @return recursive calculated width
 */
public int recursiveGetSizeWithReplacementSpan(CharSequence text, ReplacementSpan parentSpan, @IntRange(from = 0) int start, @IntRange(from = 0) int end, Paint paint) {
  if (text instanceof Spanned) {
    Spanned spannedText = (Spanned) text;
    List<ReplacementSpan> spans = getSortedReplacementSpans(spannedText, start, end);
    if (!spans.isEmpty()) {
      int lastIndexCursor = 0;
      int width = 0;
      for (ReplacementSpan span : spans) {
        if (span == parentSpan) {
          continue;
        }
        int spanStart = spannedText.getSpanStart(span);
        int spanEnd = spannedText.getSpanEnd(span);
        width += parentSpan.getSize(paint, text, lastIndexCursor, spanStart, null);
        width += span.getSize(paint, text, spanStart, spanEnd, null);
        lastIndexCursor = spanEnd;
      }
      if (lastIndexCursor < end) {
        width += parentSpan.getSize(paint, text, lastIndexCursor, end, null);
      }
      return width;
    }
  }
  return parentSpan.getSize(paint, text, start, end, null);
}

@Override
public <T> T[] getSpans(int start, int end, Class<T> type) {
  if (mEllipsisEnd >= end && mEllipsisStart <= end) {
    T[] spans1 = mSourceSpanned.getSpans(start, Math.max(mEllipsisStart, start), type);
    T[] spans2 = mSourceSpanned.getSpans(Math.min(end, mEllipsisEnd), end, type);
    int offset = mCustomEllipsisSpan != null
        && (type.isAssignableFrom(ReplacementSpan.class) || type == mCustomEllipsisSpan.getClass()) ?
        1 : 0;
    int minLen = spans1.length + spans2.length + offset;
    T[] spans = (T[]) Array.newInstance(type, minLen);
    if (spans.length > minLen) {
      spans = Arrays.copyOf(spans, minLen);
    }
    System.arraycopy(spans1, 0, spans, 0, spans1.length);
    if (offset > 0) {
      spans[spans1.length] =  (T) mCustomEllipsisSpan;
    }
    System.arraycopy(spans2, 0, spans, spans1.length + offset, spans2.length);
    return spans;
  }
  return mSourceSpanned.getSpans(start, end, type);
}

/**
 * get real translate charsequence
 * @param content
 * @return
 */
public static CharSequence getTranslateTxt(CharSequence content) {
    StringBuilder sBuilder = new StringBuilder();
    if (content instanceof SpannableStringBuilder) {
        SpannableStringBuilder spanSb = (SpannableStringBuilder) content;
        if (spanSb.toString().contains(EMHolderEntity.FINAL_HOLDER)) {
            for (int i = 0; i < spanSb.length(); i++) {
                ReplacementSpan[] spans = spanSb.getSpans(i, i + 1, ReplacementSpan.class);
                if (spans.length > 0) {
                    if (spans[0] instanceof EMImageSpan) {
                        EMImageSpan imgSpan = (EMImageSpan) spans[0];
                        sBuilder.append(imgSpan.mTransferTxt);
                    } else if (spans[0] instanceof DefEmojSpan) {
                        DefEmojSpan defSpan = (DefEmojSpan) spans[0];
                        sBuilder.append(defSpan.mTransferTxt);
                    }
                } else {
                    sBuilder.append(spanSb.subSequence(i, i + 1));
                }
            }
        } else {
            sBuilder.append(content);
        }
    }
    return sBuilder;
}

public static CharSequence getTranslateTxt(CharSequence content) {
    StringBuilder sBuilder = new StringBuilder();
    if (content instanceof SpannableStringBuilder) {
        SpannableStringBuilder spanSb = (SpannableStringBuilder) content;
        if (spanSb.toString().contains(EMHolderEntity.FINAL_HOLDER)) {
            for (int i = 0; i < spanSb.length(); i++) {
                ReplacementSpan[] spans = spanSb.getSpans(i, i + 1, ReplacementSpan.class);
                if (spans.length > 0) {
                    if (spans[0] instanceof EMImageSpan) {
                        EMImageSpan imgSpan = (EMImageSpan) spans[0];
                        sBuilder.append(imgSpan.mTransferTxt);
                    } else if (spans[0] instanceof DefEmojSpan) {
                        DefEmojSpan defSpan = (DefEmojSpan) spans[0];
                        sBuilder.append(defSpan.mTransferTxt);
                    }
                } else {
                    sBuilder.append(spanSb.subSequence(i, i + 1));
                }
            }
        } else {
            sBuilder.append(content);
        }
    }
    return sBuilder;
}

@Override
public int getSize(@NonNull Rect outRect, @NonNull Paint paint, CharSequence text, @IntRange(from = 0) int start, @IntRange(from = 0) int end, @Nullable Paint.FontMetricsInt fm) {
    int width = super.getSize(outRect, paint, text, start, end, fm);
    if (styles != null) {
        for (CharacterStyle style : styles) {
            if (style instanceof SupportSpan) {
                width = Math.max(width, ((SupportSpan) style).getSize(frame, paint, text, start, end, fm));
            } else if (style instanceof ReplacementSpan) {
                width = Math.max(width, ((ReplacementSpan) style).getSize(paint, text, start, end, fm));
            } else if (paint instanceof TextPaint) {
                if (style instanceof MetricAffectingSpan) {
                    ((MetricAffectingSpan) style).updateMeasureState((TextPaint) paint);
                }
            }
        }
    }
    frame.right = width;
    return width;
}

@Override
public int getSize(@NonNull Paint paint, CharSequence text, @IntRange(from = 0) int start, @IntRange(from = 0) int end, @Nullable Paint.FontMetricsInt fm) {
    width = 0;
    for (CharacterStyle style : styles) {
        if (style instanceof ReplacementSpan) {
            width = Math.max(width, ((ReplacementSpan) style).getSize(paint, text, start, end, fm));
        } else if (paint instanceof TextPaint) {
            if (style instanceof MetricAffectingSpan) {
                ((MetricAffectingSpan) style).updateMeasureState((TextPaint) paint);
            }
        }
    }
    if (fm != null) {
        paint.getFontMetricsInt(fm);
    }
    paint.getFontMetricsInt(fontMetricsInt);
    width = Math.max(width, (int) Math.ceil(paint.measureText(text, start, end)));
    frame.right = width;
    frame.top = fontMetricsInt.top;
    frame.bottom = fontMetricsInt.bottom;
    if (bitmap == null) {
        bitmap = Bitmap.createBitmap(width, frame.bottom - frame.top, Bitmap.Config.ARGB_8888);
        bitmapCanvas = new Canvas(bitmap);
    }
    return width;
}

@Override
        public void draw(@NonNull Canvas canvas, CharSequence text, @IntRange(from = 0) int start, @IntRange(from = 0) int end, float x, int top, int y, int bottom, @NonNull Paint paint) {
//            bitmapCanvas.drawColor(Color.GRAY, PorterDuff.Mode.CLEAR);
            int color = /*paint instanceof TextPaint ? ((TextPaint) paint).bgColor :*/ paint.getColor();
            bitmapCanvas.drawColor(color);
            for (CharacterStyle style : styles) {
                if (style instanceof ReplacementSpan) {
                    ((ReplacementSpan) style).draw(bitmapCanvas, text, start, end, 0, top, y, bottom, paint);
                } else if (paint instanceof TextPaint) {
                    style.updateDrawState((TextPaint) paint);
                }
            }
            paint.setXfermode(xfermode);
            bitmapCanvas.drawText(text, start, end, 0, y, paint);
            canvas.drawBitmap(bitmap, x, 0, null);
        }

@Override
public int getSize(@NonNull Rect outRect, @NonNull Paint paint, CharSequence text, @IntRange(from = 0) int start, @IntRange(from = 0) int end, @Nullable Paint.FontMetricsInt fm) {
    int width = super.getSize(outRect, paint, text, start, end, fm);
    if (styles != null) {
        for (CharacterStyle style : styles) {
            if (style instanceof SupportSpan) {
                width = Math.max(width, ((SupportSpan) style).getSize(frame, paint, text, start, end, fm));
            } else if (style instanceof ReplacementSpan) {
                width = Math.max(width, ((ReplacementSpan) style).getSize(paint, text, start, end, fm));
            } else if (paint instanceof TextPaint) {
                if (style instanceof MetricAffectingSpan) {
                    ((MetricAffectingSpan) style).updateMeasureState((TextPaint) paint);
                }
            }
        }
    }
    frame.right = width;
    return width;
}

@Override
public int getSize(@NonNull Paint paint, CharSequence text, @IntRange(from = 0) int start, @IntRange(from = 0) int end, @Nullable Paint.FontMetricsInt fm) {
    width = 0;
    for (CharacterStyle style : styles) {
        if (style instanceof ReplacementSpan) {
            width = Math.max(width, ((ReplacementSpan) style).getSize(paint, text, start, end, fm));
        } else if (paint instanceof TextPaint) {
            if (style instanceof MetricAffectingSpan) {
                ((MetricAffectingSpan) style).updateMeasureState((TextPaint) paint);
            }
        }
    }
    if (fm != null) {
        paint.getFontMetricsInt(fm);
    }
    paint.getFontMetricsInt(fontMetricsInt);
    width = Math.max(width, (int) Math.ceil(paint.measureText(text, start, end)));
    frame.right = width;
    frame.top = fontMetricsInt.top;
    frame.bottom = fontMetricsInt.bottom;
    if (bitmap == null) {
        bitmap = Bitmap.createBitmap(width, frame.bottom - frame.top, Bitmap.Config.ARGB_8888);
        bitmapCanvas = new Canvas(bitmap);
    }
    return width;
}

@Override
        public void draw(@NonNull Canvas canvas, CharSequence text, @IntRange(from = 0) int start, @IntRange(from = 0) int end, float x, int top, int y, int bottom, @NonNull Paint paint) {
//            bitmapCanvas.drawColor(Color.GRAY, PorterDuff.Mode.CLEAR);
            int color = /*paint instanceof TextPaint ? ((TextPaint) paint).bgColor :*/ paint.getColor();
            bitmapCanvas.drawColor(color);
            for (CharacterStyle style : styles) {
                if (style instanceof ReplacementSpan) {
                    ((ReplacementSpan) style).draw(bitmapCanvas, text, start, end, 0, top, y, bottom, paint);
                } else if (paint instanceof TextPaint) {
                    style.updateDrawState((TextPaint) paint);
                }
            }
            paint.setXfermode(xfermode);
            bitmapCanvas.drawText(text, start, end, 0, y, paint);
            canvas.drawBitmap(bitmap, x, 0, null);
        }

public static List<ReplacementSpan> getSortedReplacementSpans(final Spanned spanned, int start, int end) {
  List<ReplacementSpan> sortedSpans = new LinkedList<>();
  ReplacementSpan[] spans = spanned.getSpans(start, end, ReplacementSpan.class);
  if (spans.length > 0) {
    sortedSpans.addAll(Arrays.asList(spans));
  }
  Collections.sort(sortedSpans, new Comparator<ReplacementSpan>() {
    @Override
    public int compare(ReplacementSpan span1, ReplacementSpan span2) {
      return spanned.getSpanStart(span1) - spanned.getSpanStart(span2);
    }
  });
  return sortedSpans;
}

@Override
public void draw(@NonNull Rect outRect, @NonNull Canvas canvas, CharSequence text, @IntRange(from = 0) int start, @IntRange(from = 0) int end, float x, int top, int y, int bottom, @NonNull Paint paint) {
    for (CharacterStyle style : styles) {
        if (style instanceof SupportSpan) {
            ((SupportSpan) style).draw(frame, canvas, text, start, end, x, top, y, bottom, paint);
        } else if (style instanceof ReplacementSpan) {
            ((ReplacementSpan) style).draw(canvas, text, start, end, x, top, y, bottom, paint);
        } else if (paint instanceof TextPaint) {
            style.updateDrawState((TextPaint) paint);
        }
    }
}

/** Starts {@code span} at the current position in the builder. */
public Truss pushSpan(Object span) {
    if (span instanceof ReplacementSpan) {
        replacements++;
    } else if (replacements > 0 && span instanceof CharacterStyle) {
        span = convert((CharacterStyle) span);
    }
    stack.addLast(new Span(builder.length(), span));
    return this;
}

/** End the most recently pushed span at the current position in the builder. */
public Truss popSpan() {
    Span span = stack.removeLast();
    if (span.span instanceof ReplacementSpan) {
        replacements--;
    }
    builder.setSpan(span.span, span.start, builder.length(), SPAN_INCLUSIVE_EXCLUSIVE);
    return this;
}

@Override
public void draw(@NonNull Rect outRect, @NonNull Canvas canvas, CharSequence text, @IntRange(from = 0) int start, @IntRange(from = 0) int end, float x, int top, int y, int bottom, @NonNull Paint paint) {
    for (CharacterStyle style : styles) {
        if (style instanceof SupportSpan) {
            ((SupportSpan) style).draw(frame, canvas, text, start, end, x, top, y, bottom, paint);
        } else if (style instanceof ReplacementSpan) {
            ((ReplacementSpan) style).draw(canvas, text, start, end, x, top, y, bottom, paint);
        } else if (paint instanceof TextPaint) {
            style.updateDrawState((TextPaint) paint);
        }
    }
}

/** Starts {@code span} at the current position in the builder. */
public Truss pushSpan(Object span) {
    if (span instanceof ReplacementSpan) {
        replacements++;
    } else if (replacements > 0 && span instanceof CharacterStyle) {
        span = convert((CharacterStyle) span);
    }
    stack.addLast(new Span(builder.length(), span));
    return this;
}

/** End the most recently pushed span at the current position in the builder. */
public Truss popSpan() {
    Span span = stack.removeLast();
    if (span.span instanceof ReplacementSpan) {
        replacements--;
    }
    builder.setSpan(span.span, span.start, builder.length(), SPAN_INCLUSIVE_EXCLUSIVE);
    return this;
}

private void onSpanAdded(Object span) {
    if (span instanceof MetricAffectingSpan) {
        mHasMetricAffectingSpan = true;
    }
    if (span instanceof ReplacementSpan) {
        mHasReplacementSpan = true;
    }
    if (span instanceof ParagraphStyle) {
        mHasParagraphStyle = true;
    }
}

@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
    manipulatedSpan = null;
    if (after < count && !manualModeOn) {
        ReplacementSpan[] spans = ((Spannable)s).getSpans(start, start+count, ReplacementSpan.class);
        if (spans.length == 1) {
            manipulatedSpan = spans[0];
        } else {
            manipulatedSpan = null;
        }
    }
}

public void setCustomEllipsisSpan(ReplacementSpan customEllipsisSpan) {
  mCustomEllipsisSpan = customEllipsisSpan;
}

public ReplacementSpan getCustomEllipsisSpan() {
  return mCustomEllipsisSpan;
}

public void setCustomCollapseSpan(ReplacementSpan collapseSpan) {
  mCollapseSpan = collapseSpan;
}

public void setCustomEllipsisSpan(ReplacementSpan customEllipsisSpan) {
  mCustomEllipsisSpan = customEllipsisSpan;
}

/**
 * Utility function for measuring and rendering a replacement.
 *
 * @param replacement the replacement
 * @param wp          the work paint
 * @param start       the start of the run
 * @param limit       the limit of the run
 * @param runIsRtl    true if the run is right-to-left
 * @param c           the canvas, can be null if not rendering
 * @param x           the edge of the replacement closest to the leading margin
 * @param top         the top of the line
 * @param y           the baseline
 * @param bottom      the bottom of the line
 * @param fmi         receives metrics information, can be null
 * @param needWidth   true if the width of the replacement is needed
 * @return the signed width of the run based on the run direction; only
 * valid if needWidth is true
 */
private float handleReplacement(ReplacementSpan replacement, TextPaint wp,
                                int start, int limit, boolean runIsRtl, Canvas c,
                                float x, int top, int y, int bottom, FontMetricsInt fmi,
                                boolean needWidth) {

  float ret = 0;

  int textStart = mStart + start;
  int textLimit = mStart + limit;

  if (needWidth || (c != null && runIsRtl)) {
    int previousTop = 0;
    int previousAscent = 0;
    int previousDescent = 0;
    int previousBottom = 0;
    int previousLeading = 0;

    boolean needUpdateMetrics = (fmi != null);

    if (needUpdateMetrics) {
      previousTop = fmi.top;
      previousAscent = fmi.ascent;
      previousDescent = fmi.descent;
      previousBottom = fmi.bottom;
      previousLeading = fmi.leading;
    }

    ret = replacement.getSize(wp, mText, textStart, textLimit, fmi);

    if (needUpdateMetrics) {
      updateMetrics(fmi, previousTop, previousAscent, previousDescent, previousBottom,
          previousLeading);
    }
  }

  if (c != null) {
    if (runIsRtl) {
      x -= ret;
    }
    replacement.draw(c, mText, textStart, textLimit,
        x, top, y, bottom, wp);
  }

  return runIsRtl ? -ret : ret;
}

/**
 * Utility function for measuring and rendering a replacement.
 *
 * @param replacement the replacement
 * @param wp          the work paint
 * @param start       the start of the run
 * @param limit       the limit of the run
 * @param runIsRtl    true if the run is right-to-left
 * @param c           the canvas, can be null if not rendering
 * @param x           the edge of the replacement closest to the leading margin
 * @param top         the top of the line
 * @param y           the baseline
 * @param bottom      the bottom of the line
 * @param fmi         receives metrics information, can be null
 * @param needWidth   true if the width of the replacement is needed
 * @return the signed width of the run based on the run direction; only
 * valid if needWidth is true
 */
private float handleReplacement(ReplacementSpan replacement, TextPaint wp,
                                int start, int limit, boolean runIsRtl, Canvas c,
                                float x, int top, int y, int bottom, FontMetricsInt fmi,
                                boolean needWidth) {

  float ret = 0;

  int textStart = mStart + start;
  int textLimit = mStart + limit;

  if (needWidth || (c != null && runIsRtl)) {
    int previousTop = 0;
    int previousAscent = 0;
    int previousDescent = 0;
    int previousBottom = 0;
    int previousLeading = 0;

    boolean needUpdateMetrics = (fmi != null);

    if (needUpdateMetrics) {
      previousTop = fmi.top;
      previousAscent = fmi.ascent;
      previousDescent = fmi.descent;
      previousBottom = fmi.bottom;
      previousLeading = fmi.leading;
    }

    ret = replacement.getSize(wp, mText, textStart, textLimit, fmi);

    if (needUpdateMetrics) {
      updateMetrics(fmi, previousTop, previousAscent, previousDescent, previousBottom,
          previousLeading);
    }
  }

  if (c != null) {
    if (runIsRtl) {
      x -= ret;
    }
    replacement.draw(c, mText, textStart, textLimit,
        x, top, y, bottom, wp);
  }

  return runIsRtl ? -ret : ret;
}

public EMTranslatEntity assembleSpan(ArrayList<EMCharacterEntity> joinArr) throws JSONException {

        if (joinArr == null || joinArr.size() == 0) return null;

        SpannableStringBuilder spanSb = new SpannableStringBuilder();
        Vector<EMCandiateEntity> allStressEMKeys = new Vector<>();

        for (int i = 0; i < joinArr.size(); i++) {
            EMCharacterEntity entry = joinArr.get(i);
            switch (entry.mCharType) {
                case Normal:
                case Other:
                case Space:
                    entry.mWordStart = spanSb.length();
                    spanSb.append(entry.mWord);
                    break;
                case Emoj:
                    SpannableStringBuilder tempSpan = (SpannableStringBuilder) entry.mWord;
                    ReplacementSpan[] spans = tempSpan.getSpans(0, entry.mWord.length(), ReplacementSpan.class);
                    if (spans.length > 0) {
                        ReplacementSpan emojSpan = null;
                        if (spans[0] instanceof EMImageSpan) {
                            emojSpan = (EMImageSpan) spans[0];
                        } else if (spans[0] instanceof DefEmojSpan) {
                            emojSpan = (DefEmojSpan) spans[0];
                        }
                        spanSb.append(HOLDER_CHAR);
                        spanSb.setSpan(emojSpan, spanSb.length() - 1, spanSb.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                    }
                    break;
                case Translate:
                    String emojProperty = EMDBMagager.getInstance().queryEmojByTag(entry.mWord.toString());
                    if (StringUtil.isNullOrEmpty(emojProperty)) {
                        spanSb.append(entry.mWord);
                    } else {
                        EMCandiateEntity candiateEmojEntity = new EMCandiateEntity(entry.mWord.toString(), entry.mWordStart);
                        candiateEmojEntity.parseRespJson(new JSONObject(emojProperty));
                        ArrayList<EMCandiateProperty> emojTagEntities = candiateEmojEntity.mEmojEntities;
                        if (emojTagEntities != null && emojTagEntities.size() == 1) {
                            String emojTagId = "#|" + candiateEmojEntity.mEMKey + "_" + emojTagEntities.get(0).mUniqueId + "|";
                            candiateEmojEntity.mEMStart = spanSb.length();
                            spanSb.append(HOLDER_CHAR);
                            DefEmojSpan emojResponseSpan = new DefEmojSpan(emojTagEntities.get(0));
                            emojResponseSpan.mOriginTxt = candiateEmojEntity.mEMKey;
                            emojResponseSpan.mTransferTxt = emojTagId;

                            spanSb.setSpan(emojResponseSpan, spanSb.toString().length() - 1, spanSb.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);

                            // handle here if cache key and emoji property
                            cacheCustomEmojToDB(emojTagId);
                        }else {
                            candiateEmojEntity.mEMStart = spanSb.length();
                            allStressEMKeys.add(candiateEmojEntity);
                            spanSb.append(entry.mWord);
                        }
                    }
                    break;
            }
        }

        EMTranslatEntity translatEntity = new EMTranslatEntity(spanSb, allStressEMKeys);
        return translatEntity;
    }

@SuppressWarnings("unchecked")
@Override
public <T> T[] getSpans(int start, int end, Class<T> type) {
    // Fast path for common time-critical spans that aren't there
    if (type == MetricAffectingSpan.class && !mHasMetricAffectingSpan) {
        return (T[]) EMPTY_METRIC_AFFECTING_SPAN_ARRAY;
    }
    if (type == ReplacementSpan.class && !mHasReplacementSpan) {
        return (T[]) EMPTY_REPLACEMENT_SPAN_ARRAY;
    }
    if (!mHasParagraphStyle) {
        if (type == LeadingMarginSpan.class) {
            return (T[]) EMPTY_LEADING_MARGIN_SPAN_ARRAY;
        }
        if (type == LineHeightSpan.class) {
            return (T[]) EMPTY_LINE_HEIGHT_SPAN_ARRAY;
        }
        if (type == TabStopSpan.class) {
            return (T[]) EMPTY_TAB_STOP_SPAN_ARRAY;
        }
    }

    T[] spansFromSuperclass = mSpannableString.getSpans(start, end, type);

    if (
            mSpansArr.length == 0 || // We have no optimized spans
            isExcludedSpanType(type)) { // Query is about unoptimized span
        return spansFromSuperclass;
    }

    // Based on Arrays.binarySearch()
    int lo = 0;
    int hi = mSpansArr.length - 1;
    int mid = -2;

    while (lo <= hi) {
        mid = (lo + hi) >>> 1;
        int midVal = mSpansArr[mid].end;

        if (midVal < start) {
            lo = mid + 1;
        } else if (midVal > start) {
            hi = mid - 1;
        } else {
            break;
        }
    }

    // Iterate over spans in range
    List<T> result = null;
    for (; mid < mSpansArr.length && mSpansArr[mid].start < end; mid++) {
        if (mSpansArr[mid].end > start && type.isInstance(mSpansArr[mid].span)) {
            if (result == null) {
                result = LIST_POOL.acquire();
                if (spansFromSuperclass.length != 0) {
                    result.addAll(Arrays.asList(spansFromSuperclass));
                }
            }
            result.add((T) mSpansArr[mid].span);
        }
    }

    // If we have list then make array and pass to superclass
    if (result == null) {
        return spansFromSuperclass;
    } else {
        T[] resultArray = result.toArray((T[]) Array.newInstance(type, result.size()));
        LIST_POOL.release(result);
        return resultArray;
    }
}