@Override
public void onPause() {
    super.onPause();
    WXComponent comp = mInstance.getRootComponent();
    if (comp != null) {
        WXEvent events = comp.getDomObject().getEvents();
        boolean hasDeactived = events.contains(UConstants.Event.DEACTIVED);
        if (hasDeactived) {
            WXBridgeManager.getInstance().fireEvent(mInstance.getInstanceId(), comp.getRef(), UConstants.Event.DEACTIVED, null, null);
        }
    }
    if (mIsShakeDetectorStarted && mShakeDetector != null) {
        mShakeDetector.stop();
        mIsShakeDetectorStarted = false;
    }
}
 

WXComponent createBodyOnDomThread(WXDomObject dom) {
  if (mWXSDKInstance == null) {
    return null;
  }
  WXDomObject domObject = new WXDomObject();
  domObject.type = WXBasicComponentType.DIV;
  domObject.ref = "god";
  mGodComponent = (WXVContainer) WXComponentFactory.newInstance(mWXSDKInstance, domObject, null);
  mGodComponent.createView(null, -1);
  if (mGodComponent == null) {
    if (WXEnvironment.isApkDebugable()) {
      WXLogUtils.e("rootView failed!");
    }
    //TODO error callback
    return null;
  }
  FrameLayout frameLayout = (FrameLayout) mGodComponent.getView();
  ViewGroup.LayoutParams layoutParams = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
  frameLayout.setLayoutParams(layoutParams);
  frameLayout.setBackgroundColor(Color.TRANSPARENT);

  WXComponent component = generateComponentTree(dom, mGodComponent);
  mGodComponent.addChild(component);
  mRegistry.put(component.getRef(), component);
  return component;
}
 

private void setAppearanceWatch(WXComponent component, int event, boolean enable) {
  AppearanceHelper item = mAppearComponents.get(component.getRef());
  if (item != null) {
    item.setWatchEvent(event, enable);
  } else if (!enable) {
    //Do nothing if disable target not exist.
  } else {
    WXComponent dChild = findDirectListChild(component);
    int index = mChildren.indexOf(dChild);
    if (index != -1) {
      item = new AppearanceHelper(component, index);
      item.setWatchEvent(event, true);
      mAppearComponents.put(component.getRef(), item);
    }
  }
}
 

/**
 * @param child the inserted child
 * @param index the index of the child to be inserted.
 * @see #addChild(WXComponent)
 */
@Override
public void addChild(WXComponent child, int index) {
  super.addChild(child, index);

  if (child == null || index < -1) {
    return;
  }
  int count = mChildren.size();
  index = index >= count ? -1 : index;
  bindViewType(child);

  int adapterPosition = index == -1 ? mChildren.size() - 1 : index;
  T view = getHostView();
  if (view != null) {
    view.getRecyclerViewBaseAdapter().notifyItemInserted(adapterPosition);
  }
  relocateAppearanceHelper();
}
 

private void loadConstructor(){
  Class<? extends WXComponent> c = mCompClz;
  Constructor<? extends WXComponent> constructor;
  try {
    constructor = c.getConstructor(WXSDKInstance.class, WXDomObject.class, WXVContainer.class);
  } catch (NoSuchMethodException e) {
    WXLogUtils.d("ClazzComponentCreator","Use deprecated component constructor");
    try {
      //compatible deprecated constructor with 4 args
      constructor = c.getConstructor(WXSDKInstance.class, WXDomObject.class, WXVContainer.class, boolean.class);
    } catch (NoSuchMethodException e1) {
      try {
        //compatible deprecated constructor with 5 args
        constructor = c.getConstructor(WXSDKInstance.class, WXDomObject.class, WXVContainer.class,String.class, boolean.class);
      } catch (NoSuchMethodException e2) {
        throw new WXRuntimeException("Can't find constructor of component.");
      }
    }
  }
  mConstructor = constructor;
}
 

