/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 org.apache.weex;

import static org.apache.weex.http.WXHttpUtil.KEY_USER_AGENT;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.graphics.Color;
import android.graphics.Paint;
import android.net.Uri;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.annotation.RestrictTo;
import android.support.annotation.RestrictTo.Scope;
import android.support.annotation.WorkerThread;
import android.support.v4.util.ArrayMap;
import android.text.TextUtils;
import android.util.Log;
import android.view.Menu;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ScrollView;
import com.alibaba.fastjson.JSONObject;
import org.apache.weex.adapter.IDrawableLoader;
import org.apache.weex.adapter.IWXConfigAdapter;
import org.apache.weex.adapter.IWXHttpAdapter;
import org.apache.weex.adapter.IWXImgLoaderAdapter;
import org.apache.weex.adapter.IWXJscProcessManager;
import org.apache.weex.adapter.IWXUserTrackAdapter;
import org.apache.weex.adapter.URIAdapter;
import org.apache.weex.appfram.websocket.IWebSocketAdapter;
import org.apache.weex.bridge.EventResult;
import org.apache.weex.bridge.NativeInvokeHelper;
import org.apache.weex.bridge.SimpleJSCallback;
import org.apache.weex.bridge.WXBridgeManager;
import org.apache.weex.bridge.WXModuleManager;
import org.apache.weex.bridge.WXParams;
import org.apache.weex.common.Constants;
import org.apache.weex.common.Destroyable;
import org.apache.weex.common.OnWXScrollListener;
import org.apache.weex.common.RenderTypes;
import org.apache.weex.common.WXConfig;
import org.apache.weex.common.WXErrorCode;
import org.apache.weex.common.WXModule;
import org.apache.weex.common.WXPerformance;
import org.apache.weex.common.WXRefreshData;
import org.apache.weex.common.WXRenderStrategy;
import org.apache.weex.common.WXRequest;
import org.apache.weex.dom.WXEvent;
import org.apache.weex.http.WXHttpUtil;
import org.apache.weex.instance.InstanceOnFireEventInterceptor;
import org.apache.weex.jsEngine.JSContext;
import org.apache.weex.jsEngine.JSEngine;
import org.apache.weex.layout.ContentBoxMeasurement;
import org.apache.weex.performance.WXInstanceApm;
import org.apache.weex.performance.WXStateRecord;
import org.apache.weex.performance.WhiteScreenUtils;
import org.apache.weex.render.WXAbstractRenderContainer;
import org.apache.weex.tracing.WXTracing;
import org.apache.weex.ui.action.GraphicActionAddElement;
import org.apache.weex.ui.component.NestedContainer;
import org.apache.weex.ui.component.WXComponent;
import org.apache.weex.ui.component.WXEmbed;
import org.apache.weex.ui.flat.FlatGUIContext;
import org.apache.weex.ui.view.WXScrollView;
import org.apache.weex.utils.Trace;
import org.apache.weex.utils.WXDeviceUtils;
import org.apache.weex.utils.WXExceptionUtils;
import org.apache.weex.utils.WXFileUtils;
import org.apache.weex.utils.WXJsonUtils;
import org.apache.weex.utils.WXLogUtils;
import org.apache.weex.utils.WXReflectionUtils;
import org.apache.weex.utils.WXUtils;
import org.apache.weex.utils.WXViewUtils;
import org.apache.weex.utils.cache.RegisterCache;
import org.apache.weex.utils.tools.LogDetail;
import org.apache.weex.utils.tools.TimeCalculator;
import java.io.Serializable;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.concurrent.ConcurrentHashMap;
import org.apache.weex.bridge.WXBridgeManager.BundType;


/**
 * Each instance of WXSDKInstance represents an running weex instance.
 * It can be a pure weex view, or mixed with native view
 */
public class WXSDKInstance implements IWXActivityStateListener,View.OnLayoutChangeListener {

  private static  final  String SOURCE_TEMPLATE_BASE64_MD5 = "templateSourceBase64MD5";

  /**
   * Devtool protocol
   */
  public static String ACTION_DEBUG_INSTANCE_REFRESH = "DEBUG_INSTANCE_REFRESH";
  public static String ACTION_INSTANCE_RELOAD = "INSTANCE_RELOAD";

  //Performance
  public boolean mEnd = false;
  public boolean mHasCreateFinish = false;
  public static final String BUNDLE_URL = "bundleUrl";
  private IWXUserTrackAdapter mUserTrackAdapter;
  private IWXRenderListener mRenderListener;
  private IWXStatisticsListener mStatisticsListener;
  /** package **/ Context mContext;
  private final String mInstanceId;
  private WXAbstractRenderContainer mRenderContainer;
  private WXComponent mRootComp;
  private boolean mRendered;
  private WXRefreshData mLastRefreshData;
  private NestedInstanceInterceptor mNestedInstanceInterceptor;
  private String mBundleUrl = "";
  public static String requestUrl = "requestUrl";
  private boolean isDestroy=false;
  private boolean hasException = false;
  private boolean isRenderSuccess = false;
  private boolean createInstanceHeartBeat = false;
  private Map<String,Serializable> mUserTrackParams;
  private NativeInvokeHelper mNativeInvokeHelper;
  private boolean isCommit=false;
  private WXGlobalEventReceiver mGlobalEventReceiver=null;
  private boolean trackComponent;
  private boolean enableLayerType = true;
  private boolean mNeedValidate = false;
  private boolean mNeedReLoad = false;
  private boolean mUseScroller = false;
  private int mInstanceViewPortWidth = 750;
  private boolean enableFullScreenHeight = false;
  private WXInstanceApm mApmForInstance;
  private @NonNull
  FlatGUIContext mFlatGUIContext =new FlatGUIContext();

  private Map<String,String> mContainerInfo;

  public boolean isNewFsEnd = false;
  private List<JSONObject> componentsInfoExceedGPULimit  = new LinkedList<>();

  /**
   * bundle type
   */
  public BundType bundleType;
  public long mRenderStartNanos;
  public int mExecJSTraceId = WXTracing.nextId();

  private boolean isViewDisAppear = false;

  /**
   *for network tracker
   */
  public String mwxDims[] = new String [5];
  public long measureTimes[] = new long [5];

  public WeakReference<String> templateRef;
  public Map<String,List<String>> responseHeaders = new HashMap<>();

  /**
   * Render strategy.
   */
  private WXRenderStrategy mRenderStrategy = WXRenderStrategy.APPEND_ASYNC;

  private boolean mDisableSkipFrameworkInit = false;

  /**
   * Render start time
   */
  public long mRenderStartTime;
  /**
   * Refresh start time
   */
  private long mRefreshStartTime;
  private WXPerformance mWXPerformance;
  private ScrollView mScrollView;
  private WXScrollView.WXScrollViewListener mWXScrollViewListener;

  private List<OnWXScrollListener> mWXScrollListeners;

  private List<String> mLayerOverFlowListeners;

  private List<ActionBarHandler> mWXActionbarHandlers;

  private List<OnBackPressedHandler> mWXBackPressedHandlers;

  private List<OnActivityResultHandler> mWXOnActivityResultHandlers;

  private WXSDKInstance mParentInstance;

  private String mRenderType = RenderTypes.RENDER_TYPE_NATIVE;

  private boolean mPageDirty = true;
  private boolean mFixMultiThreadBug = false;

  public TimeCalculator mTimeCalculator;
  /**
   * Default Width And Viewport is 750,
   * when screen width change, we adjust viewport to adapter screen change
   * */
  private boolean mAutoAdjustDeviceWidth = WXEnvironment.AUTO_ADJUST_ENV_DEVICE_WIDTH;

  public  List<JSONObject> getComponentsExceedGPULimit(){return componentsInfoExceedGPULimit;}
  @RestrictTo(Scope.LIBRARY)
  public void setComponentsInfoExceedGPULimit(JSONObject component){
    if(component!= null && !component.isEmpty()){
      componentsInfoExceedGPULimit.add(component);
    }
  }

  public List<String> getLayerOverFlowListeners() {
    return mLayerOverFlowListeners;
  }

  public void addLayerOverFlowListener(String ref) {
    if (mLayerOverFlowListeners == null)
      mLayerOverFlowListeners = new ArrayList<>();
    mLayerOverFlowListeners.add(ref);
  }

  public void removeLayerOverFlowListener(String ref) {
    if (mLayerOverFlowListeners != null)
      mLayerOverFlowListeners.remove(ref);
  }

  /**
   * whether we are in preRender mode
   * */
  private volatile boolean isPreRenderMode;

  private boolean mCurrentGround = false;
  private ComponentObserver mComponentObserver;
  private Map<String, GraphicActionAddElement> inactiveAddElementAction = new ArrayMap<>();

  private Map<Long, ContentBoxMeasurement> mContentBoxMeasurements = new ArrayMap<>();

  private List<InstanceOnFireEventInterceptor> mInstanceOnFireEventInterceptorList;


  /**
   * network handler
   */
  public interface ImageNetworkHandler {
    public String fetchLocal(String url);
  }

  public interface StreamNetworkHandler {
    public String fetchLocal(String url);
  }

  public interface CustomFontNetworkHandler {
    public String fetchLocal(String url);
  }

  private ImageNetworkHandler mImageNetworkHandler;

  private StreamNetworkHandler mStreamNetworkHandler;

  private CustomFontNetworkHandler mCustomFontNetworkHandler;

  public ImageNetworkHandler getImageNetworkHandler() {
    return mImageNetworkHandler;
  }

  public void setImageNetworkHandler(ImageNetworkHandler imageNetworkHandler) {
    this.mImageNetworkHandler = imageNetworkHandler;
  }

  public StreamNetworkHandler getStreamNetworkHandler() {
    return mStreamNetworkHandler;
  }

  public void setStreamNetworkHandler(StreamNetworkHandler streamNetworkHandler) {
    this.mStreamNetworkHandler = streamNetworkHandler;
  }

  public CustomFontNetworkHandler getCustomFontNetworkHandler() {
    return mCustomFontNetworkHandler;
  }

  public void setCustomFontNetworkHandler(CustomFontNetworkHandler customFontNetworkHandler) {
    this.mCustomFontNetworkHandler = customFontNetworkHandler;
  }


  /**
   *  ActionBar Handler
   */

  public interface ActionBarHandler {
    boolean onSupportNavigateUp();
  }

