@quicktvui/ai 1.0.7 → 1.0.8

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

@@ -0,0 +1,130 @@
+package com.tencent.extend.views.fastlist;
+
+import android.content.Context;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.tencent.mtt.hippy.HippyRootView;
+import com.tencent.mtt.hippy.annotation.HippyController;
+import com.tencent.mtt.hippy.annotation.HippyControllerProps;
+import com.tencent.mtt.hippy.common.HippyArray;
+import com.tencent.mtt.hippy.common.HippyMap;
+import com.tencent.mtt.hippy.modules.Promise;
+import com.tencent.mtt.hippy.uimanager.ControllerManager;
+import com.tencent.mtt.hippy.uimanager.RenderNode;
+import com.tencent.mtt.hippy.utils.LogUtils;
+import com.tencent.mtt.hippy.views.view.HippyViewGroup;
+import com.tencent.mtt.hippy.views.view.HippyViewGroupController;
+
+
+@HippyController(
+        name = FastFlexViewController.CLASS_NAME
+)
+public class FastFlexViewController extends HippyViewGroupController implements PendingViewController {
+    public static final String CLASS_NAME = "FastFlexView";
+
+    public FastFlexViewController() {
+    }
+
+
+  @Override
+  protected void addView(ViewGroup parentView, View view, int index) {
+//    super.addView(parentView, view, index);
+  }
+
+
+  @HippyControllerProps(name = PendingViewController.PROP_LIST, defaultType = HippyControllerProps.ARRAY)
+  public void setListData(final View lv, HippyArray list){
+    if(lv instanceof FastFlexView){
+      ((FastFlexView) lv).setPendingData(list, Utils.getRenderNode(lv));
+    }
+  }
+
+  protected View createViewImpl(Context context) {
+        //return new FastFlexView(context);
+        return null;
+    }
+
+    @Override
+    protected View createViewImpl(Context context, HippyMap iniProps) {
+      FastFlexView fastFlexView = new FastFlexView(context);
+      if(iniProps != null && iniProps.containsKey("enablePlaceholder")){
+        fastFlexView.setEnablePlaceholder(iniProps.getBoolean("enablePlaceholder"));
+//        Log.e("ZHAOPENG","createViewImpl flex enablePlaceholder " +iniProps.getBoolean("enablePlaceholder"));
+      }
+      return fastFlexView;
+    }
+
+
+    @Override
+    public RenderNode createRenderNode(int id, HippyMap props, String className, HippyRootView hippyRootView, ControllerManager controllerManager, boolean lazy) {
+        return new FastFlexNode(id, props, className, hippyRootView, controllerManager, lazy);
+    }
+
+//  @HippyControllerProps(name = "enablePlaceholder", defaultType = HippyControllerProps.BOOLEAN, defaultBoolean = true)
+//  public void setEnablePlaceholder(View view, boolean enable) {
+//    if (view instanceof FastFlexView) {
+//      ((FastFlexView) view).setEnablePlaceholder(enable);
+//    }
+//  }
+
+  @Override
+  public void setPendingData(View view, Object data, RenderNode templateNode,boolean useDiff) {
+      if(LogUtils.isDebug()) {
+        Log.i("FastFlexLog", "setPendingData InFlexController data:" + data + ",templateNode:" + templateNode + ",view:" + view);
+      }
+    if(view instanceof FastFlexView){
+      ((FastFlexView) view).setPendingData(data,templateNode,useDiff);
+    }
+  }
+
+  @Override
+  public void setPendingData(View view, Object data, RenderNode templateNode) {
+    this.setPendingData(view,data,templateNode,false);
+  }
+
+  @HippyControllerProps(name = "cachePool", defaultType = HippyControllerProps.MAP)
+  public void setCacheSizeMap(View view,HippyMap map) {
+      if(view instanceof FastFlexView) {
+        ((FastFlexView) view).setCachePoolMap(map);
+      }
+  }
+
+  @HippyControllerProps(name = "useDiff", defaultType = HippyControllerProps.BOOLEAN, defaultBoolean = false)
+  public void setUseDiff(View view, boolean useDiff) {
+    if(view instanceof FastFlexView) {
+      ((FastFlexView) view).setUseDiff(useDiff);
+    }
+  }
+
+  @HippyControllerProps(name = "keyName", defaultType = HippyControllerProps.STRING)
+  public void setUseDiff(View view, String keyName) {
+    if(view instanceof FastFlexView) {
+      ((FastFlexView) view).setKeyName(keyName);
+    }
+  }
+
+  @HippyControllerProps(name = "firstFocusChild", defaultType = HippyControllerProps.MAP)
+  public void setTouchScrollEnable(FastFlexView view, HippyMap map) {
+    view.getFirstFocusHelper().setFirstFocusChildMap(map);
+  }
+
+  @Override
+  public void dispatchFunction(HippyViewGroup view, String functionName, HippyArray var, Promise promise) {
+    super.dispatchFunction(view, functionName, var, promise);
+    if (view instanceof FastFlexView) {
+      switch (functionName){
+        case "updateItem":
+          ((FastFlexView) view).updateItem(var.getInt(0), var.getObject(1));
+          break;
+      }
+    }
+
+  }
+
+  @HippyControllerProps(name = "sharedItemStore", defaultType = HippyControllerProps.STRING)
+  public void setSharedItemStore(final FastFlexView lv, String name) {
+    lv.setSharedItemStore(name);
+  }
+}

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