private WXComponent generateComponentTree(WXDomObject dom, WXVContainer parent) {
  if (dom == null || parent == null) {
    return null;
  }
  WXComponent component = WXComponentFactory.newInstance(mWXSDKInstance, dom,
                                                         parent, parent.isLazy());

  mRegistry.put(dom.ref, component);
  if (component instanceof WXVContainer) {
    WXVContainer parentC = (WXVContainer) component;
    int count = dom.childCount();
    WXDomObject child = null;
    for (int i = 0; i < count; ++i) {
      child = dom.getChild(i);
      if (child != null) {
        parentC.addChild(generateComponentTree(child, parentC));
      }
    }
  }

  return component;
}
 

/**
 * Update the specified component's dom and mark it as old.
 * @param component the component to be updated
 */
private void updateDomObj(WXComponent component) {
  if (component == null) {
    return;
  }
  WXDomObject domObject = mRegistry.get(component.getRef());
  if (domObject == null) {
    return;
  }
  domObject.old();
  component.updateDom(domObject.clone());
  if (component instanceof WXVContainer) {
    WXVContainer container = (WXVContainer) component;
    int count = container.childCount();
    for (int i = 0; i < count; ++i) {
      updateDomObj(container.getChild(i));
    }
  }
}
 

/**
 * create RootView ，every weex Instance View has a rootView;
 * @see com.taobao.weex.dom.WXDomStatement#createBody(JSONObject)
 */
void createBody(WXComponent component) {
  long start = System.currentTimeMillis();
  component.createView(mGodComponent, -1);
  if (WXEnvironment.isApkDebugable()) {
    WXLogUtils.renderPerformanceLog("createView", (System.currentTimeMillis() - start));
  }
  start = System.currentTimeMillis();
  component.applyLayoutAndEvent(component);
  component.bindData(component);

  if (WXEnvironment.isApkDebugable()) {
    WXLogUtils.renderPerformanceLog("bind", (System.currentTimeMillis() - start));
  }

  if (component instanceof WXScroller) {
    WXScroller scroller = (WXScroller) component;
    if (scroller.getView() instanceof ScrollView) {
      mWXSDKInstance.setRootScrollView((ScrollView) scroller.getView());
    }
  }
  mWXSDKInstance.setRootView(mGodComponent.getRealView());
  if (mWXSDKInstance.getRenderStrategy() != WXRenderStrategy.APPEND_ONCE) {
    mWXSDKInstance.onViewCreated(mGodComponent);
  }
}
 

private void loadConstructor(){
  Class<? extends WXComponent> c = mCompClz;
  Constructor<? extends WXComponent> constructor;
  try {
    constructor = c.getConstructor(WXSDKInstance.class, WXDomObject.class, WXVContainer.class);
  } catch (NoSuchMethodException e) {
    WXLogUtils.d("ClazzComponentCreator","Use deprecated component constructor");
    try {
      //compatible deprecated constructor with 4 args
      constructor = c.getConstructor(WXSDKInstance.class, WXDomObject.class, WXVContainer.class, boolean.class);
    } catch (NoSuchMethodException e1) {
      try {
        //compatible deprecated constructor with 5 args
        constructor = c.getConstructor(WXSDKInstance.class, WXDomObject.class, WXVContainer.class,String.class, boolean.class);
      } catch (NoSuchMethodException e2) {
        throw new WXRuntimeException("Can't find constructor of component.");
      }
    }
  }
  mConstructor = constructor;
}
 

/**
 *
 * @param loading should be {@link WXRefreshView}
 */