  public interface OnBackPressedHandler {
    boolean onBackPressed();
  }

  public static abstract class OnActivityResultHandler {
    private String id;

    public OnActivityResultHandler(String id) {
      this.id = id;
    }

    public abstract boolean onActivityResult(int requestCode, int resultCode, Intent data, String id);

    public boolean onActivityResult(int requestCode, int resultCode, Intent data) {
      return onActivityResult(requestCode, resultCode, data, id);
    }
  }

  /**
   * set make weexCore run in single process mode
   * @param flag true means weexCore run in single process mode or multi process mode
   */
  public void setUseSingleProcess(boolean flag) {
    WXBridgeManager.getInstance().setUseSingleProcess(flag);
  }

  /**
   * set open SandBox
   * @param flag
   */
  public void setUseSandBox(boolean flag) {
    WXBridgeManager.getInstance().setSandBoxContext(flag);
  }

  public PriorityQueue<WXEmbed> hiddenEmbeds;

  private int maxHiddenEmbedsNum = -1; //max hidden embed num, -1 standard for ulimit

  public int getMaxHiddenEmbedsNum() {
    return maxHiddenEmbedsNum;
  }

  public void setMaxHiddenEmbedsNum(int maxHiddenEmbedsNum) {
    this.maxHiddenEmbedsNum = maxHiddenEmbedsNum;
  }

  @WorkerThread
  @RestrictTo(Scope.LIBRARY)
  public void addInActiveAddElementAction(String ref, GraphicActionAddElement action){
    inactiveAddElementAction.put(ref, action);
  }

  @WorkerThread
  @RestrictTo(Scope.LIBRARY)
  public void removeInActiveAddElmentAction(String ref){
    inactiveAddElementAction.remove(ref);
  }

  @WorkerThread
  @RestrictTo(Scope.LIBRARY)
  public GraphicActionAddElement getInActiveAddElementAction(String ref){
    return inactiveAddElementAction.get(ref);
  }

  /**
   * If anchor is created manually(etc. define a layout xml resource ),
   * be aware do not add it to twice when {@link IWXRenderListener#onViewCreated(WXSDKInstance, View)}.
   * @param a
   */
  public void setRenderContainer(RenderContainer a){
     setWXAbstractRenderContainer(a);
  }

  public void setWXAbstractRenderContainer(WXAbstractRenderContainer a){
    if(a != null) {
      a.setSDKInstance(this);
      a.addOnLayoutChangeListener(this);
    }

    mRenderContainer = a;
    if (mRenderContainer != null && mRenderContainer.getLayoutParams() != null
            && mRenderContainer.getLayoutParams().width == ViewGroup.LayoutParams.WRAP_CONTENT) {
      WXBridgeManager.getInstance().post(new Runnable() {
        @Override
        public void run() {
          WXBridgeManager.getInstance().setRenderContentWrapContentToCore(true, getInstanceId());
        }
      });
    } else {
      WXBridgeManager.getInstance().post(new Runnable() {
        @Override
        public void run() {
          WXBridgeManager.getInstance().setRenderContentWrapContentToCore(false, getInstanceId());
        }
      });
    }
  }

  private int mMaxDeepLayer;

  public boolean isTrackComponent() {
    return trackComponent;
  }

  public void setTrackComponent(boolean trackComponent) {
    this.trackComponent = trackComponent;
  }

  /**
   * Tell whether it is enabled to change the layerType
   * {@link android.view.View#setLayerType(int, Paint)}
   * @return True for enable to change the layerType of component, false otherwise. The default
   * is True
   */
  public boolean isLayerTypeEnabled() {
    return enableLayerType;
  }

  /**
   * Enable the ability of changing layerType. e.g. {@link android.view.View#setLayerType(int, Paint)}
   * Disable the ability of changing layerType will have tremendous <strong>performance
   * punishment</strong>.
   *
   * <strong>Do not</strong> set this to false unless you know exactly what you are doing.
   * @param enable True for enable to change the layerType of component, false otherwise. The default
   * is True
   */
  public void enableLayerType(boolean enable) {
    enableLayerType = enable;
  }

  @RestrictTo(RestrictTo.Scope.LIBRARY)
  public @NonNull
  FlatGUIContext getFlatUIContext(){
    return mFlatGUIContext;
  }

  public boolean isNeedValidate() {
    return mNeedValidate;
  }

  public boolean isNeedReLoad() {
    return mNeedReLoad;
  }

  public void setNeedLoad(boolean load) {
    mNeedReLoad = load;
  }

  @RestrictTo(Scope.LIBRARY)
  public void  setEnableFullScreenHeight(boolean fullScreenHeight){enableFullScreenHeight = fullScreenHeight;}

  @RestrictTo(Scope.LIBRARY)
  public boolean isFullScreenHeightEnabled(){return enableFullScreenHeight;}

  public boolean isUseScroller() {
    return mUseScroller;
  }

  public void setUseScroller(boolean use) {
    mUseScroller = use;
  }

  public void setInstanceViewPortWidth(int instanceViewPortWidth) {
    setInstanceViewPortWidth(instanceViewPortWidth,false);

  }
  public void setInstanceViewPortWidth(int instanceViewPortWidth,boolean fromMetaModule){
    this.mInstanceViewPortWidth = instanceViewPortWidth;
    this.mAutoAdjustDeviceWidth = false;
    if(!fromMetaModule){
      WXBridgeManager.getInstance().setViewPortWidth(getInstanceId(), mInstanceViewPortWidth);
    }
  }
  public void resetDeviceDisplayOfPage(){
    WXBridgeManager.getInstance().setDeviceDisplayOfPage(getInstanceId(), WXViewUtils.getScreenWidth(getContext()), WXViewUtils.getScreenHeight(getContext()));
  }
  public void setPageKeepRawCssStyles(){
    WXBridgeManager.getInstance().setPageArgument(getInstanceId(),"reserveCssStyles","true");
  }
  public void reloadPageLayout(){
    WXBridgeManager.getInstance().reloadPageLayout(getInstanceId());
  }

  public void setAutoAdjustDeviceWidth(boolean autoAdjustViewPort){
    this.mAutoAdjustDeviceWidth = autoAdjustViewPort;
  }

  public boolean isAutoAdjustDeviceWidth(){
    return mAutoAdjustDeviceWidth;
  }

  private void setDeviceDisplay(float deviceWith, float deviceHeight, float scale){
    WXBridgeManager.getInstance().setDeviceDisplay(getInstanceId(), deviceWith, deviceHeight, scale);
  }


  public int getInstanceViewPortWidth(){
    return mInstanceViewPortWidth;
  }

  public interface OnInstanceVisibleListener{
    void onAppear();
    void onDisappear();
  }
  private List<OnInstanceVisibleListener> mVisibleListeners = new ArrayList<>();

  public WXSDKInstance(Context context) {
    mInstanceId = WXSDKManager.getInstance().generateInstanceId();
    init(context);
  }

  //for preInit
  public WXSDKInstance(){
    mInstanceId = WXSDKManager.getInstance().generateInstanceId();
    mWXPerformance = new WXPerformance(mInstanceId);
    mApmForInstance = new WXInstanceApm(mInstanceId);
    WXSDKManager.getInstance().getAllInstanceMap().put(mInstanceId,this);
    mTimeCalculator = new TimeCalculator(this);
    initFixMultiThreadFlag();
  }


  private void initFixMultiThreadFlag() {
    IWXConfigAdapter adapter = WXSDKManager.getInstance().getWxConfigAdapter();
    if (adapter != null) {
      String config = adapter.getConfig("android_weex_ext_config", "fixMultiThreadBug", "true");
      mFixMultiThreadBug = Boolean.parseBoolean(config);
    }
  }

  /**
   * For unittest only.
   */
  @RestrictTo(Scope.TESTS)
  WXSDKInstance(Context context,String id) {
    mInstanceId = id;
    init(context);
  }

  public WXComponent getRootComponent() {
    return mRootComp;
  }

  public void setNestedInstanceInterceptor(NestedInstanceInterceptor interceptor){
    mNestedInstanceInterceptor = interceptor;
  }

  public final WXSDKInstance createNestedInstance(NestedContainer container){
    WXSDKInstance sdkInstance = newNestedInstance();
    if(mNestedInstanceInterceptor != null){
      mNestedInstanceInterceptor.onCreateNestInstance(sdkInstance,container);
    }
    if(sdkInstance != null){
        sdkInstance.setComponentObserver(this.getComponentObserver());
    }
    return sdkInstance;
  }

  protected WXSDKInstance newNestedInstance() {
    return new WXSDKInstance(mContext);
  }
  public boolean isHasException() {
    return hasException;
  }

  public void setHasException(boolean hasException) {
    this.hasException = hasException;
  }

  public void createInstanceFuncHeartBeat() {
    WXLogUtils.d("createInstanceFuncHeartBeat: " + mInstanceId);
    this.createInstanceHeartBeat = true;
    getApmForInstance().onStage(WXInstanceApm.KEY_PAGE_STAGES_END_EXCUTE_BUNDLE);
  }

  public void addOnInstanceVisibleListener(OnInstanceVisibleListener l){
    mVisibleListeners.add(l);
  }

  public void removeOnInstanceVisibleListener(OnInstanceVisibleListener l){
    mVisibleListeners.remove(l);
  }

  public void init(Context context) {
    initFixMultiThreadFlag();
    RegisterCache.getInstance().idle(true);
    mContext = context;
    mContainerInfo = new HashMap<>(4);
    mNativeInvokeHelper = new NativeInvokeHelper(mInstanceId);

    if (null == mWXPerformance){
      mWXPerformance = new WXPerformance(mInstanceId);
    }
    if (null == mApmForInstance){
      mApmForInstance = new WXInstanceApm(mInstanceId);
    }

    mWXPerformance.WXSDKVersion = WXEnvironment.WXSDK_VERSION;
    mWXPerformance.JSLibInitTime = WXEnvironment.sJSLibInitTime;

    mUserTrackAdapter=WXSDKManager.getInstance().getIWXUserTrackAdapter();

    WXSDKManager.getInstance().getAllInstanceMap().put(mInstanceId,this);

    mContainerInfo.put(WXInstanceApm.KEY_PAGE_PROPERTIES_CONTAINER_NAME, context instanceof Activity
            ? context.getClass().getSimpleName()
            :"unKnowContainer"
    );
    mContainerInfo.put(WXInstanceApm.KEY_PAGE_PROPERTIES_INSTANCE_TYPE,"page");

    // WXBridgeManager.getInstance().checkJsEngineMultiThread();
    mDisableSkipFrameworkInit = isDisableSkipFrameworkInDataRender();

    if(mTimeCalculator == null) {
      mTimeCalculator = new TimeCalculator(this);
    }
  }

