@quicktvui/ai 1.0.7 → 1.0.8

package/rules/.source/hippy/extend_views/fastlist/diff/KeyDiffHelper.java

@@ -0,0 +1,289 @@
+package com.tencent.extend.views.fastlist.diff;
+
+import static com.tencent.extend.views.fastlist.diff.FastListDataBindingHelper.Patch;
+import static com.tencent.extend.views.fastlist.diff.FastListDataBindingHelper.DiffItem;
+import static com.tencent.extend.views.fastlist.diff.FastListDataBindingHelper.MoveDiffItem;
+import static com.tencent.extend.views.fastlist.diff.FastListDataBindingHelper.OnTransFormListener;
+import static com.tencent.extend.views.fastlist.diff.FastListDataBindingHelper.RangeDiffItem.handleRangeList;
+import static com.tencent.extend.views.fastlist.diff.NoKeyDiffHelper.diffArray;
+import static com.tencent.extend.views.fastlist.diff.NoKeyDiffHelper.diffMap;
+
+import android.text.TextUtils;
+import android.util.Log;
+
+import com.tencent.mtt.hippy.common.HippyArray;
+import com.tencent.mtt.hippy.common.HippyMap;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 有key diff实现类
+ */
+public class KeyDiffHelper {
+  public static String KEY = "key";
+
+  // 先处理有key的情况 key需要调用方自己控制处理，类型需要为String
+  public static <T> Map<Integer, List<DiffItem>> handleKeyDataDiff(HippyArray beforeArray, HippyArray array, String keyName,
+                                                                   OnTransFormListener<T> listener, Class<T> tClass) {
+    KEY = keyName;
+    Map<Integer, List<DiffItem>> resultMap = new HashMap<>();
+
+    if (beforeArray == null || array == null || beforeArray.size() < 1 || array.size() < 1) {
+      resultMap.put(Patch.ALL_UPDATE, new ArrayList<>());
+      return resultMap;
+    }
+
+    List<DiffItem> updateList = new ArrayList<>();
+    List<DiffItem> deleteList = new ArrayList<>();
+    List<DiffItem> insertList = new ArrayList<>();
+    List<DiffItem> moveList = new ArrayList<>();
+    resultMap.put(Patch.TYPE_UPDATE, updateList);
+    resultMap.put(Patch.TYPE_DELETE, deleteList);
+    resultMap.put(Patch.TYPE_INSERT, insertList);
+    resultMap.put(Patch.TYPE_MOVE, moveList);
+
+    realDiffByKey(beforeArray, array, resultMap, true, listener, tClass);
+
+    return resultMap;
+  }
+
+  // 先不考虑被别人调用，判空逻辑基于已知调用，不过多处理
+  private static <T> void realDiffByKey(HippyArray oldArray, HippyArray newArray,
+                                        Map<Integer, List<DiffItem>> resultMap,
+                                        boolean experimental,
+                                        OnTransFormListener<T> listener, Class<T> tClass) {
+    assert resultMap != null;
+
+    List<DiffItem> updateList = resultMap.get(Patch.TYPE_UPDATE);
+    List<DiffItem> deleteList = resultMap.get(Patch.TYPE_DELETE);
+    List<DiffItem> insertList = resultMap.get(Patch.TYPE_INSERT);
+    List<DiffItem> moveList = resultMap.get(Patch.TYPE_MOVE);
+
+    assert updateList != null;
+    assert deleteList != null;
+    assert insertList != null;
+    assert moveList != null;
+
+    int i = 0, oldSize = oldArray.size(), newSize = newArray.size();
+
+    // 第一步：先从头开始遍历 发现不同key就跳出
+    Object o;
+    while (i < oldSize && i < newSize) {
+      o = transForm(oldArray.get(i), listener, tClass);
+      if (isSameKey(o, newArray.get(i))) {
+        // key相同 判断是否需要update
+        handleUpdate(o, newArray.get(i), resultMap, i, newArray.get(i), false, listener, tClass);
+      } else {
+        break;
+      }
+      i++;
+    }
+    int oldLast = oldSize - 1, newLast = newSize - 1;
+    // 第二步：从尾开始遍历 发现不同key跳出
+    while (i <= oldLast && i <= newLast) {
+      o = transForm(oldArray.get(oldLast), listener, tClass);
+      if (isSameKey(o, newArray.get(newLast))) {
+        // key相同 可以判断是否需要update
+        handleUpdate(o, newArray.get(newLast), resultMap, oldLast, newArray.get(newLast), true, listener, tClass);
+      } else {
+        break;
+      }
+      oldLast--;
+      newLast--;
+    }
+    // 第三步：假如新老数据中已经有遍历完的了
+    if (i > oldLast) { // 旧数据已经遍历完，只要添加新数据就行
+      while (i <= newLast) {
+        handleRangeList(insertList, i, newArray.get(i));
+        i++;
+      }
+
+    } else if (i > newLast) {
+      while (i <= oldLast) {
+        handleRangeList(deleteList, i, transForm(oldArray.get(i), listener, tClass));
+        i++;
+      }
+    } else {
+      if (!experimental) {
+        resultMap.put(Patch.ALL_UPDATE, new ArrayList<>());
+        return;
+      }
+      int s1 = i, s2 = i; // 记录第一步遍历到的index
+      Map<String, Integer> keyToNewIndexMap = new HashMap<>(); // 保存新数据中未处理的数据 key：key值，value：数据位置
+      for (i = s2; i <= newLast; i++) {
+        if (realHasKey(newArray.get(i))) {
+          keyToNewIndexMap.put((String) ((HippyMap) newArray.get(i)).get(KEY), i);
+        } else {
+          try {
+            throw new IllegalArgumentException("使用有key的diff算法 每个item必须都有" + KEY + " new" + newArray.get(i));
+          } catch (Exception e) {
+            Log.e("KeyDiffHelper", Log.getStackTraceString(e));
+          }
+          resultMap.put(Patch.ALL_UPDATE, new ArrayList<>());
+          return;
+        }
+      }
+      int j, patched = 0, toBePatched = newLast - s2 + 1, maxNewIndexSoFar = 0; // toBePatched未处理的新数据个数
+      boolean moved = false; // 是否有数据移动
+      int[] newIndexToOldIndexArray = new int[toBePatched];
+      for (i = s1; i <= oldLast; i++) { // 遍历未处理的旧数据
+        Object oldItem = transForm(oldArray.get(i), listener, tClass);
+        if (patched >= toBePatched) { // 新数据已经处理完，剩下的都是要删除的
+          handleRangeList(deleteList, i, oldItem);
+          continue;
+        }
+        Integer newIndex;
+        if (realHasKey(oldItem)) {
+          newIndex = keyToNewIndexMap.get((String) ((HippyMap) oldItem).get(KEY));
+        } else {
+          try {
+            throw new IllegalArgumentException("使用有key的diff算法 每个item必须都有" + KEY + " old" + oldItem);
+          } catch (Exception e) {
+            Log.e("KeyDiffHelper", Log.getStackTraceString(e));
+          }
+          resultMap.put(Patch.ALL_UPDATE, new ArrayList<>());
+          return;
+        }
+        if (newIndex == null) {
+          handleRangeList(deleteList, i, oldItem);
+        } else {
+          newIndexToOldIndexArray[newIndex - s2] = i + 1; // 这里故意加1 区分0
+          if (newIndex >= maxNewIndexSoFar) {
+            maxNewIndexSoFar = newIndex;
+          } else {
+            moved = true;
+          }
+          patched++;
+        }
+      }
+      // 处理新增的item和move的情况
+      Integer[] increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexArray) : new Integer[0];
+      j = increasingNewIndexSequence.length - 1;
+      for (i = toBePatched - 1; i >= 0; i--) {
+        int newIndex = i + s2;
+        if (newIndexToOldIndexArray[i] == 0) {
+          handleRangeList(insertList, newIndex, newArray.get(newIndex), true);
+        } else if (moved) {
+          int oldIndex = newIndexToOldIndexArray[i] - 1;
+          Object oldItem = transForm(oldArray.get(oldIndex), listener, tClass),
+            newItem = newArray.get(newIndex);
+          if (j < 0 || i != increasingNewIndexSequence[j]) {
+            moveList.add(new MoveDiffItem(oldIndex, newIndex, oldItem, newItem));
+          } else {
+            handleUpdate(oldItem, newItem, resultMap, oldIndex, newItem, true, listener, tClass);
+            j--;
+          }
+        }
+      }
+    }
+
+  }
+
+  private static <T> void handleUpdate(Object oldItem, Object newItem,
+                                       Map<Integer, List<DiffItem>> resultMap,
+                                       int rootPosition, Object rootItem, boolean isReverse,
+                                       OnTransFormListener<T> listener, Class<T> tClass) {
+    List<DiffItem> updateList = resultMap.get(Patch.TYPE_UPDATE);
+    assert updateList != null;
+
+    if (oldItem instanceof Boolean) {
+      boolean fromBool = (boolean) oldItem;
+      if (!(newItem instanceof Boolean) || fromBool != (boolean) newItem) {
+        handleRangeList(updateList, rootPosition, rootItem, isReverse);
+      }
+    } else if (oldItem instanceof Number) {
+      boolean isSame = false;
+      double fromDoubleValue = ((Number) oldItem).doubleValue();
+      if (newItem instanceof Number) {
+        double toDoubleValue = ((Number) newItem).doubleValue();
+        isSame = (fromDoubleValue == toDoubleValue);
+      }
+      if (!isSame) {
+        handleRangeList(updateList, rootPosition, rootItem, isReverse);
+      }
+    } else if (oldItem instanceof String) {
+      if (newItem == null || !TextUtils.equals(oldItem.toString(), newItem.toString())) {
+        handleRangeList(updateList, rootPosition, rootItem, isReverse);
+      }
+    } else if (oldItem instanceof HippyArray) {
+      if (newItem instanceof HippyArray) {
+        diffArray((HippyArray) oldItem, (HippyArray) newItem, resultMap, 1, rootPosition, rootItem, listener, tClass);
+      } else {
+        handleRangeList(updateList, rootPosition, rootItem, isReverse);
+      }
+    } else if (oldItem instanceof HippyMap) {
+      if (newItem instanceof HippyMap) {
+        diffMap((HippyMap) oldItem, (HippyMap) newItem, resultMap,
+          1, rootPosition, rootItem, listener, tClass);
+      } else {
+        handleRangeList(updateList, rootPosition, rootItem, isReverse);
+      }
+    }
+  }
+
+  private static <T> Object transForm(Object item, OnTransFormListener<T> listener, Class<T> tClass) {
+    if (listener != null && item.getClass() == tClass) {
+      item = listener.onTransForm((T) item);
+    }
+    return item;
+  }
+
+  public static boolean realHasKey(Object o) {
+    return (o instanceof HippyMap) && (((HippyMap) o).get(KEY) instanceof String)
+      && !TextUtils.isEmpty((String) ((HippyMap) o).get(KEY));
+  }
+
+  public static boolean isSameKey(Object o1, Object o2) {
+    if (realHasKey(o1) && realHasKey(o2)) {
+      return ((String) ((HippyMap) o1).get(KEY)).equals(((HippyMap) o2).get(KEY));
+    }
+    return false;
+  }
+
+  private static Integer[] getSequence(int[] arr) {
+    int[] p = arr.clone();
+    List<Integer> result = new ArrayList<>();
+    result.add(0);
+    int i, j, u, v, c;
+    int len = arr.length;
+    for (i = 0; i < len; i++) {
+      int arrI = arr[i];
+      if (arrI != 0) {
+        j = result.get(result.size() - 1);
+        if (arr[j] < arrI) {
+          p[i] = j;
+          result.add(i);
+          continue;
+        }
+        u = 0;
+        v = result.size() - 1;
+        // 二分查找
+        while (u < v) {
+          c = ((u + v) / 2);
+          if (arr[result.get(c)] < arrI) {
+            u = c + 1;
+          } else {
+            v = c;
+          }
+        }
+        if (arrI < arr[result.get(u)]) {
+          if (u > 0) {
+            p[i] = result.get(u - 1);
+          }
+          result.set(u, i);
+        }
+      }
+    }
+    u = result.size();
+    v = result.get(u - 1);
+    while (u-- > 0) {
+      result.set(u, v);
+      v = p[v];
+    }
+
+    return result.toArray(new Integer[0]);
+  }
+}

