@quicktvui/ai 1.0.7 → 1.0.8

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

@@ -0,0 +1,349 @@
+/* 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.view.MotionEvent;
+import android.view.View;
+import android.view.ViewConfiguration;
+import com.tencent.mtt.hippy.HippyEngineContext;
+import com.tencent.mtt.hippy.HippyInstanceContext;
+import com.tencent.mtt.hippy.adapter.monitor.HippyEngineMonitorAdapter;
+import com.tencent.mtt.hippy.common.HippyMap;
+import com.tencent.mtt.hippy.dom.node.NodeProps;
+import com.tencent.mtt.hippy.modules.javascriptmodules.EventDispatcher;
+import com.tencent.mtt.hippy.utils.ExtendUtil;
+import com.tencent.mtt.hippy.utils.LogUtils;
+import com.tencent.mtt.hippy.utils.PixelUtil;
+
+import java.util.HashSet;
+
+@SuppressWarnings({"deprecation", "unused"})
+public class NativeGestureDispatcher implements NativeGestureProcessor.Callback {
+
+  private static final String TAG = "NativeGestureDispatcher";
+  private static final String KEY_EVENT_NAME = "name";
+  private static final String KEY_TAG_ID = "id";
+  private static final String KEY_PAGE_X = "page_x";
+  private static final String KEY_PAGE_Y = "page_y";
+  private static final int TAP_TIMEOUT = ViewConfiguration.getTapTimeout();
+
+  private static final View.OnClickListener mOnClickListener = new View.OnClickListener() {
+    @Override
+    public void onClick(final View view) {
+      if(LogUtils.isDebug()) {
+        Log.i("DebugClick", "onClick in NativeGestureDispatcher : view :"+ExtendUtil.debugView(view));
+      }
+      if (view != null && view.getContext() instanceof HippyInstanceContext) {
+        view.postDelayed(new Runnable() {
+          @Override
+          public void run() {
+            int tagId = view.getId();
+            handleClick(view, ((HippyInstanceContext) view.getContext())
+                .getEngineContext(), tagId, false);
+          }
+        }, TAP_TIMEOUT);
+      }
+
+    }
+  };
+  private static final View.OnLongClickListener mOnLongClickListener = new View.OnLongClickListener() {
+    @Override
+    public boolean onLongClick(final View view) {
+      if (view != null && view.getContext() instanceof HippyInstanceContext) {
+        view.postDelayed(new Runnable() {
+          @Override
+          public void run() {
+            int tagId = view.getId();
+            handleLongClick(((HippyInstanceContext) view.getContext())
+                .getEngineContext(), tagId);
+          }
+        }, TAP_TIMEOUT);
+
+
+      }
+      return true;
+    }
+  };
+
+  private static final View.OnAttachStateChangeListener mOnAttachedToWindowListener = new View.OnAttachStateChangeListener() {
+
+    @Override
+    public void onViewAttachedToWindow(View view) {
+      if (view != null && view.getContext() instanceof HippyInstanceContext) {
+        int tagId = view.getId();
+        handleAttachedToWindow(((HippyInstanceContext) view.getContext())
+            .getEngineContext(), tagId);
+      }
+    }
+
+    @Override
+    public void onViewDetachedFromWindow(View view) {
+
+    }
+  };
+
+  private static final View.OnAttachStateChangeListener mOnDetachedFromWindowListener = new View.OnAttachStateChangeListener() {
+
+    @Override
+    public void onViewAttachedToWindow(View view) {
+
+    }
+
+    @Override
+    public void onViewDetachedFromWindow(View view) {
+      if (view != null && view.getContext() instanceof HippyInstanceContext) {
+        int tagId = view.getId();
+        handleDetachedFromWindow(((HippyInstanceContext) view.getContext())
+            .getEngineContext(), tagId);
+      }
+    }
+  };
+
+  private final View mTargetView;
+  private HashSet<String> mGestureTypes = null;
+  private NativeGestureProcessor mGestureProcessor;
+  private HippyEngineContext mEngineContext;
+
+  public NativeGestureDispatcher(View view) {
+    mTargetView = view;
+    if (view != null && view.getContext() instanceof HippyInstanceContext) {
+      mEngineContext = ((HippyInstanceContext) view.getContext()).getEngineContext();
+    }
+  }
+
+  public static View.OnClickListener getOnClickListener() {
+    return mOnClickListener;
+  }
+
+  public static View.OnLongClickListener getOnLongClickListener() {
+    return mOnLongClickListener;
+  }
+
+  public static View.OnAttachStateChangeListener getOnAttachedToWindowListener() {
+    return mOnAttachedToWindowListener;
+  }
+
+  public static View.OnAttachStateChangeListener getOnDetachedFromWindowListener() {
+    return mOnDetachedFromWindowListener;
+  }
+
+  public static void handleClick(View target, HippyEngineContext context, int tagId,
+      boolean isCustomEvent) {
+    if (context == null) {
+      return;
+    }
+
+    HippyEngineMonitorAdapter monitorAdapter = context.getGlobalConfigs().getEngineMonitorAdapter();
+    if (monitorAdapter != null && target != null) {
+      monitorAdapter.reportClickEvent(target, isCustomEvent);
+    }
+
+    HippyMap params = new HippyMap();
+    params.pushString(KEY_EVENT_NAME, NodeProps.ON_CLICK);
+    params.pushInt(KEY_TAG_ID, tagId);
+    params.pushString("sid", ExtendUtil.getViewSID(target));
+    context.getModuleManager().getJavaScriptModule(EventDispatcher.class)
+        .receiveNativeGesture(params);
+    LogUtils.d("DebugClick", "send msg: " + NodeProps.ON_CLICK);
+  }
+
+  public static void handleLongClick(HippyEngineContext context, int tagId) {
+    if (context == null) {
+      return;
+    }
+    HippyMap params = new HippyMap();
+    params.pushString(KEY_EVENT_NAME, NodeProps.ON_LONG_CLICK);
+    params.pushInt(KEY_TAG_ID, tagId);
+    context.getModuleManager().getJavaScriptModule(EventDispatcher.class)
+        .receiveNativeGesture(params);
+  }
+
+  public static void handleAttachedToWindow(HippyEngineContext context, int tagId) {
+    if (context == null) {
+      return;
+    }
+    context.getModuleManager().getJavaScriptModule(EventDispatcher.class)
+        .receiveUIComponentEvent(tagId, NodeProps.ON_ATTACHED_TO_WINDOW, null);
+  }
+
+  public static void handleDetachedFromWindow(HippyEngineContext context, int tagId) {
+    if (context == null) {
+      return;
+    }
+    context.getModuleManager().getJavaScriptModule(EventDispatcher.class)
+        .receiveUIComponentEvent(tagId, NodeProps.ON_DETACHED_FROM_WINDOW, null);
+  }
+
+  public static void handlePressIn(HippyEngineContext context, int tagId) {
+    if (context == null) {
+      return;
+    }
+    HippyMap params = new HippyMap();
+    params.pushString(KEY_EVENT_NAME, NodeProps.ON_PRESS_IN);
+    params.pushInt(KEY_TAG_ID, tagId);
+    context.getModuleManager().getJavaScriptModule(EventDispatcher.class)
+        .receiveNativeGesture(params);
+    LogUtils.d(TAG, "send msg: " + NodeProps.ON_PRESS_IN);
+  }
+
+  public static void handlePressOut(HippyEngineContext context, int tagId) {
+    if (context == null) {
+      return;
+    }
+    HippyMap params = new HippyMap();
+    params.pushString(KEY_EVENT_NAME, NodeProps.ON_PRESS_OUT);
+    params.pushInt(KEY_TAG_ID, tagId);
+    context.getModuleManager().getJavaScriptModule(EventDispatcher.class)
+        .receiveNativeGesture(params);
+    LogUtils.d(TAG, "send msg: " + NodeProps.ON_PRESS_IN);
+  }
+
+  public static void handleTouchDown(HippyEngineContext context, int mTagId, float x, float y,
+      int viewId) {
+    int[] viewCoords = new int[2];
+    getLocationInWindow(context, viewId, viewCoords);
+    HippyMap params = new HippyMap();
+    params.pushString(KEY_EVENT_NAME, NodeProps.ON_TOUCH_DOWN);
+    params.pushInt(KEY_TAG_ID, mTagId);
+    params.pushDouble(KEY_PAGE_X, PixelUtil.px2dp(viewCoords[0] + x));
+    params.pushDouble(KEY_PAGE_Y, PixelUtil.px2dp(viewCoords[1] + y));
+    context.getModuleManager().getJavaScriptModule(EventDispatcher.class)
+        .receiveNativeGesture(params);
+  }
+
+  public static void handleTouchMove(HippyEngineContext context, int mTagId, float x, float y,
+      int viewId) {
+    int[] viewCoords = new int[2];
+    getLocationInWindow(context, viewId, viewCoords);
+    HippyMap params = new HippyMap();
+    params.pushString(KEY_EVENT_NAME, NodeProps.ON_TOUCH_MOVE);
+    params.pushInt(KEY_TAG_ID, mTagId);
+    params.pushDouble(KEY_PAGE_X, PixelUtil.px2dp(viewCoords[0] + x));
+    params.pushDouble(KEY_PAGE_Y, PixelUtil.px2dp(viewCoords[1] + y));
+    context.getModuleManager().getJavaScriptModule(EventDispatcher.class)
+        .receiveNativeGesture(params);
+  }
+
+  public static void handleTouchEnd(HippyEngineContext context, int mTagId, float x, float y,
+      int viewId) {
+    int[] viewCoords = new int[2];
+    getLocationInWindow(context, viewId, viewCoords);
+    HippyMap params = new HippyMap();
+    params.pushString(KEY_EVENT_NAME, NodeProps.ON_TOUCH_END);
+    params.pushInt(KEY_TAG_ID, mTagId);
+    params.pushDouble(KEY_PAGE_X, PixelUtil.px2dp(viewCoords[0] + x));
+    params.pushDouble(KEY_PAGE_Y, PixelUtil.px2dp(viewCoords[1] + y));
+    context.getModuleManager().getJavaScriptModule(EventDispatcher.class)
+        .receiveNativeGesture(params);
+  }
+
+  public static void handleTouchCancel(HippyEngineContext context, int mTagId, float x, float y,
+      int viewId) {
+    int[] viewCoords = new int[2];
+    getLocationInWindow(context, viewId, viewCoords);
+    HippyMap params = new HippyMap();
+    params.pushString(KEY_EVENT_NAME, NodeProps.ON_TOUCH_CANCEL);
+    params.pushInt(KEY_TAG_ID, mTagId);
+    params.pushDouble(KEY_PAGE_X, PixelUtil.px2dp(viewCoords[0] + x));
+    params.pushDouble(KEY_PAGE_Y, PixelUtil.px2dp(viewCoords[1] + y));
+    context.getModuleManager().getJavaScriptModule(EventDispatcher.class)
+        .receiveNativeGesture(params);
+  }
+
+//	private static void calculateViewCoords(float[] viewCoords, RenderNode node)
+//	{
+//		if (node != null)
+//		{
+//			viewCoords[0] = viewCoords[0] + node.getX();
+//			viewCoords[1] = viewCoords[1] + node.getY();
+//			calculateViewCoords(viewCoords, node.mParent);
+//		}
+//	}
+
+  private static void getLocationInWindow(HippyEngineContext context, int id, int[] viewCoords) {
+    if (id >= 0) {
+      View view = context.getRenderManager().getControllerManager().findView(id);
+      if (view != null) {
+        view.getLocationInWindow(viewCoords);
+      }
+    }
+  }
+
+  public boolean handleTouchEvent(MotionEvent event) {
+    if (mGestureProcessor == null) {
+      mGestureProcessor = new NativeGestureProcessor(this);
+    }
+    return mGestureProcessor.onTouchEvent(event);
+  }
+
+  public void addGestureType(String type) {
+    if (mGestureTypes == null) {
+      mGestureTypes = new HashSet<>();
+    }
+    mGestureTypes.add(type);
+  }
+
+  public void removeGestureType(String type) {
+    if (mGestureTypes != null) {
+      mGestureTypes.remove(type);
+    }
+  }
+
+  @Override
+  public boolean needHandle(String type) {
+    if (mGestureTypes != null) {
+
+      boolean result = mGestureTypes.contains(type);
+      if (!result && !TextUtils.equals(type, NodeProps.ON_INTERCEPT_TOUCH_EVENT) && !TextUtils
+          .equals(type, NodeProps.ON_INTERCEPT_PULL_UP_EVENT)) {
+        if (needHandle(NodeProps.ON_INTERCEPT_TOUCH_EVENT) || needHandle(
+            NodeProps.ON_INTERCEPT_PULL_UP_EVENT)) {
+          return true;
+        }
+      }
+      return result;
+    }
+    return false;
+  }
+
+  @Override
+  public void handle(String type, float x, float y) {
+    if (mTargetView == null) {
+      LogUtils.e("NativeGestureDispatcher", "handle!!! but view is null!!!!");
+      return;
+    }
+
+    if (TextUtils.equals(type, NodeProps.ON_PRESS_IN)) {
+      handlePressIn(mEngineContext, mTargetView.getId());
+    } else if (TextUtils.equals(type, NodeProps.ON_PRESS_OUT)) {
+      handlePressOut(mEngineContext, mTargetView.getId());
+    } else if (TextUtils.equals(type, NodeProps.ON_TOUCH_DOWN)) {
+      NativeGestureDispatcher
+          .handleTouchDown(mEngineContext, mTargetView.getId(), x, y, mTargetView.getId());
+    } else if (TextUtils.equals(type, NodeProps.ON_TOUCH_MOVE)) {
+      NativeGestureDispatcher
+          .handleTouchMove(mEngineContext, mTargetView.getId(), x, y, mTargetView.getId());
+    } else if (TextUtils.equals(type, NodeProps.ON_TOUCH_END)) {
+      NativeGestureDispatcher
+          .handleTouchEnd(mEngineContext, mTargetView.getId(), x, y, mTargetView.getId());
+    } else if (TextUtils.equals(type, NodeProps.ON_TOUCH_CANCEL)) {
+      NativeGestureDispatcher
+          .handleTouchCancel(mEngineContext, mTargetView.getId(), x, y, mTargetView.getId());
+    }
+  }
+}

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

@@ -0,0 +1,188 @@
+/* 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.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.view.MotionEvent;
+import android.view.ViewConfiguration;
+
+import com.tencent.mtt.hippy.dom.node.NodeProps;
+
+@SuppressWarnings({"unused"})
+public class NativeGestureProcessor {
+
+  static final int PRESS_IN = 1;
+  static final int PRESS_OUT = 2;
+  private static final int TAP_TIMEOUT = ViewConfiguration.getTapTimeout();
+  @SuppressWarnings("deprecation")
+  private static final int TOUCH_SLOP = ViewConfiguration.getTouchSlop();
+
+  boolean mNoPressIn = false;
+  final Callback mCallback;
+  private Handler mHandler;
+
+  private float mLastPressInX = 0;
+  private float mLastPressInY = 0;
+
+  public NativeGestureProcessor(Callback callback) {
+    this.mCallback = callback;
+  }
+
+  public Handler getGestureHandler() {
+    if (mHandler == null) {
+      mHandler = new GestureHandler(this);
+    }
+    return mHandler;
+  }
+
+  private Callback getCallback() {
+    return mCallback;
+  }
+
+  public boolean onTouchEvent(MotionEvent event) {
+    int action = event.getAction() & MotionEvent.ACTION_MASK;
+    boolean handle = false;
+    switch (action) {
+      case MotionEvent.ACTION_DOWN: {
+        if (mCallback.needHandle(NodeProps.ON_PRESS_IN)) {
+          mNoPressIn = false;
+          mLastPressInX = event.getX();
+          mLastPressInY = event.getY();
+          getGestureHandler().sendEmptyMessageDelayed(PRESS_IN, TAP_TIMEOUT);
+          handle = true;
+        } else {
+          mNoPressIn = true;
+        }
+
+        if (mCallback.needHandle(NodeProps.ON_TOUCH_DOWN)) {
+          mCallback.handle(NodeProps.ON_TOUCH_DOWN, event.getX(), event.getY());
+          handle = true;
+        }
+
+        if (!handle && mCallback.needHandle(NodeProps.ON_TOUCH_MOVE)) {
+          handle = true;
+        }
+
+        if (!handle && mCallback.needHandle(NodeProps.ON_TOUCH_END)) {
+          handle = true;
+        }
+
+        if (!handle && mCallback.needHandle(NodeProps.ON_TOUCH_CANCEL)) {
+          handle = true;
+        }
+        break;
+      }
+      case MotionEvent.ACTION_MOVE: {
+        if (mCallback.needHandle(NodeProps.ON_TOUCH_MOVE)) {
+          mCallback.handle(NodeProps.ON_TOUCH_MOVE, event.getX(), event.getY());
+          handle = true;
+        }
+
+        if (!handle && mCallback.needHandle(NodeProps.ON_TOUCH_END)) {
+          handle = true;
+        }
+
+        if (!handle && mCallback.needHandle(NodeProps.ON_TOUCH_CANCEL)) {
+          handle = true;
+        }
+
+        if (!mNoPressIn) {
+          float distX = Math.abs(event.getX() - mLastPressInX);
+          float distY = Math.abs(event.getY() - mLastPressInY);
+          if (distX > TOUCH_SLOP || distY > TOUCH_SLOP) {
+            getGestureHandler().removeMessages(PRESS_IN);
+            mNoPressIn = true;
+          }
+        }
+
+        break;
+      }
+      case MotionEvent.ACTION_UP: {
+        if (mCallback.needHandle(NodeProps.ON_TOUCH_END)) {
+          mCallback.handle(NodeProps.ON_TOUCH_END, event.getX(), event.getY());
+          handle = true;
+        }
+
+        if (mNoPressIn && mCallback.needHandle(NodeProps.ON_PRESS_OUT)) {
+          mCallback.handle(NodeProps.ON_PRESS_OUT, event.getX(), event.getY());
+          handle = true;
+        } else if (!mNoPressIn && mCallback.needHandle(NodeProps.ON_PRESS_OUT)) {
+          getGestureHandler().sendEmptyMessageDelayed(PRESS_OUT, TAP_TIMEOUT);
+          handle = true;
+        }
+
+        break;
+      }
+      case MotionEvent.ACTION_CANCEL:
+      case MotionEvent.ACTION_OUTSIDE: {
+        if (mCallback.needHandle(NodeProps.ON_TOUCH_CANCEL)) {
+          mCallback.handle(NodeProps.ON_TOUCH_CANCEL, event.getX(), event.getY());
+          handle = true;
+        }
+
+        if (mNoPressIn && mCallback.needHandle(NodeProps.ON_PRESS_OUT)) {
+          mCallback.handle(NodeProps.ON_PRESS_OUT, event.getX(), event.getY());
+          handle = true;
+        } else if (!mNoPressIn && mCallback.needHandle(NodeProps.ON_PRESS_OUT)) {
+          if (getGestureHandler().hasMessages(PRESS_IN)) {
+            getGestureHandler().removeMessages(PRESS_IN);
+            break;
+          }
+          getGestureHandler().sendEmptyMessageDelayed(PRESS_OUT, TAP_TIMEOUT);
+          handle = true;
+        }
+        break;
+      }
+    }
+    return handle;
+  }
+
+  public interface Callback {
+
+    boolean needHandle(String type);
+
+    void handle(String type, float x, float y);
+  }
+
+  private static class GestureHandler extends android.os.Handler {
+
+    private final NativeGestureProcessor mDispatcher;
+    private final NativeGestureProcessor.Callback mCallback;
+
+    public GestureHandler(NativeGestureProcessor dispatcher) {
+      super(Looper.getMainLooper());
+      mDispatcher = dispatcher;
+      mCallback = mDispatcher.getCallback();
+    }
+
+    @Override
+    public void handleMessage(Message msg) {
+      switch (msg.what) {
+        case PRESS_IN: {
+          mCallback.handle(NodeProps.ON_PRESS_IN, -1, -1);
+          mDispatcher.mNoPressIn = true;
+          break;
+        }
+        case PRESS_OUT: {
+          mCallback.handle(NodeProps.ON_PRESS_OUT, -1, -1);
+          break;
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,43 @@
+/* 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.HippyRootView;
+import com.tencent.mtt.hippy.common.HippyMap;
+
+@SuppressWarnings({"deprecation", "unused"})
+public class PullFooterRenderNode extends ListItemRenderNode {
+
+  public PullFooterRenderNode(int mId, HippyMap mPropsToUpdate, String className,
+      HippyRootView mRootView, ControllerManager componentManager,
+      boolean isLazyLoad) {
+    super(mId, mPropsToUpdate, className, mRootView, componentManager, isLazyLoad);
+  }
+
+  /**
+   * 通过类名的hashCode来定义type，计算出来是一个很大的值，几乎不会和前端类型重复
+   */
+  @Override
+  public int getItemViewType() {
+    return this.getClassName().hashCode();
+  }
+
+  @Override
+  public boolean isPullFooter() {
+    return true;
+  }
+}

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

@@ -0,0 +1,43 @@
+/* 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.HippyRootView;
+import com.tencent.mtt.hippy.common.HippyMap;
+
+@SuppressWarnings({"deprecation", "unused"})
+public class PullHeaderRenderNode extends ListItemRenderNode {
+
+  public PullHeaderRenderNode(int mId, HippyMap mPropsToUpdate, String className,
+      HippyRootView mRootView, ControllerManager componentManager,
+      boolean isLazyLoad) {
+    super(mId, mPropsToUpdate, className, mRootView, componentManager, isLazyLoad);
+  }
+
+  /**
+   * 通过类名的hashCode来定义type，计算出来是一个很大的值，几乎不会和前端类型重复
+   */
+  @Override
+  public int getItemViewType() {
+    return this.getClassName().hashCode();
+  }
+
+  @Override
+  public boolean isPullHeader() {
+    return true;
+  }
+}