  /**
   * Set a Observer for component.
   * This observer will be called in each component, should not doing
   * anything will impact render performance.
   *
   * @param observer
   */
  public void setComponentObserver(ComponentObserver observer){
    mComponentObserver = observer;
  }

  public ComponentObserver getComponentObserver(){
    return mComponentObserver;
  }

  public NativeInvokeHelper getNativeInvokeHelper() {
    return mNativeInvokeHelper;
  }

  @Deprecated
  public void setBizType(String bizType) {
    if (!TextUtils.isEmpty(bizType)) {
      mWXPerformance.bizType = bizType;
    }
  }

  public ScrollView getScrollView() {
    return mScrollView;
  }

  public void setRootScrollView(ScrollView scrollView) {
    mScrollView = scrollView;
    if (mWXScrollViewListener != null && mScrollView instanceof WXScrollView) {
      ((WXScrollView) mScrollView).addScrollViewListener(mWXScrollViewListener);
    }
  }

  @Deprecated
  public void registerScrollViewListener(WXScrollView.WXScrollViewListener scrollViewListener) {
    mWXScrollViewListener = scrollViewListener;
  }

  @Deprecated
  public WXScrollView.WXScrollViewListener getScrollViewListener() {
    return mWXScrollViewListener;
  }

  @Deprecated
  public void setIWXUserTrackAdapter(IWXUserTrackAdapter adapter) {
  }

  public void setContainerInfo(String key,String val){
    mContainerInfo.put(key,val);
  }

  public Map<String, String> getContainerInfo() {
    return mContainerInfo;
  }

  /**
   * Render template asynchronously, use {@link WXRenderStrategy#APPEND_ASYNC} as render strategy
   * @param template bundle js
   * @param options  os   iphone/android/ipad
   *                 weexversion    Weex version(like 1.0.0)
   *                 appversion     App version(like 1.0.0)
   *                 devid        Device id(like Aqh9z8dRJNBhmS9drLG5BKCmXhecHUXIZoXOctKwFebH)
   *                 sysversion    Device system version(like 5.4.4、7.0.4, should be used with os)
   *                 sysmodel     Device model(like iOS:"MGA82J/A", android:"MI NOTE LTE")
   *                 Time    UNIX timestamp, UTC+08:00
   *                 TTID(Optional)
   *                 MarkertId
   *                 Appname(Optional)  tm,tb,qa
   *                 Bundleurl(Optional)  template url
   * @param jsonInitData Initial data for rendering
   */
  public void render(String template, Map<String, Object> options, String jsonInitData) {
    render(template, options, jsonInitData, WXRenderStrategy.APPEND_ASYNC);
  }

  /**
   * Render template asynchronously
   * @param template bundle js
   * @param options  os   iphone/android/ipad
   *                 weexversion    Weex version(like 1.0.0)
   *                 appversion     App version(like 1.0.0)
   *                 devid        Device id(like Aqh9z8dRJNBhmS9drLG5BKCmXhecHUXIZoXOctKwFebH)
   *                 sysversion    Device system version(like 5.4.4、7.0.4, should be used with os)
   *                 sysmodel     Device model(like iOS:"MGA82J/A", android:"MI NOTE LTE")
   *                 Time    UNIX timestamp, UTC+08:00
   *                 TTID(Optional)
   *                 MarkertId
   *                 Appname(Optional)  tm,tb,qa
   *                 Bundleurl(Optional)  template url
   * @param jsonInitData Initial data for rendering
   * @param flag     RenderStrategy {@link WXRenderStrategy}
   */
  @Deprecated
  public void render(String template, Map<String, Object> options, String jsonInitData, WXRenderStrategy flag) {
    render(WXPerformance.DEFAULT, template, options, jsonInitData, flag);
  }

  /**
   * Render template asynchronously
   *
   * @param pageName, used for performance log.
   * @param template bundle js
   * @param options  os   iphone/android/ipad
   *                 weexversion    Weex version(like 1.0.0)
   *                 appversion     App version(like 1.0.0)
   *                 devid        Device id(like Aqh9z8dRJNBhmS9drLG5BKCmXhecHUXIZoXOctKwFebH)
   *                 sysversion    Device system version(like 5.4.4、7.0.4, should be used with os)
   *                 sysmodel     Device model(like iOS:"MGA82J/A", android:"MI NOTE LTE")
   *                 Time    UNIX timestamp, UTC+08:00
   *                 TTID(Optional)
   *                 MarkertId
   *                 Appname(Optional)  tm,tb,qa
   *                 Bundleurl(Optional)  template url
   * @param jsonInitData Initial data for rendering
   * @param flag     RenderStrategy {@link WXRenderStrategy}
   */
  public void render(String pageName, String template, Map<String, Object> options, String jsonInitData, WXRenderStrategy flag) {
    render(pageName, new Script(template), options, jsonInitData, flag);
  }

  public void render(String pageName, Script template, Map<String, Object> options, String jsonInitData, WXRenderStrategy flag) {
    mWXPerformance.beforeInstanceRender(mInstanceId);

    if(WXEnvironment.isApkDebugable() && WXPerformance.DEFAULT.equals(pageName)){

      if (getUIContext() != null) {
        new AlertDialog.Builder(getUIContext())
                .setTitle("Error: Missing pageName")
                .setMessage("We highly recommend you to set pageName. Call" +
                        "\nWXSDKInstance#render(String pageName, String template, Map<String, Object> options, String jsonInitData, WXRenderStrategy flag)\n" +
                        "to fix it.")
                .show();
      }

      return;
    }
    renderInternal(pageName,template,options,jsonInitData,flag);
  }

  /**
   * Render binary template asynchronously in DATA_RENDER_BINARY strategy.
   */
  public void render(String pageName, byte[] template, Map<String, Object> options, String jsonInitData) {
    render(pageName, new Script(template), options, jsonInitData, WXRenderStrategy.DATA_RENDER_BINARY);
  }

  private void ensureRenderArchor(){
    if(mRenderContainer == null){
      if (getContext() != null) {
        setRenderContainer(new RenderContainer(getContext()));
        mRenderContainer.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
        mRenderContainer.setBackgroundColor(Color.TRANSPARENT);
        mRenderContainer.setSDKInstance(this);
        mRenderContainer.addOnLayoutChangeListener(this);
      }
    }
  }

  private void renderInternal(String pageName,
                              String template,
                              Map<String, Object> options,
                              String jsonInitData,
                              WXRenderStrategy flag) {
    if (mRendered || TextUtils.isEmpty(template)) {
      return;
    }
    renderInternal(pageName, new Script(template), options, jsonInitData, flag);
  }

  private boolean isPreInit = false;
  public boolean isPreInitMode(){
    return isPreInit;
  }

  private boolean isPreDownLoad =false;
  public boolean isPreDownLoad(){
    return isPreDownLoad;
  }

  public void onInstanceReady(){
    WXLogUtils.d("test->","onInstanceReady");
    mApmForInstance.onStage(WXInstanceApm.KEY_PAGE_STAGES_CONTAINER_READY);
    if (!isPreInit && !isPreDownLoad){
      return;
    }
    mApmForInstance.onInstanceReady(isPreDownLoad);
    if (isPreDownLoad){
        mHttpListener.onInstanceReady();
    }
  }

  public void preInit(String pageName,
                      String script,
                      Map<String, Object> options,
                      String jsonInitData,
                      WXRenderStrategy flag){
    isPreInit = true;
    mRenderStrategy = flag;
    Map<String, Object> renderOptions = options;
    if (renderOptions == null) {
      renderOptions = new HashMap<>();
    }
    //mApmForInstance.doInit();
    mApmForInstance.isReady = false;
    WXSDKManager.getInstance().createInstance(this, new Script(script), renderOptions, jsonInitData);
  }

  public void preDownLoad(String url,
                          Map<String, Object> options,
                          String jsonInitData,
                          WXRenderStrategy flag){
    this.isPreDownLoad =true;
    mRenderStrategy = flag;
    mApmForInstance.isReady = false;
    renderByUrl(url,url,options,jsonInitData,flag);
  }