@@ -0,0 +1,67 @@
+package com.tencent.extend.views.fastlist;
+
+import android.util.Log;
+import android.view.View;
+
+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.modules.Promise;
+import com.tencent.mtt.hippy.uimanager.ControllerManager;
+import com.tencent.mtt.hippy.uimanager.RenderNode;
+import com.tencent.mtt.hippy.utils.LogUtils;
+
+public class FastItemNode extends RenderNode {
+    final ControllerManager controllerManager;
+
+    public FastItemNode(int mId, HippyMap mPropsToUpdate, String className, HippyRootView rootView, ControllerManager componentManager, boolean isLazyLoad) {
+        super(mId, mPropsToUpdate, className, rootView, componentManager, isLazyLoad);
+        this.controllerManager = componentManager;
+
+    }
+
+    public static boolean isFastItemNode(RenderNode node){
+      return node instanceof FastItemNode;
+    }
+
+
+    @Override
+    public View createView() {
+        return super.createView();
+    }
+
+    @Override
+    public void updateLayout(int x, int y, int w, int h) {
+        //zhaopeng 这里由于模版view在ListViwe中的位置由adapter在bind时确定，所以这时没有理由可以updateLayout
+//        super.updateLayout(x, y, w, h);
+    }
+
+    @Override
+    public void dispatchUIFunction(String functionName, HippyArray parameter, Promise promise) {
+        if(LogUtils.isDebug()) {
+          Log.d("FastList", "-- FastItemNode dispatchUIFunction functionName:" + functionName + ",parameter:" + parameter);
+        }
+        super.dispatchUIFunction(functionName, parameter, promise);
+        //FIXME 可能由于此列表不再正常受控制，所有导致dispatchUIFunction时parameter传递的参数会有错误
+       // controllerManager.dispatchUIFunction(getId(),getClassName(),functionName,parameter,promise);
+    }
+
+
+
+    @Override
+    public void batchComplete() {
+        super.batchComplete();
+    }
+
+
+
+    public void updateViewRecursive(){
+        //zhaopeng 这里不进行update，因为模版不需要
+    }
+
+
+
+  public View getBoundView() {
+      return controllerManager.findView(getId());
+  }
+}

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

