@quicktvui/ai 1.0.7 → 1.0.8

package/rules/.source/hippy/extend_views/fastlist/ViewTag.java

@@ -0,0 +1,317 @@
+package com.tencent.extend.views.fastlist;
+
+import android.util.Log;
+import android.view.View;
+
+import com.tencent.extend.views.TVTextView;
+import com.tencent.mtt.hippy.common.HippyMap;
+import com.tencent.mtt.hippy.dom.flex.FlexAlign;
+import com.tencent.mtt.hippy.dom.flex.FlexCSSDirection;
+import com.tencent.mtt.hippy.dom.flex.FlexJustify;
+import com.tencent.mtt.hippy.dom.node.DomNode;
+import com.tencent.mtt.hippy.uimanager.RenderNode;
+import com.tencent.mtt.hippy.utils.LogUtils;
+import com.tencent.mtt.hippy.views.list.HippyRecycler;
+
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+class ViewTag {
+  private HashMap<Integer,List<Patch>> pendingPatches;
+  FastAdapter.ElementNode domNode;
+  final RenderNode template;
+  Worker worker;
+
+  boolean enableLoadDelay = false;
+//  boolean viewCreated = false;
+  @Deprecated
+  FastAdapter.ElementNode placeHolderNode;
+  ArrayList<FastAdapter.ElementNode> mDelayLoadNodes;
+//  FastAdapter.ElementNode contentNode;
+
+  ViewTag(RenderNode template) {
+    this.template = template;
+  }
+
+  void addDelayLoad(FastAdapter.ElementNode node){
+    if(mDelayLoadNodes  == null){
+      mDelayLoadNodes = new ArrayList<>();
+    }
+    if(!mDelayLoadNodes.contains(node)) {
+      mDelayLoadNodes.add(node);
+    }
+  }
+
+  List<FastAdapter.ElementNode> getDelayLoadNodes(){
+    return mDelayLoadNodes;
+  }
+
+
+  public FastAdapter.ElementNode getRootNode(){
+    if(domNode == null){
+      domNode = new FastAdapter.ElementNode();
+      domNode.setFlexDirection(FlexCSSDirection.COLUMN);
+      domNode.setAlignItems(FlexAlign.FLEX_START);
+      domNode.setJustifyContent(FlexJustify.FLEX_START);
+      domNode.rootNode = domNode;
+      domNode.isRootItem = true;
+//      domNode.setWrap(FlexWrap.NOWRAP);
+    }
+    return domNode;
+  }
+
+  void cancelWork(){
+    //Log.d("WorkLOG", "WorkLOG cancel this:" + Utils.hashCode(worker));
+    if(worker != null){
+      worker.cancel();
+    }
+    worker = null;
+  }
+
+
+  void work(Worker worker){
+    this.worker = worker;
+    //Log.d("WorkLOG", "WorkLOG work run :" + Utils.hashCode(worker));
+    worker.work();
+    //worker.batch();
+  }
+
+  public void preparePatch(Patch p){
+    if(pendingPatches == null){
+      pendingPatches = new HashMap<>();
+    }
+    final int type = p.type;
+    if(!pendingPatches.containsKey(type)){
+      pendingPatches.put(type,new ArrayList<>());
+    }
+    pendingPatches.get(type).add(p);
+  }
+
+  public List<Patch> getPatches(int type) {
+    return pendingPatches.get(type);
+  }
+
+  public int getPatchesSize(int type){
+    return pendingPatches.containsKey(type) ? pendingPatches.get(type).size() : 0;
+  }
+
+    public void clear() {
+        if(pendingPatches != null){
+          pendingPatches.clear();
+        }
+    }
+
+  public void reset() {
+    if(domNode != null){
+      for(int i = 0; i < domNode.getChildCount(); i ++){
+        final FastAdapter.ElementNode el = (FastAdapter.ElementNode) domNode.getChildAt(i);
+        if(el.boundView != null) {
+          if(LogUtils.isDebug()) {
+            Log.i("ViewTAG","ElementCallback clear callback"+"view:"+el.boundView);
+          }
+          el.boundView.setOnClickListener(null);
+          el.boundView.setOnFocusChangeListener(null);
+//          HippyEngineContext context = ((HippyInstanceContext)el.boundView.getContext()).getEngineContext();
+//          DomNode tDom = context.getDomManager().getNode(template.getId());
+//          Utils.resetNode(el,tDom);
+        }
+        resetElementNode(domNode);
+        //重置嵌套的子列表
+        resetAllView(domNode);
+      }
+    }
+  }
+
+  void resetAllView(DomNode node){
+    if(node instanceof FastAdapter.ElementNode) {
+      final FastAdapter.ElementNode en = (FastAdapter.ElementNode) node;
+      if(en.boundView instanceof FastPendingView){
+        ((FastPendingView) en.boundView).notifyRecycled();
+      }
+      //这里如果打开注释的话，会导致频繁切换tab时，点击事件无效，这里暂注掉
+//      if (en.boundView != null && en.boundView.isFocusable()) {
+//        en.boundView.setOnClickListener(null);
+//        en.boundView.setOnFocusChangeListener(null);
+//      }
+      for(int i = 0; i < node.getChildCount(); i ++){
+        resetAllView(node.getChildAt(i));
+      }
+    }
+  }
+
+
+  public void resetTextView(){
+    if(domNode != null){
+      for(int i = 0; i < domNode.getChildCount(); i ++){
+        resetTextElementNode(domNode);
+      }
+    }
+  }
+
+  void resetTextElementNode(DomNode node){
+    if(node instanceof FastAdapter.ElementNode) {
+      final FastAdapter.ElementNode en = (FastAdapter.ElementNode) node;
+      if(en.boundView instanceof TVTextView){
+        ((HippyRecycler) en.boundView).onResetBeforeCache();
+      }
+      for(int i = 0; i < node.getChildCount(); i ++){
+        resetTextElementNode(node.getChildAt(i));
+      }
+    }
+  }
+
+
+  void resetElementNode(DomNode node){
+    if(node instanceof FastAdapter.ElementNode) {
+      final FastAdapter.ElementNode en = (FastAdapter.ElementNode) node;
+      en.resetState();
+      if(en.boundView instanceof HippyRecycler){
+        ((HippyRecycler) en.boundView).onResetBeforeCache();
+      }
+//      for(int i = 0; i < node.getChildCount(); i ++){
+//        resetElementNode(node.getChildAt(i));
+//      }
+    }
+  }
+
+  static class Patch{
+    final int type;
+    View view;
+    RenderNode boundNode;
+    final static int TYPE_PENDING_CREATE  =0;
+    final static int TYPE_PROP =1;
+    final static int TYPE_PENDING_PRO =2;
+    final static int TYPE_LAYOUT =3;
+    final static int TYPE_EXTRA =4;
+    final static int TYPE_PENDING_LIST =5;
+
+    Patch(int type) {
+      this.type = type;
+    }
+  }
+
+  static class PendingPropPatch extends Patch{
+    String valueKey;
+    String prop;
+    FastAdapter.ElementNode eNode;
+    public PendingPropPatch(RenderNode bindNode, String nodeProp, View view, String valueKey,FastAdapter.ElementNode en) {
+      super(TYPE_PENDING_PRO);
+      this.view = view;
+      this.prop = nodeProp;
+      this.valueKey = valueKey;
+      this.boundNode = bindNode;
+      this.eNode = en;
+    }
+  }
+
+  static class UpdatePropPatch extends Patch{
+    HippyMap data;
+    public UpdatePropPatch(RenderNode bindNode, View view, HippyMap data) {
+      super(TYPE_PROP);
+      this.view = view;
+      this.data = data;
+      this.boundNode = bindNode;
+    }
+  }
+
+  static class UpdateExtraPatch extends Patch{
+    public UpdateExtraPatch(RenderNode bindNode, View view) {
+      super(TYPE_EXTRA);
+      this.view = view;
+      this.boundNode = bindNode;
+    }
+  }
+
+  static class ListItemPatch extends Patch{
+    String prop;
+    public ListItemPatch(RenderNode bindNode, View view,String prop) {
+      super(TYPE_PENDING_LIST);
+      this.view = view;
+      this.boundNode = bindNode;
+      this.prop = prop;
+    }
+  }
+
+  static class UpdateLayoutPatch extends Patch{
+    final int[] layout;
+    FastAdapter.ElementNode eNode;
+    public UpdateLayoutPatch(RenderNode bindNode, View view, FastAdapter.ElementNode node) {
+      super(TYPE_LAYOUT);
+      this.view = view;
+      this.boundNode = bindNode;
+      this.layout = new int[]{bindNode.getX(),bindNode.getY(),bindNode.getWidth(),bindNode.getHeight()};
+      this.eNode = node;
+    }
+
+    public UpdateLayoutPatch(int x,int y,int width,int height, View view,RenderNode bindNode,FastAdapter.ElementNode node) {
+      super(TYPE_LAYOUT);
+      this.view = view;
+      this.boundNode = bindNode;
+      this.layout = new int[]{x,y,width,height};
+      this.eNode = node;
+    }
+
+  }
+
+  static abstract class Worker {
+    private boolean canceled = false;
+    ArrayList<Task> tasks;
+
+    public Worker() {
+    }
+
+    void cancel(){
+      this.canceled = true;
+      if(tasks != null) {
+          for (Task task : tasks) {
+            task.canceled = true;
+          }
+        if(isCanceled()){
+          Log.e("WorkLOG", "cancel workSize:" + tasks.size());
+        }
+          tasks.clear();
+      }
+    }
+
+    void addTask(Task task){
+      if(tasks == null){
+        tasks = new ArrayList<>();
+      }
+      tasks.add(task);
+      //rootView.postDelayed(task,16);
+    }
+
+    abstract void work();
+    void batch(){
+      if(tasks != null) {
+        for (Task task : tasks) {
+          if(isCanceled()){
+              Log.e("WorkLOG", "WorkLOG cancel work !!");
+            break;
+          }
+          if (!task.canceled) {
+            task.run();
+          }else{
+              Log.e("WorkLOG", "WorkLOG cancel work ");
+          }
+        }
+        tasks.clear();
+      }
+    }
+
+    boolean isCanceled(){
+      return canceled;
+    }
+
+  }
+
+  static abstract class Task implements Runnable{
+    boolean canceled = false;
+    int batch = 0;
+  }
+
+}
+
+