  private void renderInternal(String pageName,
                              Script template,
                              Map<String, Object> options,
                              String jsonInitData,
                              WXRenderStrategy flag){
    if (mRendered || template == null || template.isEmpty()) {
      return;
    }

    LogDetail logDetail = mTimeCalculator.createLogDetail("renderInternal");
    mRenderStrategy = flag;

    //some case ,from render(template),but not render (url)
    if (!mApmForInstance.hasInit()){
      mApmForInstance.doInit();
    }
    mApmForInstance.setPageName(pageName);
    mApmForInstance.onStage(WXInstanceApm.KEY_PAGE_STAGES_RENDER_ORGIGIN);
    mApmForInstance.doDelayCollectData();

    mWXPerformance.pageName = (TextUtils.isEmpty(pageName) ? "defaultBundleUrl":pageName);
    if (TextUtils.isEmpty(mBundleUrl)) {
      mBundleUrl = mWXPerformance.pageName;
    }

    if (WXTracing.isAvailable()) {
      WXTracing.TraceEvent traceEvent = WXTracing.newEvent("executeBundleJS", mInstanceId, -1);
      traceEvent.traceId = mExecJSTraceId;
      traceEvent.iid = mInstanceId;
      traceEvent.tname = "JSThread";
      traceEvent.ph = "B";
      traceEvent.submit();
      mRenderStartNanos = System.nanoTime();
    }

    ensureRenderArchor();

    Map<String, Object> renderOptions = options;
    if (renderOptions == null) {
      renderOptions = new HashMap<>();
    }

    if (WXEnvironment.sDynamicMode && !TextUtils.isEmpty(WXEnvironment.sDynamicUrl) && renderOptions.get("dynamicMode") == null) {
      renderOptions.put("dynamicMode", "true");
      renderByUrl(pageName, WXEnvironment.sDynamicUrl, renderOptions, jsonInitData, flag);
      return;
    }

    TimeCalculator timeCalculator = new TimeCalculator(this);

    mWXPerformance.JSTemplateSize = template.length() / 1024f;
    mApmForInstance.addStats(WXInstanceApm.KEY_PAGE_STATS_BUNDLE_SIZE,mWXPerformance.JSTemplateSize);
    mRenderStartTime = System.currentTimeMillis();
    WXSDKManager.getInstance().setCrashInfo(WXEnvironment.WEEX_CURRENT_KEY,pageName);
    if(mAutoAdjustDeviceWidth && WXDeviceUtils.isAutoResize(mContext)){
         if(WXEnvironment.AUTO_UPDATE_APPLICATION_SCREEN_SIZE) {
             WXViewUtils.updateApplicationScreen(mContext);
         }
         WXParams params = WXBridgeManager.getInstance().getInitParams();
         if(params != null && !TextUtils.equals(params.getDeviceWidth(), String.valueOf(WXViewUtils.getScreenWidth(mContext)))){
           params.setDeviceWidth(String.valueOf(WXViewUtils.getScreenWidth(mContext)));
           params.setDeviceHeight(String.valueOf(WXViewUtils.getScreenHeight(mContext)));
           float density = WXEnvironment.sApplication.getResources().getDisplayMetrics().density;
           WXEnvironment.addCustomOptions(WXConfig.scale, Float.toString(density));
           String statusBarHeight =  null;
           if(WXViewUtils.getStatusBarHeight(mContext) > 0 ){
             statusBarHeight = String.valueOf(WXViewUtils.getStatusBarHeight(mContext));
           }
           WXBridgeManager.getInstance().updateInitDeviceParams(params.getDeviceWidth(),
                                                                params.getDeviceHeight(),
                                                                Float.toString(density), statusBarHeight);
           setDeviceDisplay(WXViewUtils.getScreenWidth(mContext),
                            WXViewUtils.getScreenHeight(mContext),
                            WXViewUtils.getScreenDensity(mContext));
         }
    }
    logDetail.taskStart();
    if (isPreInitMode()){
      getApmForInstance().onStage(WXInstanceApm.KEY_PAGE_STAGES_LOAD_BUNDLE_START);
      WXBridgeManager.getInstance().loadJsBundleInPreInitMode(getInstanceId(),template.getContent());
    } else {
      WXSDKManager.getInstance().createInstance(this, template, renderOptions, jsonInitData);
    }
    logDetail.taskEnd();
    mRendered = true;

    final IWXJscProcessManager wxJscProcessManager = WXSDKManager.getInstance().getWXJscProcessManager();

    if(wxJscProcessManager != null && wxJscProcessManager.shouldReboot()) {
      WXSDKManager.getInstance().postOnUiThread(new Runnable() {
        @Override
        public void run() {
          checkWhiteScreen();
          if(isDestroy || hasException || isRenderSuccess) {
            return;
          }

          // there is no need to reboot js engine if render by eagle
          if(isDataRender()) {
            return;
          }

          View containerView = getContainerView();
          if(containerView instanceof ViewGroup) {
            if(0 == ((ViewGroup) containerView).getChildCount()) {
              if(wxJscProcessManager.withException(WXSDKInstance.this)) {
                onJSException(String.valueOf(WXErrorCode.WX_ERR_RELOAD_PAGE),"jsc reboot","jsc reboot");
              }
              if(!createInstanceHeartBeat) {
                  WXBridgeManager.getInstance().callReportCrashReloadPage(mInstanceId, null);
                  WXLogUtils.e("callReportCrashReloadPage with jsc reboot");
              }
            }
          }
        }
      }, wxJscProcessManager.rebootTimeout());
    }
  }


  private void checkWhiteScreen(){
    if (isDestroy ||!WhiteScreenUtils.doWhiteScreenCheck()){
      return;
    }

    boolean isWS = WhiteScreenUtils.isWhiteScreen(this);
    if (!isWS){
      return;
    }
    WXErrorCode errorCode = createInstanceHeartBeat?WXErrorCode.WX_ERROR_WHITE_SCREEN:WXErrorCode.WHITE_SCREEN_RESPONSE_TIMEOUT;
    if (WXBridgeManager.getInstance().isRebootExceedLimit()){
      errorCode = WXErrorCode.WHITE_SCREEN_REBOOT_EXCEED_LIMIT;
    }
    Map<String,String> args = new HashMap<>(1);
    String vieTreeMsg = WhiteScreenUtils.takeViewTreeSnapShot(this);
    args.put("viewTree",null == vieTreeMsg?"null viewTreeMsg":vieTreeMsg);
    args.put("weexCoreThreadStackTrace",WXBridgeManager.getInstance().getWeexCoreThreadStackTrace());

    for (Map.Entry<String,String> entry: WXStateRecord.getInstance().getStateInfo().entrySet()){
      args.put(entry.getKey(),entry.getValue());
    }
    WXExceptionUtils.commitCriticalExceptionRT(getInstanceId(),errorCode,"checkEmptyScreen",errorCode.getErrorMsg(),args);
  }


  public boolean skipFrameworkInit(){
    return isDataRender() && !mDisableSkipFrameworkInit;
  }

  private boolean isDataRender() {
    return getRenderStrategy() == WXRenderStrategy.DATA_RENDER_BINARY || getRenderStrategy() == WXRenderStrategy.DATA_RENDER;
  }

  private void renderByUrlInternal(String pageName,
                                   final String url,
                                   Map<String, Object> options,
                                   final String jsonInitData,
                                   WXRenderStrategy flag) {


    LogDetail logDetail = mTimeCalculator.createLogDetail("renderByUrlInternal");
    logDetail.taskStart();
    ensureRenderArchor();
    pageName = wrapPageName(pageName, url);
    mBundleUrl = url;
    mRenderStrategy = flag;
    if(WXSDKManager.getInstance().getValidateProcessor()!=null) {
      mNeedValidate = WXSDKManager.getInstance().getValidateProcessor().needValidate(mBundleUrl);
    }

    Map<String, Object> renderOptions = options;
    if (renderOptions == null) {
      renderOptions = new HashMap<>();
    }
    if (!renderOptions.containsKey(BUNDLE_URL)) {
      renderOptions.put(BUNDLE_URL, url);
    }

    getWXPerformance().pageName = pageName;

    mApmForInstance.doInit();
    mApmForInstance.setPageName(pageName);

    Uri uri = Uri.parse(url);
    if (uri != null && TextUtils.equals(uri.getScheme(), "file")) {
      mApmForInstance.onStage(WXInstanceApm.KEY_PAGE_STAGES_DOWN_BUNDLE_START);
      String template = WXFileUtils.loadFileOrAsset(assembleFilePath(uri), mContext);
      mApmForInstance.onStage(WXInstanceApm.KEY_PAGE_STAGES_DOWN_BUNDLE_END);
      render(pageName,template , renderOptions, jsonInitData, flag);
      return;
    }

    boolean is_wlasm = false;
    if (uri != null && uri.getPath()!=null) {
      if(uri.getPath().endsWith(".wlasm")){
        is_wlasm =  true;
      }
    }
    if (is_wlasm){
      flag = WXRenderStrategy.DATA_RENDER_BINARY;
    }

    IWXHttpAdapter adapter = WXSDKManager.getInstance().getIWXHttpAdapter();

    WXRequest wxRequest = new WXRequest();
    wxRequest.url = rewriteUri(Uri.parse(url), URIAdapter.BUNDLE).toString();
    if(wxRequest != null && !TextUtils.isEmpty(wxRequest.url)){
      requestUrl = wxRequest.url;
    }else {
      requestUrl = pageName;
    }

    if (wxRequest.paramMap == null) {
      wxRequest.paramMap = new HashMap<String, String>();
    }
    wxRequest.instanceId = getInstanceId();
    wxRequest.paramMap.put(KEY_USER_AGENT, WXHttpUtil.assembleUserAgent(mContext,WXEnvironment.getConfig()));
    wxRequest.paramMap.put("isBundleRequest","true");
    mHttpListener = new WXHttpListener(this, pageName, renderOptions, jsonInitData, flag, System.currentTimeMillis());
    mHttpListener.isPreDownLoadMode = isPreDownLoad;
    mHttpListener.setSDKInstance(this);
    mApmForInstance.onStage(WXInstanceApm.KEY_PAGE_STAGES_DOWN_BUNDLE_START);
    adapter.sendRequest(wxRequest, (IWXHttpAdapter.OnHttpListener) mHttpListener);
    logDetail.taskEnd();
  }

  private WXHttpListener mHttpListener = null;

  /**
   * Use {@link #render(String, String, Map, String, WXRenderStrategy)} instead.
   * @param pageName
   * @param template
   * @param options
   * @param jsonInitData
   * @param width
   * @param height
   * @param flag
   */
  @Deprecated
  public void render(String pageName, String template, Map<String, Object> options, String jsonInitData, int width, int height, WXRenderStrategy flag) {
    render(pageName,template,options,jsonInitData,flag);
  }

  /**
   * Render template asynchronously, use {@link WXRenderStrategy#APPEND_ASYNC} as render strategy
   * @param template bundle js
   */
  public void render(String template) {
    render(WXPerformance.DEFAULT, template, null, null, mRenderStrategy);
  }

  /**
   * Use {@link #render(String)} instead.
   * @param template
   * @param width
   * @param height
   */
  @Deprecated
  public void render(String template, int width, int height) {
    render(template);
  }

  /**
   * Use {@link #renderByUrl(String, String, Map, String, WXRenderStrategy)} instead.
   * @param pageName
   * @param url
   * @param options
   * @param jsonInitData
   * @param width
   * @param height
   * @param flag
   */
  @Deprecated
  public void renderByUrl(String pageName, final String url, Map<String, Object> options, final String jsonInitData, final int width, final int height, final WXRenderStrategy flag){
    renderByUrl(pageName,url,options,jsonInitData,flag);
  }

  public void renderByUrl(String pageName, final String url, Map<String, Object> options, final String jsonInitData, final WXRenderStrategy flag) {
    renderByUrlInternal(pageName,url,options,jsonInitData,flag);
  }

  private String wrapPageName(String pageName, String url) {
    if(TextUtils.equals(pageName, WXPerformance.DEFAULT)){
      pageName = url;
      WXExceptionUtils.degradeUrl = pageName;
      try {
        Uri uri=Uri.parse(url);
        if(uri!=null){
          Uri.Builder builder=new Uri.Builder();
          builder.scheme(uri.getScheme());
          builder.authority(uri.getAuthority());
          builder.path(uri.getPath());
          pageName=builder.toString();
        }
      } catch (Exception e) {
      }
    }
    return pageName;
  }