public void setFooterView(WXComponent loading) {
    setLoadmoreEnable(true);
    if (swipeLayout != null) {
        if (swipeLayout.getFooterView() != null) {
            swipeLayout.setLoadingHeight((int) loading.getDomObject().getLayoutHeight());

            String colorStr = (String) loading.getDomObject().getStyles().get(Constants.Name.BACKGROUND_COLOR);
            String bgColor = WXUtils.getString(colorStr, null);

            if (bgColor != null) {
                if (!TextUtils.isEmpty(bgColor)) {
                    int colorInt = WXResourceUtils.getColor(bgColor);
                    if (!(colorInt == Color.TRANSPARENT)) {
                        swipeLayout.setLoadingBgColor(colorInt);
                    }
                }
            }
            swipeLayout.getFooterView().setRefreshView(loading.getHostView());
        }
    }
}
 

@Override
public void onTrackNode(@NonNull WXComponent component, int layer) {
    if(layer < MAX_VDOM_LAYER) {
        return;
    }
    View hostView = component.getHostView();
    if(hostView == null) {
        return;
    }

    if(mViewHighlighter != null) {
        mViewHighlighter.addHighlightedView(hostView);
    }
}
 

private void removeFooterOrHeader(WXComponent child) {
  if (child instanceof WXLoading) {
    getHostView().removeFooterView(child);
  } else if (child instanceof WXRefresh) {
    getHostView().removeHeaderView(child);
  }
}
 

@Nullable
private WXComponent findBoundComponentBy(@NonNull View targetView,@NonNull WXComponent rootComponent) {
    Deque<WXComponent> deque = new ArrayDeque<>();
    deque.add(rootComponent);
    WXComponent targetComponent = null;

    while (!deque.isEmpty()) {
        WXComponent component = deque.removeFirst();

        View view = component.getHostView();
        if(view != null && view.equals(targetView)) {
            targetComponent = component;
        }

        //we should take embed into account
        if(component instanceof WXEmbed) {
            WXComponent nestedRootComponent = ViewUtils.getNestedRootComponent((WXEmbed) component);
            if(nestedRootComponent != null) {
                deque.add(nestedRootComponent);
            }
        } else if(component instanceof WXVContainer) {
            WXVContainer container = (WXVContainer) component;
            for(int i = 0,len = container.getChildCount(); i < len; i++) {
                WXComponent c = container.getChild(i);
                deque.add(c);
            }
        }
    }

    return targetComponent;
}
 

public void onBackPressed() {
    WXComponent comp = mInstance.getRootComponent();
    if (comp != null) {
        WXEvent events = comp.getDomObject().getEvents();
        boolean hasBack = events.contains(UConstants.Event.ONANDROIDBACK);
        if (hasBack) {
            WXBridgeManager.getInstance().fireEvent(mInstance.getInstanceId(), comp.getRef(), UConstants.Event.ONANDROIDBACK, null, null);
            return;
        } else {
            super.onBackPressed();
        }
    }
    super.onBackPressed();
}
 

@Test
public void testScrollTo() throws Exception {
  WXComponent child = WXDivTest.create(component);
  ComponentTest.create(child);
  component.addChild(child);

  child = WXHeaderTest.create(component);
  ComponentTest.create(child);
  component.addChild(child);

  Map<String, Object> options = new HashMap<>(2);
  options.put("offset", 10);
  options.put("animated", false);
  component.scrollTo(child,options);
}
 

public static boolean registerComponent(String type, Class<? extends WXComponent> clazz, boolean appendTree) throws WXException {
  if (clazz == null || TextUtils.isEmpty(type)) {
    return false;
  }

  Map<String, String> componentInfo = new HashMap<>();
  componentInfo.put("type", type);
  if (appendTree) {
    componentInfo.put("append", "tree");
  }
  registerInternal(type,clazz,componentInfo);
  return true;
}
 

/**
 * To determine whether an animation is needed
 * @param child
 * @return
 */
private boolean isAddAnimation(WXComponent child) {
  ImmutableDomObject domObject = child.getDomObject();
  if (domObject != null) {
    Object attr = domObject.getAttrs().get(Constants.Name.INSERT_CELL_ANIMATION);
    if (Constants.Value.DEFAULT.equals(attr)) {
      return true;
    }
  }
  return false;
}
 