@@ -0,0 +1,306 @@
+package com.tencent.extend.views.fastlist;
+
+import android.content.Context;
+import android.graphics.Color;
+import android.util.Log;
+import android.view.View;
+
+import com.tencent.extend.views.IRecyclerItemView;
+import com.tencent.mtt.hippy.common.HippyArray;
+import com.tencent.mtt.hippy.common.HippyMap;
+import com.tencent.mtt.hippy.modules.Promise;
+import com.tencent.mtt.hippy.uimanager.HippyViewEvent;
+import com.tencent.mtt.hippy.uimanager.RenderNode;
+import com.tencent.mtt.hippy.utils.LogUtils;
+import com.tencent.mtt.hippy.views.view.HippyViewGroup;
+
+public class FastItemView extends HippyViewGroup implements IRecyclerItemView, FastAdapter.ScrollTaskHandler, FastAdapter.ItemContainer {
+    private FastListView parentListView;
+    private FastFlexView parentFlexView;
+    protected int bindPosition = -1;
+    protected Object bindItem = null;
+    protected int JSEventViewID = -1;
+    boolean enablePlaceholder = false;
+    boolean disablePlaceholderFocus = false;
+    public FastItemView(Context context) {
+        super(context);
+        setClipChildren(false);
+        setFocusable(false);
+    }
+
+    public void setParentListView(FastListView parentListView) {
+      this.parentListView = parentListView;
+    }
+
+    public void setParentFlexView(FastFlexView parentFlexView) {
+      this.parentFlexView = parentFlexView;
+    }
+
+  public void setJSEventViewID(int JSEventViewID) {
+    this.JSEventViewID = JSEventViewID;
+  }
+
+  public void updateInstance(int index, Object object) {
+
+    }
+
+  @Override
+  public HippyMap getScrollOverride() {
+    HippyMap map =  super.getScrollOverride();
+    if (map != null) {
+      return map;
+    }
+    if (getContentView() instanceof HippyViewGroup) {
+      return ((HippyViewGroup) getContentView()).getScrollOverride();
+    }
+    return null;
+  }
+
+  public FastListView getParentListView() {
+    return parentListView;
+  }
+
+  public FastFlexView getParentFlexView() {
+    return parentFlexView;
+  }
+
+  public void updateItemDataInList(int position, Object object){
+      assert getId() != -1;
+      FastPendingView parent = parentListView;
+      if(LogUtils.isDebug()){
+        Log.i("FastItemViewLog","updateIteDataInList id："+getId()+",parent:"+parent);
+      }
+      if(parent != null){
+        parent.updateItem(position,object);
+      }else{
+        throw new IllegalStateException("updateItemProps error, parent cant be null here,position:"+position);
+      }
+    }
+
+    private FastPendingView findParent(){
+      if(getParent() instanceof FastPendingView){
+        return (FastPendingView) getParent();
+      }
+      if(LogUtils.isDebug()){
+        Log.d("FastItemViewLog","findParent step 1 null id："+getId()+",parent:"+getParent());
+      }
+      final RenderNode node = Utils.getRenderNode(this);
+      if(node != null && node.getParent() != null){
+        final View view =  Utils.findBoundView(getHippyContext(),node.getParent());
+        if(view instanceof FastPendingView){
+          return (FastPendingView) view;
+        }
+      }
+      if(LogUtils.isDebug()){
+        Log.e("FastItemViewLog","findParent final null id："+getId()+",parent:"+getParent());
+      }
+      return null;
+    }
+
+
+    public void batchUpdate(int position) {
+
+    }
+
+    public static FastItemView findTemplateItemView(View view){
+      if(view instanceof FastItemView){
+        return (FastItemView) view;
+      }
+      if(view .getParent() instanceof View) {
+        return findTemplateItemView((View) view.getParent());
+      }
+      return null;
+    }
+
+    public void updateItemProps(String name,int anInt, HippyMap map, boolean aBoolean) {
+      FastPendingView parent = parentListView;
+      if(LogUtils.isDebug()){
+        Log.i("FastItemViewLog","updateItemProps id："+getId()+",parent:"+parent+",name:"+name+",pos:"+anInt);
+      }
+      if(parent != null){
+        parent.updateItemProps(name,anInt,map,aBoolean);
+      }else{
+        throw new IllegalStateException("updateItemProps error, parent cant be null here,name:"+name+",position:"+anInt);
+      }
+    }
+
+  public void dispatchItemFunction(HippyArray var, Promise promise) {
+    FastPendingView parent = parentListView;
+    if(LogUtils.isDebug()){
+      Log.i("FastItemViewLog","dispatchItemFunction id："+getId()+",parent:"+parent);
+    }
+    if(parent != null){
+      parent.dispatchItemFunction(var,promise);
+    }else{
+      throw new IllegalStateException("dispatchItemFunction error, parent cant be null,var："+var);
+    }
+  }
+
+  HippyViewEvent itemEvent;
+
+
+
+  protected HippyViewEvent getItemEvent(){
+    if(itemEvent == null){
+      itemEvent = new HippyViewEvent("onItemViewEvent");
+    }
+    return itemEvent;
+  }
+
+  protected HippyMap generateItemEventMap(String eventName,int position,Object item){
+    HippyMap hm = new HippyMap();
+    hm.pushString("eventName",eventName);
+    hm.pushInt("position",position);
+    hm.pushObject("itemData",item);
+    return hm;
+  }
+
+  @Override
+  public void onBind(View parent, int position, Object item) {
+    this.bindPosition = position;
+    this.bindItem = item;
+    if(JSEventViewID > -1) {
+      getItemEvent().send(JSEventViewID, getHippyContext(), generateItemEventMap("bind", position, item));
+    }
+  }
+
+  @Override
+  public void onCreate(View parent) {
+    if(JSEventViewID > -1) {
+      getItemEvent().send(JSEventViewID, getHippyContext(),generateItemEventMap("create", -1, null));
+    }
+  }
+
+  @Override
+  public void onUnBind(View parent, int position, Object item) {
+    this.bindPosition = -1;
+    this.bindItem = null;
+    if(JSEventViewID > -1) {
+      getItemEvent().send(JSEventViewID, getHippyContext(), generateItemEventMap("unBind", position, item));
+    }
+  }
+
+
+  @Override
+  public void onAttachToWindow(View parent, int position, Object item) {
+    if(JSEventViewID > -1) {
+      getItemEvent().send(JSEventViewID, getHippyContext(), generateItemEventMap("attach", position, item));
+    }
+  }
+
+  @Override
+  public void onDetachFromWindow(View parent, int position, Object item) {
+    if(JSEventViewID > -1) {
+      getItemEvent().send(JSEventViewID, getHippyContext(), generateItemEventMap("detach", position, item));
+    }
+  }
+
+  @Override
+  public void clearPostTask(int type) {
+
+  }
+
+  @Override
+  public void notifyDetachFromParent() {
+
+  }
+
+  @Override
+  public void notifyAttachToParent() {
+
+  }
+
+  @Override
+  public void notifyBringToFront(boolean front) {
+    if(JSEventViewID > -1) {
+      if (front) {
+        getItemEvent().send(JSEventViewID, getHippyContext(), generateItemEventMap("toFront", bindPosition, bindItem));
+      } else {
+        getItemEvent().send(JSEventViewID, getHippyContext(), generateItemEventMap("toBack", bindPosition, bindItem));
+      }
+    }
+  }
+
+
+  @Override
+  public void notifyPauseTask() {
+    if(JSEventViewID > -1) {
+      getItemEvent().send(JSEventViewID, getHippyContext(), generateItemEventMap("pause", bindPosition, bindItem));
+    }
+  }
+
+  @Override
+  public void notifyResumeTask() {
+    if(JSEventViewID > -1) {
+      getItemEvent().send(JSEventViewID, getHippyContext(), generateItemEventMap("resume", bindPosition, bindItem));
+    }
+  }
+
+
+  @Override
+  public View getItemView() {
+    return this;
+  }
+
+
+  @Override
+  public View getContentView() {
+    if(getChildCount() > 0){
+      return getChildAt(0);
+    }
+    return null;
+  }
+
+  @Override
+  protected void drawableStateChanged() {
+    super.drawableStateChanged();
+    if (enablePlaceholder && isFocusable() && getContentView() != null && !disablePlaceholderFocus) {
+      getContentView().refreshDrawableState();
+    }
+  }
+
+  @Override
+  public void toggle(boolean toPlaceholder) {
+    if(!enablePlaceholder){
+      return;
+    }
+    final View content = getContentView();
+    if(toPlaceholder){
+      if (content != null) {
+        content.setAlpha(0);
+      }
+      setBackgroundColor(placeholderBackgroundColor);
+    }else {
+      if (content != null) {
+        if(!disablePlaceholderFocus) {
+          content.setDuplicateParentStateEnabled(true);
+        }
+        content.setAlpha(1);
+      }
+      setBackgroundColor(Color.TRANSPARENT);
+    }
+  }
+
+
+  public void setEnablePlaceholder(boolean enablePlaceholder) {
+    this.enablePlaceholder = enablePlaceholder;
+  }
+
+  int placeholderBackgroundColor;
+  float placeholderBorderRadius = 0;
+
+  public void configPlaceholder(int placeholderBackgroundColor, float placeholderBorderRadius) {
+      if(enablePlaceholder) {
+        this.placeholderBackgroundColor = placeholderBackgroundColor;
+        this.placeholderBorderRadius = placeholderBorderRadius;
+        if (getContentView() != null) {
+          setBackgroundColor(placeholderBackgroundColor);
+        }
+        setBorderRadius(placeholderBorderRadius, BorderRadiusDirection.ALL.ordinal());
+      }
+  }
+
+  public void setDisablePlaceholderFocus(boolean disablePlaceholderFocus) {
+      this.disablePlaceholderFocus = disablePlaceholderFocus;
+  }
+}

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