  private String assembleFilePath(Uri uri) {
    if(uri!=null && uri.getPath()!=null){
      return uri.getPath().replaceFirst("/","");
    }
    return "";
  }

  public void reloadPage(boolean reloadThis) {

    WXSDKEngine.reload();

    if (reloadThis) {
      if (mContext != null)  {
        Intent intent = new Intent();
        intent.setAction(ACTION_INSTANCE_RELOAD);
        intent.putExtra("url", mBundleUrl);
        mContext.sendBroadcast(intent);
      }
      // mRendered = false;
      //    destroy();
      // renderInternal(mPackage, mTemplate, mOptions, mJsonInitData, mFlag);
      // refreshInstance("{}");
    } else {
      IWXConfigAdapter adapter = WXSDKManager.getInstance().getWxConfigAdapter();
      if (adapter != null) {
        boolean degrade = Boolean.parseBoolean(adapter
                .getConfig("android_weex_ext_config",
                        "degrade_to_h5_if_not_reload",
                        "true"));
        WXLogUtils.e("degrade : " + degrade);
        if(degrade) {
          onJSException(String.valueOf(WXErrorCode.WX_ERR_RELOAD_PAGE.getErrorCode()),"Do not reloadPage", "Do not reloadPage degradeToH5");
          WXLogUtils.e("Do not reloadPage degradeToH5");
        }
      }
    }
  }

  /**
   * Refresh instance asynchronously.
   * @param data the new data
   */
  public void refreshInstance(Map<String, Object> data) {
    if (data == null) {
      return;
    }
    refreshInstance(WXJsonUtils.fromObjectToJSONString(data));
  }

  /**
   * Refresh instance asynchronously.
   * @param jsonData the new data
   */
  public void refreshInstance(String jsonData) {
    if (jsonData == null) {
      return;
    }
    mRefreshStartTime = System.currentTimeMillis();
    //cancel last refresh message
    if (mLastRefreshData != null) {
      mLastRefreshData.isDirty = true;
    }

    mLastRefreshData = new WXRefreshData(jsonData, false);

    WXSDKManager.getInstance().refreshInstance(mInstanceId, mLastRefreshData);
  }

  public WXRenderStrategy getRenderStrategy() {
    return mRenderStrategy;
  }

  public Context getUIContext() {
    return mContext;
  }

  public String getInstanceId() {
    return mInstanceId;
  }

  public Context getContext() {
    return mContext;
  }

  public int getWeexHeight() {
    return mRenderContainer == null ? 0: mRenderContainer.getHeight();
  }

  public int getWeexWidth() {
    return mRenderContainer == null ? 0: mRenderContainer.getWidth();
  }


  public IWXImgLoaderAdapter getImgLoaderAdapter() {
    return WXSDKManager.getInstance().getIWXImgLoaderAdapter();
  }

  public IDrawableLoader getDrawableLoader() {
    return WXSDKManager.getInstance().getDrawableLoader();
  }

  public URIAdapter getURIAdapter(){
    return WXSDKManager.getInstance().getURIAdapter();
  }

  public Uri rewriteUri(Uri uri,String type){
    return getURIAdapter().rewrite(this,type,uri);
  }

  public IWXHttpAdapter getWXHttpAdapter() {
    return WXSDKManager.getInstance().getIWXHttpAdapter();
  }

  public IWXStatisticsListener getWXStatisticsListener() {
    return mStatisticsListener;
  }

  public @Nullable
  IWebSocketAdapter getWXWebSocketAdapter() {
    return WXSDKManager.getInstance().getIWXWebSocketAdapter();
  }

  @Deprecated
  public void reloadImages() {
    if (mScrollView == null) {
      return;
    }
  }


  public boolean isPreRenderMode() {
    return this.isPreRenderMode;
  }

  public void setPreRenderMode(final boolean isPreRenderMode) {
    WXSDKManager.getInstance().getWXRenderManager().postOnUiThread(new Runnable() {
      @Override
      public void run() {
        WXSDKInstance.this.isPreRenderMode = isPreRenderMode;
      }
    },0);
  }

  public void setContext(@NonNull Context context) {
    this.mContext = context;
  }

  /********************************
   * begin register listener
   ********************************************************/
  public void registerRenderListener(IWXRenderListener listener) {
    mRenderListener = listener;
  }

  @Deprecated
  public void registerActivityStateListener(IWXActivityStateListener listener) {

  }

  public void registerStatisticsListener(IWXStatisticsListener listener) {
    mStatisticsListener = listener;
  }

  /**set render start time*/
  public void setRenderStartTime(long renderStartTime) {
    this.mRenderStartTime = renderStartTime;
  }

  /********************************
   * end register listener
   ********************************************************/


  /********************************
   *  begin hook Activity life cycle callback
   ********************************************************/

  @Override
  public void onActivityCreate() {

    // module listen Activity onActivityCreate
    WXModuleManager.onActivityCreate(getInstanceId());

    if(mRootComp != null) {
      mRootComp.onActivityCreate();
    }else{
        if (WXEnvironment.isApkDebugable()){
            WXLogUtils.w("Warning :Component tree has not build completely,onActivityCreate can not be call!");
        }
    }

    mGlobalEventReceiver=new WXGlobalEventReceiver(this);
    try {
      getContext().registerReceiver(mGlobalEventReceiver, new IntentFilter(WXGlobalEventReceiver.EVENT_ACTION));
    } catch (Throwable e) {
      // Huawei may throw a exception if register more than 500 BroadcastReceivers
      WXLogUtils.e(e.getMessage());
      mGlobalEventReceiver = null;
    }

  }

  @Override
  public void onActivityStart() {

    // module listen Activity onActivityCreate
    WXModuleManager.onActivityStart(getInstanceId());
    if(mRootComp != null) {
      mRootComp.onActivityStart();
    }else{
        if (WXEnvironment.isApkDebugable()) {
            WXLogUtils.w("Warning :Component tree has not build completely,onActivityStart can not be call!");

        }
    }

  }

  public boolean onCreateOptionsMenu(Menu menu) {

    WXModuleManager.onCreateOptionsMenu(getInstanceId(),menu);
    if(mRootComp != null) {
      mRootComp.onCreateOptionsMenu(menu);
    }else{
        if (WXEnvironment.isApkDebugable()) {
            WXLogUtils.w("Warning :Component tree has not build completely,onActivityStart can not be call!");

        }
    }
    return true;
  }

  @Override
  public void onActivityPause() {
    onViewDisappear();
    if(!isCommit){
      if(mUseScroller){
        mWXPerformance.useScroller=1;
      }
      mWXPerformance.maxDeepViewLayer=getMaxDeepLayer();
      mWXPerformance.wxDims = mwxDims;
      mWXPerformance.measureTimes = measureTimes;
      if (mUserTrackAdapter != null) {
        mUserTrackAdapter.commit(mContext, null, IWXUserTrackAdapter.LOAD, mWXPerformance, getUserTrackParams());
      }
      isCommit=true;
    }
    // module listen Activity onActivityPause
    WXModuleManager.onActivityPause(getInstanceId());
    if(mRootComp != null) {
      mRootComp.onActivityPause();
    }else{
        if (WXEnvironment.isApkDebugable()) {
            WXLogUtils.w("Warning :Component tree has not build completely,onActivityPause can not be call!");
        }
    }

    if (!mCurrentGround) {
      WXLogUtils.i("Application to be in the backround");
      Intent intent = new Intent(WXGlobalEventReceiver.EVENT_ACTION);
      intent.putExtra(WXGlobalEventReceiver.EVENT_NAME, Constants.Event.PAUSE_EVENT);
      intent.putExtra(WXGlobalEventReceiver.EVENT_WX_INSTANCEID, getInstanceId());
      /**
       *  Fix NPE just like {@link #onActivityResume()}
       */
      if (null != mContext){
        mContext.sendBroadcast(intent);
      }else {
        try {
          WXEnvironment.getApplication().sendBroadcast(intent);
        } catch (Exception e){
          WXLogUtils.e("weex",e);
        }
      }
      this.mCurrentGround = true;
    }

    //component appear
    if((WXEnvironment.isApkDebugable() || WXEnvironment.isPerf()) && mApmForInstance != null){
        WXLogUtils.e("PerformanceData " + mApmForInstance.toPerfString());
    }
  }


  @Override
  public void onActivityResume() {

    // notify onActivityResume callback to module
    WXModuleManager.onActivityResume(getInstanceId());

    if(mRootComp != null) {
      mRootComp.onActivityResume();
    }else{
        if (WXEnvironment.isApkDebugable()) {
            WXLogUtils.w("Warning :Component tree has not build completely, onActivityResume can not be call!");
        }
    }

    if (mCurrentGround) {
      WXLogUtils.i("Application  to be in the foreground");
      Intent intent = new Intent(WXGlobalEventReceiver.EVENT_ACTION);
      intent.putExtra(WXGlobalEventReceiver.EVENT_NAME, Constants.Event.RESUME_EVENT);
      intent.putExtra(WXGlobalEventReceiver.EVENT_WX_INSTANCEID, getInstanceId());
      //todo tmp solution for gray version
      if (null != mContext){
        mContext.sendBroadcast(intent);
      }else {
        WXEnvironment.getApplication().sendBroadcast(intent);
      }
      this.mCurrentGround = false;
    }

    onViewAppear();
  }

  @Override
  public void onActivityStop() {

    // notify onActivityResume callback to module
    WXModuleManager.onActivityStop(getInstanceId());

    if(mRootComp != null) {
      mRootComp.onActivityStop();
    }else{
        if (WXEnvironment.isApkDebugable()) {
            WXLogUtils.w("Warning :Component tree has not build completely, onActivityStop can not be call!");
        }
    }

  }

  @Override
  public void onActivityDestroy() {
    WXModuleManager.onActivityDestroy(getInstanceId());

    if(mRootComp != null) {
      mRootComp.onActivityDestroy();
    }else{
        if (WXEnvironment.isApkDebugable()) {
            WXLogUtils.w("Warning :Component tree has not build completely, onActivityDestroy can not be call!");
        }
    }
    this.mTimeCalculator.println();
    destroy();
  }