@Override
public void executeRender(RenderActionContext context) {
  WXComponent comp = context.getComponent(mRef);
  if(comp != null){
    //sync dom change to component
    comp.updateDom(mUpdatedDom);
    comp.addEvent(mEvent);
  }
}
 

public void onViewAppear(){
  WXComponent comp = getRootComponent();
  if(comp != null) {
    fireEvent( comp.getRef(), Constants.Event.VIEWAPPEAR,null, null);
    for(OnInstanceVisibleListener instance:mVisibleListeners){
      instance.onAppear();
    }
  }
}
 

@Override
public void executeRender(RenderActionContext context) {
  WXComponent component = context.getComponent(mRef);
  if (component == null) {
    return;
  }

  Scrollable scroller = component.getParentScroller();
  if (scroller == null) {
    return;
  }
  scroller.scrollTo(component,mOptions);
}
 

@Override
public void executeRender(RenderActionContext context) {
  WXComponent comp = context.getComponent(mRef);
  if (comp == null) {
    return;
  }

  comp.updateProperties(mData);
}
 

void invokeMethod(String ref, String method, JSONArray args){
  if(mDestroy){
    return;
  }
  WXComponent comp = mWXRenderManager.getWXComponent(mInstanceId, ref);
  if(comp == null){
    WXLogUtils.e("DomStatement","target component not found.");
    return;
  }
  comp.invoke(method,args);
}
 

public WXGesture(WXComponent wxComponent, Context context) {
  this.component = wxComponent;
  globalRect = new Rect();
  globalOffset = new Point();
  globalEventOffset = new Point();
  locEventOffset = new PointF();
  locLeftTop = new PointF();
  mGestureDetector = new GestureDetector(context, new GestureListener(), new GestureHandler());
}
 

/**
 * set padding style of View
 */
void setPadding(String ref, Spacing padding, Spacing border) {
  WXComponent component = mRegistry.get(ref);
  if (component == null) {
    return;
  }
  component.setPadding(padding, border);
}
 

@Override
public void executeDom(DOMActionContext context) {
  WXComponent comp = context.getCompByRef(mRef);
  if(comp == null){
    WXLogUtils.e("DOMAction","target component not found.");
    return;
  }
  comp.invoke(mMethod,mArgs);
}
 

public boolean onBackPressed() {
  WXComponent comp = getRootComponent();
  if(comp != null) {
    WXEvent events= comp.getDomObject().getEvents();
    boolean hasBackPressed = events.contains(Constants.Event.CLICKBACKITEM);
    if (hasBackPressed) {
      fireEvent(comp.getRef(), Constants.Event.CLICKBACKITEM,null, null);
    }
    return hasBackPressed;
  }
  return false;
}
 

/**
 * set layout information of View
 */
void setLayout(String ref, WXDomObject domObject) {
  WXComponent component = mRegistry.get(ref);
  if (component == null) {
    return;
  }
  component.setLayout(domObject);
}
 

/**
 * set extra information of View
 */
void setExtra(String ref, Object extra) {
  WXComponent component = mRegistry.get(ref);
  if (component == null) {
    return;
  }
  component.updateExtra(extra);
}
 

@Override
public void onTrackNode(@NonNull WXComponent component, int layer) {
    if(layer < MAX_VDOM_LAYER) {
        return;
    }
    View hostView = component.getHostView();
    if(hostView == null) {
        return;
    }

    if(mViewHighlighter != null) {
        mViewHighlighter.addHighlightedView(hostView);
    }
}
 

@Override
public void remove(WXComponent child, boolean destroy) {
    int index = mChildren.indexOf(child);
    if (destroy) {
        child.detachViewAndClearPreInfo();
    }
    getView().getAdapter().notifyItemRemoved(index);
    if (WXEnvironment.isApkDebugable()) {
        WXLogUtils.d(TAG, "removeChild child at " + index);
    }
    super.remove(child, destroy);
}