@@ -0,0 +1,106 @@
+package com.tencent.extend.views.fastlist;
+
+import android.content.Context;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.tencent.mtt.hippy.HippyRootView;
+import com.tencent.mtt.hippy.annotation.HippyController;
+import com.tencent.mtt.hippy.annotation.HippyControllerProps;
+import com.tencent.mtt.hippy.common.HippyArray;
+import com.tencent.mtt.hippy.common.HippyMap;
+import com.tencent.mtt.hippy.modules.Promise;
+import com.tencent.mtt.hippy.uimanager.ControllerManager;
+import com.tencent.mtt.hippy.uimanager.HippyViewController;
+import com.tencent.mtt.hippy.uimanager.RenderNode;
+import com.tencent.mtt.hippy.utils.LogUtils;
+import com.tencent.mtt.hippy.views.view.HippyViewGroup;
+
+
+@HippyController(
+        name = FastItemViewController.CLASS_NAME
+)
+public class FastItemViewController extends HippyViewController<FastItemView> {
+    public static final String CLASS_NAME = "FastItemView";
+    public static final String TAG = "FastItemViewLog";
+
+    public FastItemViewController() {
+    }
+
+  @Override
+  protected void addView(ViewGroup parentView, View view, int index) {
+    super.addView(parentView, view, index);
+  }
+
+
+  protected View createViewImpl(Context context) {
+        return new FastItemView(context);
+    }
+
+    @Override
+    protected View createViewImpl(Context context, HippyMap iniProps) {
+//      if(iniProps != null) {
+//        if (iniProps.containsKey("type")) {
+//          Log.d(CLASS_NAME, "createViewImpl hasType:" + iniProps.get("type"));
+//        } else {
+//          //throw new IllegalArgumentException("tv-item必须指定type属性");
+//          Log.e(CLASS_NAME, "createViewImpl eror hasType null");
+//        }
+//      }
+        return super.createViewImpl(context, iniProps);
+    }
+
+
+    @Override
+    public RenderNode createRenderNode(int id, HippyMap props, String className, HippyRootView hippyRootView, ControllerManager controllerManager, boolean lazy) {
+        return new FastItemNode(id, props, className, hippyRootView, controllerManager, lazy);
+    }
+
+
+  @HippyControllerProps(name = "focusScrollTarget", defaultType = HippyControllerProps.BOOLEAN,defaultBoolean = false)
+  public void setFocusScrollTarget(FastItemView view, boolean enable) {
+    if(view != null){
+      view.setFocusScrollTarget(enable);
+    }
+  }
+
+  @Override
+  public void dispatchFunction(FastItemView view, String functionName, HippyArray params, Promise promise) {
+    super.dispatchFunction(view, functionName, params, promise);
+    switch (functionName) {
+      case "dispatchItemFunctionWithPromise":
+        view.dispatchItemFunction(params,promise);
+        break;
+    }
+  }
+
+  @Override
+  public void dispatchFunction(FastItemView view, String functionName, HippyArray var) {
+    if (LogUtils.isDebug()) {
+      Log.d(TAG, "dispatchFunction functionName:" + functionName + ",var :" + var);
+    }
+    super.dispatchFunction(view,functionName,var);
+    switch (functionName) {
+      case "updateInstance":
+        view.updateInstance(var.getInt(0),var.getObject(1));
+        break;
+      case "updateItem":
+        view.updateItemDataInList(var.getInt(0),var.getObject(1));
+        break;
+      case "batch":
+        view.batchUpdate(var.getInt(0));
+        break;
+      case "updateItemProps":
+        view.updateItemProps(var.getString(0), var.getInt(1),var.getMap(2),var.getBoolean(3));
+        break;
+      case "dispatchItemFunction":
+        view.dispatchItemFunction(var,null);
+        break;
+
+
+    }
+  }
+
+
+}

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