package/rules/.source/hippy/extend_views/fastlist/VirtualListView.java

@@ -0,0 +1,8 @@
+package com.tencent.extend.views.fastlist;
+
+import android.view.View;
+
+public interface VirtualListView {
+  View getView();
+  void searchUpdateItemDataByItemID(String id, Object data, boolean traverse);
+}

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

@@ -0,0 +1,320 @@
+package com.tencent.extend.views.fastlist.diff;
+
+import static com.tencent.extend.views.fastlist.diff.KeyDiffHelper.handleKeyDataDiff;
+import static com.tencent.extend.views.fastlist.diff.NoKeyDiffHelper.handleNoKeyDataDiff;
+
+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;
+
+/**
+ * tv-list 实现diff工具类
+ */
+public class FastListDataBindingHelper {
+
+  public interface OnDataDiffListener2 {
+
+    void onMove(int position, int nextPosition);
+
+    void onRangeUpdate(int start, int count);
+
+    void onAllChange();
+  }
+
+  public interface OnDataDiffListener3 extends OnDataDiffListener2 {
+
+    void onRangeInsert(int position, int count);
+
+    void onRangeDelete(int position, int count);
+
+    void onUpdateViewData();
+  }
+
+  // 不需要转换旧数据，直接调用此方法
+  public static void handleDataDiffCallBack3(HippyArray beforeArray, HippyArray array,
+                                             String keyName, OnDataDiffListener3 listener) {
+    handleDataDiffCallBack3(beforeArray, array, keyName, listener, null, null);
+  }
+
+  /**
+   * 回调方式的diff方法
+   *
+   * @param beforeArray       旧数据
+   * @param array             新数据
+   * @param keyName           指定key的名字，String类型   数据没有key值的话，直接传空
+   * @param resultListener    diff结果回调监听
+   * @param transFormListener 处理旧数据item转换
+   * @param tClass            旧数据的Class类型
+   * @param <T>               旧数据的类型
+   */
+  public static <T> void handleDataDiffCallBack3(HippyArray beforeArray, HippyArray array,
+                                                 String keyName, OnDataDiffListener3 resultListener,
+                                                 OnTransFormListener<T> transFormListener, Class<T> tClass) {
+    Map<Integer, List<DiffItem>> resultMap = handleDataDiff(beforeArray, array, keyName, transFormListener, tClass);
+
+    if (resultListener == null) {
+      return;
+    }
+
+    resultListener.onUpdateViewData();
+
+    if (resultMap.get(Patch.ALL_UPDATE) != null) {
+      resultListener.onAllChange();
+      return;
+    }
+
+    List<DiffItem> upList = resultMap.get(Patch.TYPE_UPDATE);
+    List<DiffItem> deList = resultMap.get(Patch.TYPE_DELETE);
+    List<DiffItem> insertList = resultMap.get(Patch.TYPE_INSERT);
+
+    if (!TextUtils.isEmpty(keyName)) {
+      List<DiffItem> moList = resultMap.get(Patch.TYPE_MOVE);
+      handleKeyCallBack(upList, deList, insertList, moList, resultListener, array.size());
+    } else {
+      handleNoKeyCallBack(upList, deList, insertList, resultListener);
+    }
+  }
+
+  private static void handleKeyCallBack(List<DiffItem> upList, List<DiffItem> deList,
+                                        List<DiffItem> insertList, List<DiffItem> moList,
+                                        OnDataDiffListener3 resultListener, int newSize) {
+    // update
+    commonNotify(upList, Patch.TYPE_UPDATE, resultListener);
+    int max = -1, min = -1;
+    // insert
+    if (insertList.size() > 0) {
+      int inMin = commonNotify(insertList, Patch.TYPE_INSERT, resultListener);
+      if (inMin != -1) {
+        min = inMin;
+        max = newSize - 1;
+      }
+    }
+    // move
+    if (moList.size() > 0) {
+      for (int i = 0; i < moList.size(); i++) {
+        if (moList.get(i) instanceof MoveDiffItem) {
+          MoveDiffItem moveDiffItem =
+            (MoveDiffItem) moList.get(i);
+          resultListener.onMove(moveDiffItem.position, moveDiffItem.nextPosition);
+          max = Math.max(max, Math.max(moveDiffItem.position, moveDiffItem.nextPosition));
+          if (min == -1) {
+            min = Math.min(moveDiffItem.position, moveDiffItem.nextPosition);
+          } else {
+            min = Math.min(min, Math.min(moveDiffItem.position, moveDiffItem.nextPosition));
+          }
+        }
+      }
+    }
+    // delete
+    if (deList.size() > 0) {
+
+      for (int i = deList.size() - 1; i >= 0; i--) {
+        RangeDiffItem item = (RangeDiffItem) deList.get(i);
+        resultListener.onRangeDelete(item.position, item.getListSize());
+      }
+
+      int deMin = deList.get(0).position;
+      min = min == -1 ? deMin : Math.min(min, deMin);
+      max = newSize - 1;
+    }
+    if (min != -1 && max != -1 && needRangUpdate(deList, insertList, moList, newSize)) {
+      max = Math.min(max, newSize - 1);
+
+      resultListener.onRangeUpdate(min, max - min + 1);
+    }
+  }
+
+  private static boolean needRangUpdate(List<DiffItem> deList, List<DiffItem> insertList,
+                                        List<DiffItem> moList, int newSize) {
+    if (moList.size() != 0) {
+      return true;
+    }
+    if (deList.size() == 1 && insertList.size() == 0) {
+      RangeDiffItem item = (RangeDiffItem) deList.get(0);
+      return (item.isReverse ? item.getListLast() : item.position) + item.getListSize() != newSize;
+    }
+    if (insertList.size() == 1 && deList.size() == 0) {
+      RangeDiffItem item = (RangeDiffItem) insertList.get(0);
+      return (item.isReverse ? item.getListLast() : item.position) + item.getListSize() != newSize;
+    }
+    return true;
+  }
+
+  private static void handleNoKeyCallBack(List<DiffItem> upList, List<DiffItem> deList,
+                                          List<DiffItem> insertList, OnDataDiffListener3 resultListener) {
+    // update
+    commonNotify(upList, Patch.TYPE_UPDATE, resultListener);
+    // delete
+    commonNotify(deList, Patch.TYPE_DELETE, resultListener);
+    // insert
+    commonNotify(insertList, Patch.TYPE_INSERT, resultListener);
+  }
+
+  private static int commonNotify(List<DiffItem> diffItems, int type, OnDataDiffListener3 resultListener) {
+    int min = -1;
+    if (diffItems.size() > 0) {
+      DiffItem item;
+      for (int i = 0; i < diffItems.size(); i++) {
+        item = diffItems.get(i);
+        if (item instanceof RangeDiffItem) {
+          int minPos = ((RangeDiffItem) item).notify(type, resultListener);
+          min = min == -1 ? minPos : Math.min(minPos, min);
+        }
+      }
+    }
+    return min;
+  }
+
+  // 不需要转换旧数据，直接调用此方法
+  public static Map<Integer, List<DiffItem>> handleDataDiff(HippyArray beforeArray, HippyArray array,
+                                                            String keyName) {
+    return handleDataDiff(beforeArray, array, keyName, null, null);
+  }
+
+  /**
+   * 无回调形式的diff方法，结果直接返回
+   *
+   * @param beforeArray 旧数据
+   * @param array       新数据
+   * @param keyName     指定key的名字，String类型   数据没有key值的话，直接传空
+   * @param listener    处理旧数据item转换
+   * @param tClass      旧数据的Class类型
+   * @param <T>         旧数据的类型
+   * @return 包含list结果的Map
+   */
+  public static <T> Map<Integer, List<DiffItem>> handleDataDiff(HippyArray beforeArray, HippyArray array,
+                                                                String keyName,
+                                                                OnTransFormListener<T> listener, Class<T> tClass) {
+    if (beforeArray == null || array == null || beforeArray.size() < 1 || array.size() < 1) {
+      Map<Integer, List<DiffItem>> resultMap = new HashMap<>();
+      resultMap.put(Patch.ALL_UPDATE, new ArrayList<>());
+      return resultMap;
+    }
+    if (!TextUtils.isEmpty(keyName)) {
+      return handleKeyDataDiff(beforeArray, array, keyName, listener, tClass);
+    } else {
+      return handleNoKeyDataDiff(beforeArray, array, listener, tClass);
+    }
+  }
+
+  public static class MoveDiffItem extends DiffItem {
+    public final int nextPosition;
+    public final Object nextItem;
+
+    public MoveDiffItem(int position, int nextPosition, Object item, Object nextItem) {
+      super(position, item);
+      this.nextPosition = nextPosition;
+      this.nextItem = nextItem;
+    }
+  }
+
+  public static class RangeDiffItem extends DiffItem {
+
+    protected final List<Integer> posList = new ArrayList<>();
+
+    protected final boolean isReverse;
+
+    public static void handleRangeList(List<DiffItem> rangeList,
+                                       int position, Object item) {
+      handleRangeList(rangeList, position, item, false);
+    }
+
+    public static void handleRangeList(List<DiffItem> rangeList,
+                                       int position, Object item, boolean isReverse) {
+
+      if (rangeList.size() < 1) {
+        rangeList.add(RangeDiffItem.getInstance(null, position, item, isReverse));
+      } else {
+        // 获取最近添加的数据
+        RangeDiffItem diffItem = (RangeDiffItem) rangeList.get(rangeList.size() - 1);
+
+        RangeDiffItem instance = RangeDiffItem.getInstance(diffItem, position, item, isReverse);
+        if (instance != null) {
+          rangeList.add(instance);
+        }
+      }
+    }
+
+    public static RangeDiffItem getInstance(RangeDiffItem diffItem, int nowPosition,
+                                            Object nowItem, boolean isReverse) {
+      if (diffItem != null && nowPosition == diffItem.getListLast() + (isReverse ? -1 : 1)) {
+        diffItem.addPosition(nowPosition);
+        return null;
+      } else {
+        return new RangeDiffItem(nowPosition, nowItem, isReverse);
+      }
+    }
+
+    public RangeDiffItem(int position, Object item, boolean isReverse) {
+      super(position, item);
+      this.isReverse = isReverse;
+      posList.add(position);
+    }
+
+    public int notify(int type, OnDataDiffListener3 listener) {
+      int pos = isReverse ? getListLast() : position;
+      switch (type) {
+        case Patch.TYPE_UPDATE:
+          listener.onRangeUpdate(pos, getListSize());
+          break;
+        case Patch.TYPE_INSERT:
+          listener.onRangeInsert(pos, getListSize());
+          break;
+        case Patch.TYPE_DELETE:
+          listener.onRangeDelete(pos, getListSize());
+          break;
+      }
+      return pos;
+    }
+
+    public int getListSize() {
+      return posList.size();
+    }
+
+    private void addPosition(int nowPosition) {
+      posList.add(nowPosition);
+    }
+
+    private Integer getListLast() {
+      return posList.get(posList.size() - 1);
+    }
+  }
+
+  public static class DiffItem {
+
+    public final int position;
+    public final Object item;
+
+    public DiffItem(int position, Object item) {
+      this.position = position;
+      this.item = item;
+    }
+
+    @Override
+    public String toString() {
+      return "DiffItem{" +
+        "position=" + position +
+        ", item=" + item +
+        '}';
+    }
+  }
+
+  public static class Patch {
+
+    public static final int TYPE_UPDATE = 0; // 更新
+    public static final int TYPE_DELETE = 1; // 删除
+    public static final int TYPE_INSERT = 2; // 插入
+    public static final int TYPE_MOVE = 3; // 移动 目前移动的情况，没有判断该数据有没有update
+    public static final int ALL_UPDATE = 4; // 通知全部更新
+  }
+
+  public interface OnTransFormListener<T> {
+    HippyMap onTransForm(T item);
+  }
+}