@quicktvui/ai 1.0.7 → 1.0.8

package/rules/.source/hippy/hippy_uimanager/RenderNode.java

@@ -0,0 +1,533 @@
+/* Tencent is pleased to support the open source community by making Hippy available.
+ * Copyright (C) 2018 THL A29 Limited, a Tencent company. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.tencent.mtt.hippy.uimanager;
+
+
+import android.text.TextUtils;
+import android.util.Log;
+import android.util.SparseArray;
+import android.view.View;
+
+
+import com.tencent.extend.pm.PageRootNode;
+import com.tencent.extend.pm.WindowNode;
+import com.tencent.mtt.hippy.HippyRootView;
+import com.tencent.mtt.hippy.common.HippyArray;
+import com.tencent.mtt.hippy.common.HippyMap;
+import com.tencent.mtt.hippy.dom.node.NodeProps;
+import com.tencent.mtt.hippy.modules.Promise;
+import com.tencent.mtt.hippy.utils.LogUtils;
+import com.tencent.mtt.hippy.views.list.HippyListItemViewController;
+
+import java.util.*;
+
+@SuppressWarnings({"deprecation", "unused"})
+public class RenderNode {
+
+  final int mId;
+  int mX;
+  int mY;
+  int mWidth;
+  int mHeight;
+
+  boolean mHasUpdateLayout = false;
+  HippyMap mProps = null;
+  HippyMap mPropsToUpdate;
+  final String mClassName;
+  final List<RenderNode> mChildren = new ArrayList<>();
+
+  List<MoveHolder> mMoveHolders = null;
+
+  SparseArray<Integer> mDeletedIdIndexMap;
+
+  List<Promise> mMeasureInWindows = null;
+  Object mTextExtra;
+  Object mTextExtraUpdate;
+
+
+
+  protected HippyRootView mRootView;
+
+  final ControllerManager mComponentManager;
+
+
+  RenderNode mParent = null;
+  WindowNode mWindowRootNode = null;
+
+  boolean mIsDelete = false;
+  boolean mIsRootHasDelete = false;
+
+
+  boolean mIsLazyLoad = false;
+
+  boolean mNotifyManageChildren = false;
+
+  public boolean mHasSetDteblId = false;
+
+  List<UIFunction> mUIFunction = null;
+
+  public RenderNode getParent() {
+    return mParent;
+  }
+
+  int indexFromParent() {
+    if (mParent != null) {
+      return mParent.mChildren.indexOf(this);
+    }
+    return 0;
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder stringBuilder = new StringBuilder();
+    printChild(this, stringBuilder);
+    return stringBuilder.toString();
+  }
+
+  void printChild(RenderNode renderNode, StringBuilder stringBuilder) {
+    stringBuilder.append(" [Id:").append(renderNode.getId()).append(renderNode.mClassName);
+    for (RenderNode child : renderNode.mChildren) {
+      printChild(child, stringBuilder);
+    }
+    stringBuilder.append("]");
+  }
+
+  public RenderNode(int mId, HippyMap mPropsToUpdate, String className, HippyRootView rootView,
+      ControllerManager componentManager,
+      boolean isLazyLoad) {
+    this.mId = mId;
+    this.mPropsToUpdate = mPropsToUpdate;
+    this.mClassName = className;
+    this.mRootView = rootView;
+    this.mComponentManager = componentManager;
+    this.mIsLazyLoad = isLazyLoad;
+    this.mProps = mPropsToUpdate;
+  }
+
+  public void addDeleteId(int id, RenderNode node) {
+    if (shouldUpdateView()) {
+      if (mDeletedIdIndexMap == null) {
+        mDeletedIdIndexMap = new SparseArray<>();
+      }
+      mDeletedIdIndexMap.put(id, mChildren.indexOf(node));
+    }
+  }
+
+  public int getId() {
+    return mId;
+  }
+
+
+  public View createViewRecursive() {
+    View view = createView();
+    mHasUpdateLayout = true;
+    mTextExtraUpdate = mTextExtra;
+    for (RenderNode renderNode : mChildren) {
+      renderNode.createViewRecursive();
+    }
+    return view;
+  }
+
+  public void updateViewRecursive() {
+    update();
+
+    for (RenderNode renderNode : mChildren) {
+      renderNode.updateViewRecursive();
+    }
+  }
+
+  public void forceLayout(){
+    this.mHasUpdateLayout = true;
+  }
+
+  public boolean removeChild(RenderNode uiNode) {
+    uiNode.mParent = null;
+    uiNode.mWindowRootNode = null;
+    return mChildren.remove(uiNode);
+  }
+
+  protected void addChild(RenderNode uiNode, int index) {
+    mChildren.add(index, uiNode);
+    uiNode.mParent = this;
+
+    if (getWindowRootNode() != null) {
+//      if (getWindowRootNode() != null) {
+//        Log.d(WindowNode.TAG, "addChild: " + uiNode + " getWindowRootNode != null " + this);
+//      }
+      uiNode.setWindowRoot(getWindowRootNode());
+    }else{
+      uiNode.setWindowRoot(mWindowRootNode == null && mParent != null  ? mParent.getWindowRootNode() : getWindowRootNode());
+      if(LogUtils.isDebug() && uiNode.getWindowRootNode() == null) {
+        if (mParent != null && mParent.getWindowRootNode() == null) {
+          Log.e(WindowNode.TAG, "addChild error pageRoot is null node: " + this + ",parent:" + mParent);
+        }
+      }
+    }
+
+  }
+
+  public void setWindowRoot(WindowNode mPageRootNode) {
+    this.mWindowRootNode = mPageRootNode;
+  }
+  public WindowNode getWindowRootNode() {
+    return mWindowRootNode == null && mParent != null  ? mParent.getWindowRootNode() : mWindowRootNode;
+  }
+
+  void setLazy(RenderNode node, boolean isLazy)
+  {
+    node.mIsLazyLoad = isLazy;
+    for (int i = 0; i < node.getChildCount(); i++)
+    {
+      final RenderNode cn = node.getChildAt(i);
+      if(HippyListItemViewController.CLASS_NAME.equals(cn.mClassName)){
+        //XXX add by zhaopeng 20201213
+        //这里如果不添加此判断，当ul嵌套时，父层级的List会将子List的view一起创建，导致子List创建失败。
+        //ListView
+        //ListViewItem
+        //ListView
+        //ListViewItem
+        //Image
+        continue;
+      }
+      setLazy(cn, isLazy);
+    }
+  }
+
+  public void setLazy(boolean isLazy) {
+    setLazy(this, isLazy);
+  }
+
+  public void remove(int index) {
+    RenderNode uiNode = mChildren.remove(index);
+    uiNode.mParent = null;
+    uiNode.mWindowRootNode = null;
+  }
+
+  public RenderNode getChildAt(int index) {
+    if (0 <= index && index < getChildCount()) {
+      return mChildren.get(index);
+    }
+    return null;
+  }
+
+  public int getChildCount() {
+    return mChildren.size();
+  }
+
+  public RenderNode(int id, String className, ControllerManager componentManager) {
+    this.mId = id;
+    this.mClassName = className;
+    this.mComponentManager = componentManager;
+  }
+
+  public void updateNode(HippyMap map) {
+    if (mPropsToUpdate != null) {
+      //mProps do not syc to UI
+      HippyMap hippyMap = DiffUtils.diffProps(mPropsToUpdate, map, 0);
+      if (hippyMap != null && hippyMap.size() > 0) {
+        Set<String> sets = hippyMap.keySet();
+        for (String key : sets) {
+          if (TextUtils.equals(NodeProps.STYLE, key)) {
+            HippyMap styles = hippyMap.getMap(key);
+            if (styles != null) {
+              HippyMap stylesToUpdate = mPropsToUpdate.getMap(key);
+              if (stylesToUpdate == null) {
+                stylesToUpdate = new HippyMap();
+              }
+              Set<String> styleKeys = styles.keySet();
+              for (String styleKey : styleKeys) {
+                stylesToUpdate.pushObject(styleKey, styles.get(styleKey));
+              }
+
+              mPropsToUpdate.pushObject(key, stylesToUpdate);
+            }
+          } else {
+            mPropsToUpdate.pushObject(key, hippyMap.get(key));
+          }
+
+        }
+      }
+    } else {
+      mPropsToUpdate = DiffUtils.diffProps(mProps, map, 0);
+    }
+
+    mProps = map;
+  }
+
+  public HippyMap getProps() {
+    return mProps;
+  }
+
+  private boolean shouldCreateView() {
+    return !mIsLazyLoad && !mComponentManager.hasView(mId);
+  }
+
+  public String getClassName() {
+    return mClassName;
+  }
+
+  public int getX() {
+    return mX;
+  }
+
+  public int getY() {
+    return mY;
+  }
+
+  public int getWidth() {
+    return mWidth;
+  }
+
+  public int getHeight() {
+    return mHeight;
+  }
+
+  final List<RenderNode> mChildPendingList = new ArrayList<>();
+
+  public View createView() {
+    //delete is first  when js call delete  and create the same node  if delete is not call the ui cannot create
+    if (mDeletedIdIndexMap != null && mDeletedIdIndexMap.size() > 0) {
+      for (int i = 0; i < mDeletedIdIndexMap.size(); i++) {
+        int key = mDeletedIdIndexMap.keyAt(i);
+        mComponentManager
+            .deleteChild(mId, mDeletedIdIndexMap.keyAt(i), mDeletedIdIndexMap.get(key));
+      }
+      mDeletedIdIndexMap.clear();
+      mNotifyManageChildren = true;
+    }
+
+    if (mIsDelete && TextUtils.equals(NodeProps.ROOT_NODE, mClassName) && !mIsRootHasDelete) {
+      mIsRootHasDelete = true;
+      mComponentManager.deleteRootView(mId);
+    }
+    if (shouldCreateView() && !TextUtils.equals(NodeProps.ROOT_NODE, mClassName)
+        && mParent != null) {
+      mPropsToUpdate = null;
+      mParent.addChildToPendingList(this);
+      return mComponentManager.createView(mRootView, mId, mClassName, mProps);
+
+    }
+    return null;
+  }
+
+  private boolean shouldUpdateView() {
+    return mComponentManager.hasView(mId);
+  }
+
+  public void updateLayoutManual(){
+    if(mComponentManager != null ) {
+      mComponentManager.updateLayout(mClassName, mId, mX, mY, mWidth, mHeight);
+    }
+  }
+
+
+  protected void addChildToPendingList(RenderNode renderNode) {
+    mChildPendingList.add(renderNode);
+  }
+
+  public void update() {
+    LogUtils.d("UINode", "mId" + mId + " updateStyle");
+
+    //		long time = System.currentTimeMillis();
+    if (shouldUpdateView()) {
+      if (mChildPendingList.size() > 0) {
+        Collections.sort(mChildPendingList, new Comparator<RenderNode>() {
+          @Override
+          public int compare(RenderNode o1, RenderNode o2) {
+            return o1.indexFromParent() < o2.indexFromParent() ? -1 : 0;
+          }
+        });
+        for (int i = 0; i < mChildPendingList.size(); i++) {
+          RenderNode renderNode = mChildPendingList.get(i);
+          mComponentManager.addChild(mId, renderNode.getId(), renderNode.indexFromParent());
+        }
+        mChildPendingList.clear();
+        mNotifyManageChildren = true;
+      }
+      if (mPropsToUpdate != null) {
+        mComponentManager.updateView(mId, mClassName, mPropsToUpdate);
+        mPropsToUpdate = null;
+      }
+      if (mMoveHolders != null) {
+        for (MoveHolder moveHolder : mMoveHolders) {
+          Collections.sort(moveHolder.mMoveIds, new Comparator<RenderNode>() {
+            @Override
+            public int compare(RenderNode o1, RenderNode o2) {
+              return o1.indexFromParent() < o2.indexFromParent() ? -1 : 0;
+            }
+          });
+
+          for (int j = 0; j < moveHolder.mMoveIds.size(); j++) {
+            RenderNode moveId = moveHolder.mMoveIds.get(j);
+            mComponentManager.move(moveId.getId(), moveHolder.mMove2Id, moveId.indexFromParent());
+          }
+        }
+        mMoveHolders = null;
+      }
+
+      if (mHasUpdateLayout && !TextUtils.equals(NodeProps.ROOT_NODE, mClassName)) {
+        mComponentManager.updateLayout(mClassName, mId, mX, mY, mWidth, mHeight);
+//        LogUtils.d("UINode", "mId" + mId + " updateLayout");
+        mHasUpdateLayout = false;
+      }
+      if (mTextExtraUpdate != null) {
+        mComponentManager.updateExtra(mId, mClassName, mTextExtraUpdate);
+        mTextExtraUpdate = null;
+      }
+
+      if (mUIFunction != null && mUIFunction.size() > 0) {
+        for (int i = 0; i < mUIFunction.size(); i++) {
+          UIFunction uiFunction = mUIFunction.get(i);
+          mComponentManager
+              .dispatchUIFunction(mId, mClassName, uiFunction.mFunctionName, uiFunction.mParameter,
+                  uiFunction.mPromise);
+        }
+        mUIFunction.clear();
+        mUIFunction = null;
+      }
+      if (mMeasureInWindows != null && mMeasureInWindows.size() > 0) {
+        for (int i = 0; i < mMeasureInWindows.size(); i++) {
+          Promise promise = mMeasureInWindows.get(i);
+          mComponentManager.measureInWindow(mId, promise);
+        }
+        mMeasureInWindows.clear();
+        mMeasureInWindows = null;
+
+      }
+      if (mNotifyManageChildren) {
+        manageChildrenComplete();
+        mNotifyManageChildren = false;
+      }
+
+    }
+//    LogUtils.d("UINode", "mId" + mId + " end updateStyle");
+  }
+
+
+  public void updateLayout(int x, int y, int w, int h) {
+    this.mX = x;
+    this.mY = y;
+    this.mWidth = w;
+    this.mHeight = h;
+    mHasUpdateLayout = true;
+  }
+
+  public void measureInWindow(Promise promise) {
+    if (mMeasureInWindows == null) {
+      mMeasureInWindows = new ArrayList<>();
+    }
+    mMeasureInWindows.add(promise);
+  }
+
+    public void updateViewLayoutRecursive() {
+    }
+
+
+
+
+  static class MoveHolder {
+
+    public MoveHolder(List<RenderNode> moveRenders, int mMove2Id) {
+      this.mMoveIds = moveRenders;
+      this.mMove2Id = mMove2Id;
+    }
+
+    final List<RenderNode> mMoveIds;
+    final int mMove2Id;
+  }
+
+  public void move(List<RenderNode> moveIds, int move2Id) {
+    if (shouldUpdateView()) {
+      if (mMoveHolders == null) {
+        mMoveHolders = new ArrayList<>();
+      }
+      mMoveHolders.add(new MoveHolder(moveIds, move2Id));
+    }
+  }
+
+  public void updateExtra(Object object) {
+    mTextExtra = object;
+    mTextExtraUpdate = object;
+  }
+
+
+  public void setDelete(boolean b) {
+    mIsDelete = b;
+  }
+
+  public boolean isDelete() {
+    return mIsDelete;
+  }
+
+  public void batchComplete() {
+    if (!mIsLazyLoad && !mIsDelete) {
+      mComponentManager.onBatchComplete(mClassName, mId);
+    }
+  }
+
+  public void manageChildrenComplete() {
+    if (!mIsLazyLoad && !mIsDelete) {
+      mComponentManager.onManageChildComplete(mClassName, mId);
+    }
+  }
+
+  static class UIFunction {
+
+    public UIFunction(String functionName, HippyArray parameter, Promise promise) {
+      this.mFunctionName = functionName;
+      this.mParameter = parameter;
+      this.mPromise = promise;
+    }
+
+    final String mFunctionName;
+    final HippyArray mParameter;
+    final Promise mPromise;
+  }
+
+
+  public void dispatchUIFunction(String functionName, HippyArray parameter, Promise promise) {
+    if (mUIFunction == null) {
+      mUIFunction = new ArrayList<>();
+    }
+    mUIFunction.add(new UIFunction(functionName, parameter, promise));
+  }
+
+  public boolean isIsLazyLoad() {
+    return mIsLazyLoad;
+  }
+
+  public void nodeToMap(HippyMap map) {
+    map.pushInt("id", mId);
+    map.pushInt("x", mX);
+    map.pushInt("y", mY);
+    map.pushInt("width", mWidth);
+    map.pushInt("height", mHeight);
+    map.pushString("className", mClassName);
+    map.pushObject("textExtra", mTextExtra);
+    map.pushMap("props", mProps);
+    map.pushBoolean("isLazyLoad", mIsLazyLoad);
+  }
+
+  public void applyByMap(HippyMap map){
+    mX = map.getInt("x");
+    mY = map.getInt("y");
+    mWidth = map.getInt("width");
+    mHeight = map.getInt("height");
+    mTextExtra = map.get("textExtra");
+    mProps = map.getMap("props");
+  }
+
+}

package/rules/.source/hippy/hippy_uimanager/StateView.java

@@ -0,0 +1,17 @@
+package com.tencent.mtt.hippy.uimanager;
+
+import com.tencent.mtt.hippy.common.HippyArray;
+
+public interface StateView {
+
+
+  void setShowOnState(int[] showOnState);
+  void setShowOnCustomState(String[] showOnState);
+
+  void setCustomState(String state,boolean on);
+
+  int STATE_FOCUS_AND_SELECT = 100;
+  int STATE_FOCUS_NO_SELECT = STATE_FOCUS_AND_SELECT + 1;
+  int STATE_SELECT_NO_FOCUS = STATE_FOCUS_AND_SELECT + 2;
+
+}

package/rules/.source/hippy/hippy_uimanager/TransformUtil.java

@@ -0,0 +1,125 @@
+/* Tencent is pleased to support the open source community by making Hippy available.
+ * Copyright (C) 2018 THL A29 Limited, a Tencent company. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.tencent.mtt.hippy.uimanager;
+
+import com.tencent.mtt.hippy.common.HippyArray;
+import com.tencent.mtt.hippy.common.HippyMap;
+
+@SuppressWarnings({"deprecation", "unused"})
+public class TransformUtil {
+
+  private static final ThreadLocal<double[]> sHelperMatrix = new ThreadLocal<double[]>() {
+    @Override
+    protected double[] initialValue() {
+      return new double[16];
+    }
+  };
+
+  private static double convertToRadians(HippyMap transformMap, String key) {
+    double value = 0;
+    boolean inRadians = true;
+    if (transformMap.get(key) instanceof String) {
+      String stringValue = (String) transformMap.get(key);
+      if (stringValue.endsWith("deg")) {
+        inRadians = false;
+      }
+      if (stringValue.endsWith("rad") || stringValue.endsWith("deg")) {
+        stringValue = stringValue.substring(0, stringValue.length() - 3);
+      }
+      value = Float.parseFloat(stringValue);
+    } else if (transformMap.get(key) instanceof Number) {
+      value = ((Number) transformMap.get(key)).doubleValue();
+    }
+    return inRadians ? value : MatrixUtil.degreesToRadians(value);
+  }
+
+  public static void processTransform(HippyArray transforms, double[] result) {
+    double[] helperMatrix = sHelperMatrix.get();
+    MatrixUtil.resetIdentityMatrix(result);
+
+    for (int transformIdx = 0, size = transforms.size(); transformIdx < size; transformIdx++) {
+      HippyMap transform = transforms.getMap(transformIdx);
+      String transformType = transform.keySet().iterator().next();
+
+      assert helperMatrix != null;
+      MatrixUtil.resetIdentityMatrix(helperMatrix);
+      Object value = transform.get(transformType);
+      if ("matrix".equals(transformType) && value instanceof HippyArray) {
+        HippyArray matrix = (HippyArray) value;
+        for (int i = 0; i < 16; i++) {
+          Object matrixValue = matrix.getObject(i);
+          if (matrixValue instanceof Number) {
+            helperMatrix[i] = ((Number) matrixValue).doubleValue();
+          }
+        }
+      } else if ("perspective".equals(transformType) && value instanceof Number) {
+        MatrixUtil.applyPerspective(helperMatrix, ((Number) value).doubleValue());
+      } else if ("rotateX".equals(transformType)) {
+        MatrixUtil.applyRotateX(helperMatrix, convertToRadians(transform, transformType));
+      } else if ("rotateY".equals(transformType)) {
+        MatrixUtil.applyRotateY(helperMatrix, convertToRadians(transform, transformType));
+      } else if ("rotate".equals(transformType) || "rotateZ".equals(transformType)) {
+        MatrixUtil.applyRotateZ(helperMatrix, convertToRadians(transform, transformType));
+      } else if ("scale".equals(transformType) && value instanceof Number) {
+        double scale = ((Number) value).doubleValue();
+        MatrixUtil.applyScaleX(helperMatrix, scale);
+        MatrixUtil.applyScaleY(helperMatrix, scale);
+      } else if ("scaleX".equals(transformType) && value instanceof Number) {
+        MatrixUtil.applyScaleX(helperMatrix, ((Number) value).doubleValue());
+      } else if ("scaleY".equals(transformType)) {
+        MatrixUtil.applyScaleY(helperMatrix, ((Number) value).doubleValue());
+      } else if ("translate".equals(transformType) && value instanceof HippyArray) {
+        double x = 0d, y = 0d, z = 0d;
+
+        if (((HippyArray) value).size() > 0) {
+          Object tranX = ((HippyArray) value).getObject(0);
+          if (tranX instanceof Number) {
+            x = ((Number) tranX).doubleValue();
+          }
+        }
+
+        if (((HippyArray) value).size() > 1) {
+          Object tranY = ((HippyArray) value).getObject(1);
+          if (tranY instanceof Number) {
+            y = ((Number) tranY).doubleValue();
+          }
+        }
+
+        if (((HippyArray) value).size() > 2) {
+          Object tranZ = ((HippyArray) value).getObject(2);
+          if (tranZ instanceof Number) {
+            z = ((Number) tranZ).doubleValue();
+          }
+        }
+        MatrixUtil.applyTranslate3D(helperMatrix, x, y, z);
+      } else if ("translateX".equals(transformType) && value instanceof Number) {
+        MatrixUtil.applyTranslate2D(helperMatrix, ((Number) value).doubleValue(), 0d);
+      } else if ("translateY".equals(transformType) && value instanceof Number) {
+        MatrixUtil.applyTranslate2D(helperMatrix, 0d, ((Number) value).doubleValue());
+      } else if ("skewX".equals(transformType)) {
+        MatrixUtil.applySkewX(helperMatrix, convertToRadians(transform, transformType));
+      } else if ("skewY".equals(transformType)) {
+        MatrixUtil.applySkewY(helperMatrix, convertToRadians(transform, transformType));
+      } else {
+        RuntimeException runtimeException = new RuntimeException(
+            "Unsupported transform type: " + transformType);
+        runtimeException.printStackTrace();
+      }
+
+      MatrixUtil.multiplyInto(result, result, helperMatrix);
+    }
+  }
+}