  @Override
  public boolean onActivityBack() {

    WXModuleManager.onActivityBack(getInstanceId());

    if(mRootComp != null) {
      return mRootComp.onActivityBack();
    }else{
        if (WXEnvironment.isApkDebugable()) {
            WXLogUtils.w("Warning :Component tree has not build completely, onActivityBack can not be call!");
        }
    }

    return false;
  }

  public boolean onSupportNavigateUp() {
    if (mWXActionbarHandlers != null) {
      for (ActionBarHandler handler : mWXActionbarHandlers) {
        if (handler.onSupportNavigateUp()) {
          return true;
        }
      }
    }
    return false;
  }

  public boolean onBackPressed() {
    if(mWXBackPressedHandlers != null) {
      for (OnBackPressedHandler handler : mWXBackPressedHandlers) {
        if(handler.onBackPressed()) {
          return true;
        }
      }
    }

    WXComponent comp = getRootComponent();
    if(comp != null) {
      WXEvent events= comp.getEvents();
      boolean hasNativeBackHook = events.contains(Constants.Event.NATIVE_BACK);
      if (hasNativeBackHook) {
        EventResult result = comp.fireEventWait(Constants.Event.NATIVE_BACK, null);
        if (WXUtils.getBoolean(result.getResult(), false)) {
          return true;
        }
      }

      boolean hasBackPressed = events.contains(Constants.Event.CLICKBACKITEM);
      if (hasBackPressed) {
        fireEvent(comp.getRef(), Constants.Event.CLICKBACKITEM,null, null);
      }
      return hasBackPressed;
    }
    return false;
  }

  public void onActivityResult(int requestCode, int resultCode, Intent data){
    WXModuleManager.onActivityResult(getInstanceId(),requestCode,resultCode,data);

    if(mRootComp != null) {
      mRootComp.onActivityResult(requestCode,resultCode,data);
    }else{
        if (WXEnvironment.isApkDebugable()) {
            WXLogUtils.w("Warning :Component tree has not build completely, onActivityResult can not be call!");
        }
    }


    if (mWXOnActivityResultHandlers != null && !mWXOnActivityResultHandlers.isEmpty()) {
      for (OnActivityResultHandler onActivityResultHandler : mWXOnActivityResultHandlers) {
        if (onActivityResultHandler.onActivityResult(requestCode, resultCode, data)) {
          break;
        }
      }
    }

  }


  public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {

    WXModuleManager.onRequestPermissionsResult(getInstanceId(),requestCode,permissions,grantResults);

    if(mRootComp != null) {
       mRootComp.onRequestPermissionsResult(requestCode,permissions,grantResults);
    }else{
        if (WXEnvironment.isApkDebugable()) {
            WXLogUtils.w(
                "Warning :Component tree has not build completely, onRequestPermissionsResult can not be call!");
        }
    }
  }

  /********************************
   *  end hook Activity life cycle callback
   ********************************************************/

  public void onViewDisappear(){
    isViewDisAppear = false;
    mApmForInstance.onDisAppear();
    WXComponent comp = getRootComponent();
    if(comp != null) {
      fireEvent(comp.getRef(), Constants.Event.VIEWDISAPPEAR, null, null);
      //call disappear of nested instances
      for(OnInstanceVisibleListener instance:mVisibleListeners){
        instance.onDisappear();
      }
    }
  }

  public boolean isViewDisAppear(){
    return isViewDisAppear;
  }

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


  public void onCreateFinish() {
    if(mHasCreateFinish){
      return;
    }
    if (mContext != null) {
      onViewAppear();
      View wxView= mRenderContainer;
      if(mRenderListener != null) {
        mRenderListener.onViewCreated(WXSDKInstance.this, wxView);
      }
      if (mStatisticsListener != null) {
        mStatisticsListener.onFirstView();
      }
    }
  }

  /**
   * call back when update finish
   */
  public void onUpdateFinish() {
    if (WXEnvironment.isApkDebugable()){
      WXLogUtils.d("Instance onUpdateSuccess");
    }
  }


  public void runOnUiThread(Runnable action) {
    WXSDKManager.getInstance().postOnUiThread(action, 0);
  }

  public void onRenderSuccess(final int width, final int height) {
    isRenderSuccess = true;
    if (!isNewFsEnd){
      getApmForInstance().arriveNewFsRenderTime();
    }
    if (!getApmForInstance().stageMap.containsKey(WXInstanceApm.KEY_PAGE_STAGES_INTERACTION)){
      getApmForInstance().arriveInteraction(getRootComponent());
    }

    long time = System.currentTimeMillis() - mRenderStartTime;
    long[] renderFinishTime = WXBridgeManager.getInstance().getRenderFinishTime(getInstanceId());

    mWXPerformance.callBridgeTime = renderFinishTime[0];
    mWXPerformance.cssLayoutTime = renderFinishTime[1];
    mWXPerformance.parseJsonTime = renderFinishTime[2];

    mWXPerformance.totalTime = time;
    if(mWXPerformance.screenRenderTime<0.001){
      mWXPerformance.screenRenderTime =  time;
    }

    if (mRenderListener != null && mContext != null) {
      mRenderListener.onRenderSuccess(WXSDKInstance.this, width, height);
      if (mUserTrackAdapter != null) {
        WXPerformance performance=new WXPerformance(mInstanceId);
        performance.errCode=WXErrorCode.WX_SUCCESS.getErrorCode();
        performance.args=getBundleUrl();
        mUserTrackAdapter.commit(mContext,null,IWXUserTrackAdapter.JS_BRIDGE,performance,getUserTrackParams());
      }
      if (WXEnvironment.isApkDebugable()){
        WXLogUtils.d(WXLogUtils.WEEX_PERF_TAG, mWXPerformance.toString());
      }
    }
    if(WXEnvironment.isPerf()){
      WXLogUtils.e("weex_perf",mWXPerformance.getPerfData());
    }
  }

  public void onRefreshSuccess(final int width, final int height) {
    if (mRenderListener != null && mContext != null) {
      mRenderListener.onRefreshSuccess(WXSDKInstance.this, width, height);
    }
  }

  public void onChangeElement(WXComponent component, boolean isOutOfScreen) {

    if (isDestroy()  || null == mRenderContainer || mWXPerformance == null ){
      return;
    }
    if (null == component || component.isIgnoreInteraction){
        return;
    }

    if (mRenderContainer.hasConsumeEvent()) {
      return;
    }

    long lastElementChangeTime = System.currentTimeMillis();

    long lazyLoadTime;

    if (mHasCreateFinish){
      lazyLoadTime = lastElementChangeTime - mWXPerformance.renderTimeOrigin;
      if (lazyLoadTime > 8000) {
        //force record detail performance data
        return;
      }
    }

    if (component.mIsAddElementToTree) {
      getWXPerformance().localInteractionViewAddCount++;
      if (!isOutOfScreen)
        getWXPerformance().interactionViewAddLimitCount++;
      component.mIsAddElementToTree = false;
    }

    if (!isOutOfScreen) {
      mApmForInstance.arriveInteraction(component);
    }
  }

  public void onRenderError(final String errCode, final String msg) {
    WXStateRecord.getInstance().recordException(getInstanceId(),"onRenderError,"+errCode+","+msg);
    if (mRenderListener != null && mContext != null) {
      WXLogUtils.e("onRenderError "+errCode +","+msg);
      runOnUiThread(new Runnable() {

        @Override
        public void run() {
          if (mRenderListener != null && mContext != null) {
            mRenderListener.onException(WXSDKInstance.this, errCode, msg);
          }
        }
      });
    }
  }

  public void onJSException(final String errCode, final String function, final String exception) {
    WXStateRecord.getInstance().recordException(getInstanceId(),"onJSException,"+errCode+","+function+"|"+exception);
    hasException = true;
    if (mRenderListener != null && mContext != null) {
      WXLogUtils.e("onJSException "+errCode +","+exception);
      runOnUiThread(new Runnable() {

        @Override
        public void run() {
          if (mRenderListener != null && mContext != null) {
            StringBuilder builder = new StringBuilder();
            builder.append(function);
            builder.append(exception);
            mRenderListener.onException(WXSDKInstance.this, errCode, builder.toString());
          }
        }
      });
    }
  }