package/rules/.source/hippy/extend_views/fastlist/diff/NoKeyDiffHelper.java

@@ -0,0 +1,278 @@
+package com.tencent.extend.views.fastlist.diff;
+
+import static com.tencent.extend.views.fastlist.diff.FastListDataBindingHelper.RangeDiffItem.handleRangeList;
+
+import android.text.TextUtils;
+
+import com.tencent.mtt.hippy.common.HippyArray;
+import com.tencent.mtt.hippy.common.HippyMap;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import com.tencent.extend.views.fastlist.diff.FastListDataBindingHelper.DiffItem;
+import com.tencent.extend.views.fastlist.diff.FastListDataBindingHelper.Patch;
+import com.tencent.extend.views.fastlist.diff.FastListDataBindingHelper.OnTransFormListener;
+import com.tencent.extend.views.fastlist.diff.FastListDataBindingHelper.RangeDiffItem;
+
+/**
+ * 无key diff实现类
+ */
+public class NoKeyDiffHelper {
+
+  /**
+   * 无key diff入口方法
+   *
+   * @param beforeArray 旧数据
+   * @param array       新数据
+   * @param listener    旧数据item转换
+   * @param tClass      旧数据item Class类型
+   * @param <T>         旧数据item类型
+   * @return diff结果map
+   */
+  public static <T> Map<Integer, List<DiffItem>> handleNoKeyDataDiff(HippyArray beforeArray, HippyArray array,
+                                                                     OnTransFormListener<T> listener, Class<T> tClass) {
+
+    Map<Integer, List<DiffItem>> resultMap = new HashMap<>();
+    List<DiffItem> updateList = new ArrayList<>();
+    List<DiffItem> insertList = new ArrayList<>();
+    List<DiffItem> deleteList = new ArrayList<>();
+    resultMap.put(Patch.TYPE_UPDATE, updateList);
+    resultMap.put(Patch.TYPE_INSERT, insertList);
+    resultMap.put(Patch.TYPE_DELETE, deleteList);
+
+    diffArray(beforeArray, array, resultMap, listener, tClass);
+
+    return resultMap;
+  }
+
+  private static <T> void diffArray(HippyArray oldArray, HippyArray newArray,
+                                    Map<Integer, List<DiffItem>> resultMap,
+                                    OnTransFormListener<T> listener, Class<T> tClass) {
+    diffArray(oldArray, newArray, resultMap, 0, -1, null, listener, tClass);
+  }
+
+  public static <T> void diffArray(HippyArray oldArray, HippyArray newArray,
+                                   Map<Integer, List<DiffItem>> resultMap,
+                                   int diffLevel, int rootPosition, Object rootItem,
+                                   OnTransFormListener<T> listener, Class<T> tClass) {
+
+    List<DiffItem> updateList = resultMap.get(Patch.TYPE_UPDATE);
+    List<DiffItem> insertList = resultMap.get(Patch.TYPE_INSERT);
+    List<DiffItem> deleteList = resultMap.get(Patch.TYPE_DELETE);
+
+    assert updateList != null;
+    assert insertList != null;
+    assert deleteList != null;
+
+    if (diffLevel != 0 && oldArray.size() != newArray.size()) {
+      handleRangeList(updateList, rootPosition, rootItem);
+      return;
+    }
+
+    for (int position = 0; position < oldArray.size(); position++) {
+      Object oldItem = oldArray.getObject(position);
+      if (diffLevel == 0 && listener != null && oldItem.getClass() == tClass) {
+        oldItem = listener.onTransForm((T) oldItem);
+      }
+      Object newItem;
+      if (position < newArray.size()) {
+        newItem = newArray.getObject(position);
+      } else { // 说明新数组比较短
+        if (diffLevel != 0) {
+          handleRangeList(updateList, rootPosition, rootItem);
+          return;
+        } else {
+          handleRangeList(deleteList, position, oldItem);
+          continue;
+        }
+      }
+      if (oldItem instanceof Boolean) {
+        boolean fromBool = (boolean) oldItem;
+        if (!(newItem instanceof Boolean) || fromBool != (boolean) newItem) {
+          if (diffLevel != 0) {
+            handleRangeList(updateList, rootPosition, rootItem);
+            return;
+          } else {
+            handleRangeList(updateList, position, newItem);
+          }
+        }
+      } else if (oldItem instanceof Number) {
+        boolean isSame = false;
+        double fromDoubleValue = ((Number) oldItem).doubleValue();
+        if (newItem instanceof Number) {
+          double toDoubleValue = ((Number) newItem).doubleValue();
+          isSame = (fromDoubleValue == toDoubleValue);
+        }
+        if (!isSame) {
+          if (diffLevel != 0) {
+            handleRangeList(updateList, rootPosition, rootItem);
+            return;
+          } else {
+            handleRangeList(updateList, position, newItem);
+          }
+        }
+      } else if (oldItem instanceof String) {
+        if (newItem == null || !TextUtils.equals(oldItem.toString(), newItem.toString())) {
+          if (diffLevel != 0) {
+            handleRangeList(updateList, rootPosition, rootItem);
+            return;
+          } else {
+            handleRangeList(updateList, position, newItem);
+          }
+        }
+      } else if (oldItem instanceof HippyArray) {
+        if (newItem instanceof HippyArray) {
+          if (diffLevel != 0) {
+            int sizeBefore = updateList.size();
+            int innerSizeBefore = -1;
+            RangeDiffItem item = null;
+            if (sizeBefore > 0) {
+              item = (RangeDiffItem) updateList.get(sizeBefore - 1);
+              innerSizeBefore = item.getListSize();
+            }
+            diffArray((HippyArray) oldItem, (HippyArray) newItem, resultMap,
+              diffLevel + 1, rootPosition, rootItem, listener, tClass);
+            // update有新增，不需要继续循环
+            if (sizeBefore != updateList.size() || innerSizeBefore != -1 && innerSizeBefore != item.getListSize()) {
+              break;
+            }
+          } else {
+            diffArray((HippyArray) oldItem, (HippyArray) newItem, resultMap,
+              diffLevel + 1, position, newItem, listener, tClass);
+          }
+        } else {
+          if (diffLevel != 0) {
+            handleRangeList(updateList, rootPosition, rootItem);
+            return;
+          } else {
+            handleRangeList(updateList, position, newItem);
+          }
+        }
+      } else if (oldItem instanceof HippyMap) {
+        if (newItem instanceof HippyMap) {
+          if (diffLevel != 0) {
+            int sizeBefore = updateList.size();
+            int innerSizeBefore = -1;
+            RangeDiffItem item = null;
+            if (sizeBefore > 0) {
+              item = (RangeDiffItem) updateList.get(sizeBefore - 1);
+              innerSizeBefore = item.getListSize();
+            }
+            diffMap((HippyMap) oldItem, (HippyMap) newItem, resultMap,
+              diffLevel + 1, rootPosition, rootItem, listener, tClass);
+            // 这快应该判断是否进入继续循环
+            if (sizeBefore != updateList.size() || innerSizeBefore != -1 && innerSizeBefore != item.getListSize()) {
+              break;
+            }
+          } else {
+            diffMap((HippyMap) oldItem, (HippyMap) newItem, resultMap,
+              diffLevel + 1, position, newItem, listener, tClass);
+          }
+        } else {
+          if (diffLevel != 0) {
+            handleRangeList(updateList, rootPosition, rootItem);
+            return;
+          } else {
+            handleRangeList(updateList, position, newItem);
+          }
+        }
+      }
+    }
+
+    if (newArray.size() > oldArray.size()) {
+      for (int position = oldArray.size(); position < newArray.size(); position++) {
+        if (diffLevel != 0) {
+          handleRangeList(updateList, rootPosition, rootItem);
+        } else {
+          handleRangeList(insertList, position, newArray.get(position));
+        }
+      }
+    }
+  }
+
+  protected static <T> void diffMap(HippyMap oldMap, HippyMap newMap, Map<Integer,
+    List<DiffItem>> resultMap, int diffLevel, int rootPosition, Object rootItem,
+                                    OnTransFormListener<T> listener, Class<T> tClass) {
+    assert resultMap != null;
+
+    List<DiffItem> updateList = resultMap.get(Patch.TYPE_UPDATE);
+
+    assert updateList != null;
+
+    if (oldMap.keySet().size() != newMap.keySet().size()) {
+      handleRangeList(updateList, rootPosition, rootItem);
+      return;
+    }
+
+    for (String key : oldMap.keySet()) {
+      Object oldValue = oldMap.get(key);
+      Object newValue = newMap.get(key);
+
+      if (oldValue instanceof Boolean) {
+        boolean fromBool = (boolean) oldValue;
+        if (!(newValue instanceof Boolean) || fromBool != (boolean) newValue) {
+          handleRangeList(updateList, rootPosition, rootItem);
+          return;
+        }
+      } else if (oldValue instanceof Number) {
+        boolean isSame = false;
+        double fromDoubleValue = ((Number) oldValue).doubleValue();
+        if (newValue instanceof Number) {
+          double toDoubleValue = ((Number) newValue).doubleValue();
+          isSame = (fromDoubleValue == toDoubleValue);
+        }
+        if (!isSame) {
+          handleRangeList(updateList, rootPosition, rootItem);
+          return;
+        }
+      } else if (oldValue instanceof String) {
+        if (newValue == null || !TextUtils.equals(oldValue.toString(), newValue.toString())) {
+          handleRangeList(updateList, rootPosition, rootItem);
+          return;
+        }
+      } else if (oldValue instanceof HippyArray) {
+        if (newValue instanceof HippyArray) {
+          int sizeBefore = updateList.size();
+          int innerSizeBefore = -1;
+          RangeDiffItem item = null;
+          if (sizeBefore > 0) {
+            item = (RangeDiffItem) updateList.get(sizeBefore - 1);
+            innerSizeBefore = item.getListSize();
+          }
+          diffArray((HippyArray) oldValue, (HippyArray) newValue, resultMap,
+            diffLevel + 1, rootPosition, rootItem, listener, tClass);
+          // update有新增，不需要继续循环
+          if (sizeBefore != updateList.size() || innerSizeBefore != -1 && innerSizeBefore != item.getListSize()) {
+            return;
+          }
+        } else {
+          handleRangeList(updateList, rootPosition, rootItem);
+          return;
+        }
+      } else if (oldValue instanceof HippyMap) {
+        if (newValue instanceof HippyMap) {
+          int sizeBefore = updateList.size();
+          int innerSizeBefore = -1;
+          RangeDiffItem item = null;
+          if (sizeBefore > 0) {
+            item = (RangeDiffItem) updateList.get(sizeBefore - 1);
+            innerSizeBefore = item.getListSize();
+          }
+          diffMap((HippyMap) oldValue, (HippyMap) newValue, resultMap,
+            diffLevel + 1, rootPosition, rootItem, listener, tClass);
+          // update有新增，不需要继续循环
+          if (sizeBefore != updateList.size() || innerSizeBefore != -1 && innerSizeBefore != item.getListSize()) {
+            return;
+          }
+        } else {
+          handleRangeList(updateList, rootPosition, rootItem);
+          return;
+        }
+      }
+    }
+  }
+
+}