@@ -0,0 +1,95 @@
+package com.tencent.extend.views.fastlist;
+
+
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.util.Log;
+
+import com.tencent.extend.FocusManagerModule;
+import com.tencent.mtt.hippy.HippyEngineContext;
+import com.tencent.mtt.hippy.annotation.HippyMethod;
+import com.tencent.mtt.hippy.annotation.HippyNativeModule;
+import com.tencent.mtt.hippy.common.HippyArray;
+import com.tencent.mtt.hippy.modules.nativemodules.HippyNativeModuleBase;
+
+import java.util.HashMap;
+
+@HippyNativeModule(name = "FastListModule")
+public class FastListModule extends HippyNativeModuleBase {
+  public static HashMap<Integer, GlobalConfig> globalConfig;
+  private GlobalConfig config;
+  public FastListModule(HippyEngineContext context) {
+    super(context);
+    config = new GlobalConfig();
+    if(globalConfig == null){
+      globalConfig = new HashMap<>();
+    }
+    globalConfig.put(context.hashCode(),config);
+  }
+
+  @HippyMethod(name = "clearAllCache")
+  public void clearAllCache() {
+    if(FastAdapter.gSharedCachePools != null){
+      FastAdapter.gSharedCachePools.clear();
+      FastAdapter.gSharedCachePools = null;
+    }
+  }
+
+  @HippyMethod(name = "setPlaceholderIcon")
+  public void setPlaceholderIcon(HippyArray array) {
+    Log.i("FastListModule","setPlaceholderIcon array:"+array);
+    config.placeholderIcon = array.getString(0);
+    config.placeholderIconSize = array.getArray(1);
+  }
+
+  @HippyMethod(name = "setPlaceholderBorderRadius")
+  public void setPlaceholderIcon(int radius) {
+    Log.i("FastListModule","setPlaceholderBorderRadius radius:"+radius);
+    config.placeholderBorderRadius = radius;
+  }
+
+  @HippyMethod(name = "scrollFactor")
+  public void setScrollFactor(float scrollFactor) {
+    Log.i("FastListModule","scrollFactor scrollFactor:"+scrollFactor);
+    config.scrollFactor = scrollFactor;
+  }
+
+  @HippyMethod(name = "setFadeEnabled")
+  public void setFadeEnabled(boolean fadeImageEnable) {
+    Log.i("FastListModule","setFadeEnabled fadeImageEnable:"+fadeImageEnable);
+    config.fadeImageEnable = fadeImageEnable;
+  }
+
+  @HippyMethod(name = "setDefaultFadingEdgeLength")
+  public void setFadingEdgeLength(double length) {
+    Log.i("FastListModule","setDefaultFadingEdgeLength length:"+length);
+    config.defaultFadingEdgeLength = (float) length;
+  }
+
+  @HippyMethod(name = "setFadeDuration")
+  public void setFadeDuration(int duration) {
+    Log.i("FastListModule","setFadeDuration duration:"+duration);
+    config.fadeDuration = duration;
+  }
+
+  public static class GlobalConfig {
+    public String placeholderIcon = null;
+    public HippyArray placeholderIconSize = null;
+    public float scrollFactor = 1.2f;
+    public int placeholderBorderRadius = 8;
+    public float defaultFadingEdgeLength = 0.0f;
+    public boolean fadeImageEnable = false;
+    public int fadeDuration = 500;
+  }
+
+  public static @NonNull FastListModule.GlobalConfig getGlobalConfig(@Nullable HippyEngineContext context){
+    FastListModule.GlobalConfig config = null;
+    if (globalConfig != null && context != null) {
+      config = globalConfig.get(context.hashCode());
+    }
+    if (config != null) {
+      return config;
+    }
+    return new FastListModule.GlobalConfig();
+  }
+}