  @Override
  public final void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft, int
          oldTop, int oldRight, int oldBottom) {
    if (left != oldLeft || top != oldTop || right != oldRight || bottom != oldBottom) {
      onLayoutChange(v);
    }
  }

  /**
   * Subclass should override this method to get notifications of layout change of GodView.
   * @param godView the godView.
   */
  public void onLayoutChange(View godView) {

  }

  private boolean mCreateInstance =true;
  public void firstScreenCreateInstanceTime(long time) {
    if(mCreateInstance) {
      mWXPerformance.firstScreenJSFExecuteTime = time -mRenderStartTime;
      mCreateInstance =false;
    }
  }

  public void callJsTime(final long time){
    if (!mEnd){
      mWXPerformance.fsCallJsTotalTime+=time;
      mWXPerformance.fsCallJsTotalNum++;
    }
  }

  public void onComponentCreate(WXComponent component,long createTime) {
      mWXPerformance.mActionAddElementCount++;
      mWXPerformance.mActionAddElementSumTime += createTime;
      if (!mEnd){
        mWXPerformance.fsComponentCreateTime+=createTime;
        mWXPerformance.fsComponentCount++;
      }
      mWXPerformance.componentCount++;
      mWXPerformance.componentCreateTime+=createTime;
  }

  public void callActionAddElementTime(long time) {
      mWXPerformance.mActionAddElementSumTime += time;
  }

  public void onOldFsRenderTimeLogic(){
      if (mEnd){
        return;
      }
      mEnd = true;
      if (mStatisticsListener != null && mContext != null) {
        runOnUiThread(new Runnable() {
        @Override
        public void run() {
            if (mStatisticsListener != null && mContext != null) {
              Trace.beginSection("onFirstScreen");
              mStatisticsListener.onFirstScreen();
              Trace.endSection();
            }
          }
        });
      }
      mApmForInstance.arriveFSRenderTime();
      mWXPerformance.fsRenderTime = System.currentTimeMillis();
      mWXPerformance.screenRenderTime = System.currentTimeMillis() - mRenderStartTime;
  }

  public WXSDKInstance getParentInstance() {
    return mParentInstance;
  }

  public void setParentInstance(WXSDKInstance mParentInstance) {
    this.mParentInstance = mParentInstance;
  }

  private void destroyView(View rootView) {
    try {
      if (rootView instanceof ViewGroup) {
        ViewGroup cViewGroup = ((ViewGroup) rootView);
        for (int index = 0; index < cViewGroup.getChildCount(); index++) {
          destroyView(cViewGroup.getChildAt(index));
        }

        cViewGroup.removeViews(0, ((ViewGroup) rootView).getChildCount());
        // Ensure that the viewgroup's status to be normal
        WXReflectionUtils.setValue(rootView, "mChildrenCount", 0);

      }
      if(rootView instanceof Destroyable){
        ((Destroyable)rootView).destroy();
      }
    } catch (Exception e) {
      WXLogUtils.e("WXSDKInstance destroyView Exception: ", e);
    }
  }

  public synchronized void destroy() {
    if(!isDestroy()) {
      if(mParentInstance != null){
         mParentInstance = null;
      }
      mApmForInstance.onEnd();


      if(mRendered) {
        WXSDKManager.getInstance().destroyInstance(mInstanceId);
      }

      try {
        if (mGlobalEventReceiver != null) {
          getContext().unregisterReceiver(mGlobalEventReceiver);
          mGlobalEventReceiver = null;
        }
      }catch (IllegalArgumentException e){
        WXLogUtils.w(WXLogUtils.getStackTrace(e));
      }

      if (mRootComp != null) {
        mRootComp.destroy();
        mRootComp = null;
      }

      if(mRenderContainer != null){
        destroyView(mRenderContainer);
      }


      if (mGlobalEvents != null) {
        mGlobalEvents.clear();
      }

      if (mComponentObserver != null) {
        mComponentObserver = null;
      }

      if (mLayerOverFlowListeners != null) {
        mLayerOverFlowListeners.clear();
      }

      if(mWXOnActivityResultHandlers != null && !mWXOnActivityResultHandlers.isEmpty()) {
        mWXOnActivityResultHandlers.clear();
      }

      if(mWXBackPressedHandlers != null && !mWXBackPressedHandlers.isEmpty()) {
        mWXBackPressedHandlers.clear();
      }

      if(mWXActionbarHandlers != null && !mWXActionbarHandlers.isEmpty()) {
        mWXActionbarHandlers.clear();
      }

      getFlatUIContext().destroy();
      mFlatGUIContext = null;
      mInstanceOnFireEventInterceptorList = null;
      mWXScrollListeners = null;
      mWXActionbarHandlers = null;
      mWXBackPressedHandlers = null;
      mRenderContainer = null;
      mNestedInstanceInterceptor = null;
      mUserTrackAdapter = null;
      mScrollView = null;
      mContext = null;
      mRenderListener = null;
      isDestroy = true;
      mStatisticsListener = null;
      if(responseHeaders != null){
        responseHeaders.clear();
      }
      if(templateRef != null){
        templateRef = null;
      }
      if (null != mContentBoxMeasurements) {
        mContentBoxMeasurements.clear();
      }
      mWXPerformance.afterInstanceDestroy(mInstanceId);

      WXBridgeManager.getInstance().post(new Runnable() {
        @Override
        public void run() {
          WXBridgeManager.getInstance().onInstanceClose(getInstanceId());
          inactiveAddElementAction.clear();
        }
      });

      //when report error in @WXExceptionUtils
      // instance may had destroy and remove,
      // so we delay remove from allInstanceMap
      WXBridgeManager.getInstance().postDelay(new Runnable() {
        @Override
        public void run() {
          WXSDKManager.getInstance().getAllInstanceMap().remove(mInstanceId);
        }
      },1000);
    }
  }

  public boolean isDestroy(){
    return isDestroy;
  }

  /**
   * @return If you use render () the return value may be empty
   */
  public @Nullable String getBundleUrl() {
    return mBundleUrl;
  }

  public View getRootView() {
    if (mRootComp == null)
      return null;
    return mRootComp.getRealView();
  }

  public View getContainerView() {
    return mRenderContainer;
  }

  @Deprecated
  public void setBundleUrl(String url){
    mBundleUrl = url;
    if(WXSDKManager.getInstance().getValidateProcessor()!=null) {
      mNeedValidate = WXSDKManager.getInstance().getValidateProcessor().needValidate(mBundleUrl);
    }
  }

  public void onRootCreated(WXComponent root) {
    this.mRootComp = root;
    this.mRootComp.mDeepInComponentTree =1;
    mRenderContainer.addView(root.getHostView());


    setSize(mRenderContainer.getWidth(),mRenderContainer.getHeight());
  }

  /**
   * Move fixed view to container ,except it's already moved.
   * @param fixedChild
   */
  public void moveFixedView(View fixedChild){
    if(mRenderContainer != null) {
      ViewGroup parent;
      if((parent = (ViewGroup) fixedChild.getParent()) != null){
        if (parent != mRenderContainer) {
          parent.removeView(fixedChild);
          mRenderContainer.addView(fixedChild);
        }
      }else{
        mRenderContainer.addView(fixedChild);
      }
    }
  }

  public void removeFixedView(View fixedChild){
    if(mRenderContainer != null) {
      mRenderContainer.removeView(fixedChild);
    }
  }

  public int getRenderContainerPaddingLeft() {
    if(mRenderContainer != null) {
      return mRenderContainer.getPaddingLeft();
    }
    return 0;
  }

  public int getRenderContainerPaddingRight() {
    if(mRenderContainer != null) {
      return mRenderContainer.getPaddingRight();
    }
    return 0;
  }

  public int getRenderContainerPaddingTop() {
    if(mRenderContainer != null) {
      return mRenderContainer.getPaddingTop();
    }
    return 0;
  }

  public synchronized List<OnWXScrollListener> getWXScrollListeners() {
    return mWXScrollListeners;
  }

  public synchronized void registerOnWXScrollListener(OnWXScrollListener wxScrollListener) {
    if(mWXScrollListeners==null){
      mWXScrollListeners=new ArrayList<>();
    }
    mWXScrollListeners.add(wxScrollListener);
  }

  public synchronized void registerActionbarHandler(ActionBarHandler actionBarHandler) {
    if(actionBarHandler == null) {
      return;
    }
    if(mWXActionbarHandlers == null) {
      mWXActionbarHandlers = new ArrayList<>();
    }

    mWXActionbarHandlers.add(actionBarHandler);
  }

  public synchronized void unRegisterActionbarHandler(ActionBarHandler actionBarHandler) {
    if(mWXActionbarHandlers != null && actionBarHandler != null) {
      mWXActionbarHandlers.remove(actionBarHandler);
    }
  }

  public synchronized void unRegisterOnActivityResultHandler(OnActivityResultHandler onActivityResultHandler) {
    if(mWXOnActivityResultHandlers != null && onActivityResultHandler != null) {
      mWXOnActivityResultHandlers.remove(onActivityResultHandler);
    }
  }

  public synchronized void registerOnActivityResultHandler(OnActivityResultHandler onActivityResultHandler) {
    if(onActivityResultHandler == null) {
      return;
    }

    if(mWXOnActivityResultHandlers == null) {
      mWXOnActivityResultHandlers = new ArrayList<>();
    }
    mWXOnActivityResultHandlers.add(onActivityResultHandler);
  }


  public synchronized void registerBackPressedHandler(OnBackPressedHandler backPressedHandler) {
    if(backPressedHandler == null) {
      return;
    }

    if(mWXBackPressedHandlers == null) {
      mWXBackPressedHandlers = new ArrayList<>();
    }

    mWXBackPressedHandlers.add(backPressedHandler);
  }

  public synchronized void unRegisterBackPressedHandler(OnBackPressedHandler backPressedHandler) {
    if(mWXBackPressedHandlers != null && backPressedHandler != null) {
      mWXBackPressedHandlers.remove(backPressedHandler);
    }
  }

  static int sScreenHeight = -1;
  public void setSize(int width, int height) {
    if (width > 0 && height > 0 & !isDestroy && mRendered && mRenderContainer != null) {
        if (sScreenHeight < 0){
            sScreenHeight = WXViewUtils.getScreenHeight(getContext());
        }
        if (sScreenHeight>0){
            double screenRatio = (double)height/(double)sScreenHeight *100;
            if(screenRatio>100){
              screenRatio =100;
            }
            getApmForInstance().addStats(WXInstanceApm.KEY_PAGE_STATS_BODY_RATIO,screenRatio);
        }
      ViewGroup.LayoutParams layoutParams = mRenderContainer.getLayoutParams();
      if (layoutParams != null) {
        final float realWidth = width;
        final float realHeight = height;
        if (mRenderContainer.getWidth() != width || mRenderContainer.getHeight() != height) {
          layoutParams.width = width;
          layoutParams.height = height;
          mRenderContainer.setLayoutParams(layoutParams);
        }

        if (mRootComp != null && layoutParams != null) {
          final boolean isWidthWrapContent = layoutParams.width == ViewGroup.LayoutParams.WRAP_CONTENT;
          final boolean isHeightWrapContent = layoutParams.height == ViewGroup.LayoutParams.WRAP_CONTENT;

          WXBridgeManager.getInstance().post(new Runnable() {
            @Override
            public void run() {
              WXBridgeManager.getInstance().setDefaultRootSize(getInstanceId(), realWidth, realHeight, isWidthWrapContent,
                      isHeightWrapContent);
            }
          });
        }
      }
    }
  }

  /*Global Event*/
  private HashMap<String, List<String>> mGlobalEvents = new HashMap<>();

  public void fireGlobalEventCallback(String eventName, Map<String,Object> params){
    List<String> callbacks=mGlobalEvents.get(eventName);
    if(callbacks!=null){
      for(String callback:callbacks){
        WXSDKManager.getInstance().callback(mInstanceId,callback,params,true);
      }
    }
  }

  /**
   * Fire event callback on a element.
   * @param elementRef
   * @param type
   * @param data
   * @param domChanges
   */
  public void fireEvent(String elementRef,final String type, final Map<String, Object> data,final Map<String, Object> domChanges, List<Object> eventArgs){
    fireEvent(elementRef, type, data, domChanges, eventArgs, null);
  }

  public void fireEvent(String elementRef,final String type, final Map<String, Object> data,final Map<String, Object> domChanges, List<Object> eventArgs, EventResult callback) {
    onInterceptInstanceEvent(getInstanceId(), elementRef, type, data, domChanges);
    if (null != mWXPerformance && mWXPerformance.fsCallEventTotalNum<Integer.MAX_VALUE){
      mWXPerformance.fsCallEventTotalNum++;
    }
    mApmForInstance.updateFSDiffStats(WXInstanceApm.KEY_PAGE_STATS_FS_CALL_EVENT_NUM,1);
    WXBridgeManager.getInstance().fireEventOnNode(getInstanceId(),elementRef,type,data,domChanges, eventArgs, callback);
  }


  /**
   * Fire event callback on a element.
   * @param elementRef
   * @param type
   * @param data
   * @param domChanges
   */
  public void fireEvent(String elementRef,final String type, final Map<String, Object> data,final Map<String, Object> domChanges){
    fireEvent(elementRef, type, data, domChanges, null);
  }

  public void fireEvent(String elementRef,final String type, final Map<String, Object> data){
    fireEvent(elementRef,type,data,null);
  }

  public void fireEvent(String ref, String type){
    fireEvent(ref,type,new HashMap<String, Object>());
  }

  protected void addEventListener(String eventName, String callback) {
    if (TextUtils.isEmpty(eventName) || TextUtils.isEmpty(callback)) {
      return;
    }
    List<String> callbacks = mGlobalEvents.get(eventName);
    if (callbacks == null) {
      callbacks = new ArrayList<>();
      mGlobalEvents.put(eventName, callbacks);
    }
    callbacks.add(callback);
  }
  protected void removeEventListener(String eventName, String callback) {
    if (TextUtils.isEmpty(eventName) || TextUtils.isEmpty(callback)) {
      return;
    }
    List<String> callbacks = mGlobalEvents.get(eventName);
    if (callbacks != null) {
      callbacks.remove(callback);
    }
  }

  protected void removeEventListener(String eventName) {
    if (TextUtils.isEmpty(eventName)) {
      return;
    }
    mGlobalEvents.remove(eventName);
  }

  /**
   * Notifies WEEX that this event has occurred
   * @param eventName WEEX register event
   * @param module Events occur in this Module
   * @param params The parameters to be notified to WEEX are required
   */
  public void fireModuleEvent(String eventName, WXModule module,Map<String, Object> params) {
    if (TextUtils.isEmpty(eventName) || module == null) {
      return;
    }

    Map<String, Object> event = new HashMap<>();
    event.put("type", eventName);
    event.put("module", module.getModuleName());
    event.put("data", params);

    List<String> callbacks = module.getEventCallbacks(eventName);
    if (callbacks != null) {
      for (String callback : callbacks) {
        SimpleJSCallback jsCallback = new SimpleJSCallback(mInstanceId, callback);
        if (module.isOnce(callback)) {
          jsCallback.invoke(event);
        } else {
          jsCallback.invokeAndKeepAlive(event);
        }
      }
    }
  }

  /**
   * Check whether the current module registered the event
   * @param eventName EventName register in weex
   * @param module Events occur in this Module
   * @return  register->true
   */
  public boolean checkModuleEventRegistered(String eventName,WXModule module) {
    if (module != null) {
      List<String> events = module.getEventCallbacks(eventName);
      if (events != null && events.size() > 0) {
        return true;
      }
    }
    return false;
  }

  public WXPerformance getWXPerformance(){
    return mWXPerformance;
  }

  public WXInstanceApm getApmForInstance() {
    return mApmForInstance;
  }

  public Map<String, Serializable> getUserTrackParams() {
    return mUserTrackParams;
  }

  public void addUserTrackParameter(String key,Serializable value){
    if(this.mUserTrackParams == null){
      this.mUserTrackParams = new ConcurrentHashMap<>();
    }
    mUserTrackParams.put(key,value);
  }

  public void clearUserTrackParameters(){
    if(this.mUserTrackParams != null){
      this.mUserTrackParams.clear();
    }
  }

  public void removeUserTrackParameter(String key){
    if(this.mUserTrackParams != null){
      this.mUserTrackParams.remove(key);
    }
  }

  public int getMaxDeepLayer() {
    return mMaxDeepLayer;
  }

  public void setMaxDeepLayer(int maxDeepLayer) {
    mMaxDeepLayer = maxDeepLayer;
    mApmForInstance.updateMaxStats(WXInstanceApm.KEY_PAGE_STATS_MAX_DEEP_VIEW,maxDeepLayer);
  }

  public void setMaxDomDeep(int maxDomDeep){
    mApmForInstance.updateMaxStats(WXInstanceApm.KEY_PAGE_STATS_MAX_DEEP_DOM,maxDomDeep);
    if (null == mWXPerformance){
      return;
    }
    if (mWXPerformance.maxDeepVDomLayer <= maxDomDeep){
      mWXPerformance.maxDeepVDomLayer = maxDomDeep;
    }
  }

  public void onHttpStart(){
    if (!mEnd){
      mWXPerformance.fsRequestNum++;
    }
  }

  /**
   * return md5, and bytes length
   * */
  public String getTemplateInfo() {
    String template = getTemplate();
    if(template == null){
      return " template md5 null ,httpHeader:" + JSONObject.toJSONString(responseHeaders);
    }
    if(TextUtils.isEmpty(template)){
      return " template md5  length 0 ,httpHeader" + JSONObject.toJSONString(responseHeaders);
    }
    try {
      byte[] bts = template.getBytes("UTF-8");
      String sourceMD5 = WXFileUtils.md5(bts);
      String sourceBase64MD5 = WXFileUtils.base64Md5(bts);
      ArrayList<String> sourceMD5List = new ArrayList<>();
      ArrayList<String> sourceBase64MD5List = new ArrayList<>();
      sourceMD5List.add(sourceMD5);
      sourceBase64MD5List.add(sourceBase64MD5);
      responseHeaders.put("templateSourceMD5", sourceMD5List);
      responseHeaders.put(SOURCE_TEMPLATE_BASE64_MD5, sourceBase64MD5List);
      return " template md5 " + sourceMD5 + " length " +   bts.length
              + " base64 md5 " + sourceBase64MD5
              + " response header " + JSONObject.toJSONString(responseHeaders);
    } catch (Exception e) {
      return "template md5 getBytes error";
    }

  }

  /**
   * check template header md5 match with header  content-md5
   * */
  public boolean isContentMd5Match(){
    if(responseHeaders == null){
      return true;
    }
    List<String> contentMD5s = responseHeaders.get("Content-Md5");
    if(contentMD5s == null){
      contentMD5s  = responseHeaders.get("content-md5");
    }
    if(contentMD5s == null || contentMD5s.size() <= 0){
      return true;
    }
    String md5 = contentMD5s.get(0);

    List<String> sourceBase64Md5 = responseHeaders.get(SOURCE_TEMPLATE_BASE64_MD5);
    if(sourceBase64Md5 == null){
      getTemplateInfo();
      sourceBase64Md5 = responseHeaders.get(SOURCE_TEMPLATE_BASE64_MD5);
    }
    if(sourceBase64Md5 == null || sourceBase64Md5.size() == 0){
      return  true;
    }
    return  md5.equals(sourceBase64Md5.get(0));
  }

  public String getTemplate() {
    if(templateRef == null){
      return  null;
    }
    return templateRef.get();
  }

  public void setTemplate(String template) {
    this.templateRef = new WeakReference<String>(template);
  }

  public interface NestedInstanceInterceptor {
    void onCreateNestInstance(WXSDKInstance instance, NestedContainer container);
  }

  public void OnVSync() {
    if(mFixMultiThreadBug) {
      if(!mPageDirty) {
        return;
      }
      WXBridgeManager.getInstance().post(new Runnable() {
        @Override
        public void run() {
          boolean forceLayout = WXBridgeManager.getInstance().notifyLayout(getInstanceId());
          if(forceLayout) {
            WXBridgeManager.getInstance().forceLayout(getInstanceId());
          }
        }
      });
    } else  {
      boolean forceLayout = WXBridgeManager.getInstance().notifyLayout(getInstanceId());
      if(forceLayout) {
        WXBridgeManager.getInstance().post(new Runnable() {
          @Override
          public void run() {
            WXBridgeManager.getInstance().forceLayout(getInstanceId());
          }
        });
      }
    }


  }

  public void addContentBoxMeasurement(long renderObjectPtr, ContentBoxMeasurement contentBoxMeasurement) {
    mContentBoxMeasurements.put(renderObjectPtr, contentBoxMeasurement);
  }

  public ContentBoxMeasurement getContentBoxMeasurement(long renderObjectPtr) {
    return mContentBoxMeasurements.get(renderObjectPtr);
  }


  private void onInterceptInstanceEvent(String instanceId, String elementRef, String type, Map<String, Object> data, Map<String, Object> domChanges) {
    if(this.mInstanceOnFireEventInterceptorList == null){
      return;
    }
    for(InstanceOnFireEventInterceptor instanceOnFireEventInterceptor : this.mInstanceOnFireEventInterceptorList){
      instanceOnFireEventInterceptor.onInterceptFireEvent(instanceId, elementRef, type, data, domChanges);
    }
  }

  public List<InstanceOnFireEventInterceptor> getInstanceOnFireEventInterceptorList(){
    if(this.mInstanceOnFireEventInterceptorList == null){
      this.mInstanceOnFireEventInterceptorList = new ArrayList<>();
    }
    return mInstanceOnFireEventInterceptorList;
  }


  public void addInstanceOnFireEventInterceptor(InstanceOnFireEventInterceptor instanceOnFireEventInterceptor) {
    if(instanceOnFireEventInterceptor == null){
      return;
    }
    if(!getInstanceOnFireEventInterceptorList().contains(instanceOnFireEventInterceptor)){
      getInstanceOnFireEventInterceptorList().add(instanceOnFireEventInterceptor);
    }
  }

  public String getRenderType() {
    return mRenderType;
  }

  public void setRenderType(String renderType) {
    this.mRenderType = renderType;
  }

  private static boolean isDisableSkipFrameworkInDataRender() {
    IWXConfigAdapter adapter = WXSDKManager.getInstance().getWxConfigAdapter();
    if (adapter == null) {
      return false;
    }
    String result = adapter.getConfig("wxeagle", "disable_skip_framework_init", "false");
    return "true".equals(result);
  }

  public boolean isPageDirty() {
    return mPageDirty;
  }

  public void setPageDirty(boolean mPageDirty) {
    this.mPageDirty = mPageDirty;
  }
}