package/rules/.source/hippy/extend_views/tag/FontTag.java

@@ -0,0 +1,53 @@
+package com.tencent.extend.views.tag;
+
+import android.content.Context;
+import android.text.Editable;
+import android.text.TextUtils;
+import android.text.style.BackgroundColorSpan;
+import android.text.style.ForegroundColorSpan;
+
+import org.xml.sax.Attributes;
+
+/**
+ * Create by sorosunrain on 2021/07/19 15:22
+ */
+public class FontTag extends HtmlTag{
+
+    public FontTag(Context context) {
+        super(context);
+    }
+
+    @Override
+    public void startHandleTag(Editable text, Attributes attributes) {
+        String textColor = attributes.getValue("", "color");
+        String textSize = attributes.getValue("", "size");
+
+        if(!TextUtils.isEmpty(textColor)){
+            int color = getHtmlColor(textColor) | 0xFF000000;
+            start(text, new ForegroundColorSpan(color));
+        }
+
+        if(!TextUtils.isEmpty(textSize)){
+            int size = getHtmlSize(textSize);
+            start(text, new Font(size));
+        }
+    }
+
+    @Override
+    public void endHandleTag(Editable text) {
+        Background b = getLast(text, Background.class); //读取出最后标记类型
+        if (b != null) {
+            end(text, Background.class, new BackgroundColorSpan(b.color)); //设置为Android可以解析的24种ParcelableSpan基本分类，当然也可以自己定义，但需要集成原有的分类
+        }
+
+        final ForegroundColorSpan fc = getLast(text, ForegroundColorSpan.class);
+        if (fc != null) {
+            end(text, ForegroundColorSpan.class, new ForegroundColorSpan(fc.getForegroundColor()));
+        }
+
+        Font f = getLast(text, Font.class);
+        if (f != null) {
+            end(text, Font.class, new TextFontSpan(f.textSize, f.textDecordation, f.fontWeidght)); //使用自定义的
+        }
+    }
+}