* Apache License
 * Version 2.0, January 2004
 * http://www.apache.org/licenses/
 * <p>
 * <p>
 * 1. Definitions.
 * <p>
 * "License" shall mean the terms and conditions for use, reproduction,
 * and distribution as defined by Sections 1 through 9 of this document.
 * <p>
 * "Licensor" shall mean the copyright owner or entity authorized by
 * the copyright owner that is granting the License.
 * <p>
 * "Legal Entity" shall mean the union of the acting entity and all
 * other entities that control, are controlled by, or are under common
 * control with that entity. For the purposes of this definition,
 * "control" means (i) the power, direct or indirect, to cause the
 * direction or management of such entity, whether by contract or
 * otherwise, or (ii) ownership of fifty percent (50%) or more of the
 * outstanding shares, or (iii) beneficial ownership of such entity.
 * <p>
 * "You" (or "Your") shall mean an individual or Legal Entity
 * exercising permissions granted by this License.
 * <p>
 * "Source" form shall mean the preferred form for making modifications,
 * including but not limited to software source code, documentation
 * source, and configuration files.
 * <p>
 * "Object" form shall mean any form resulting from mechanical
 * transformation or translation of a Source form, including but
 * not limited to compiled object code, generated documentation,
 * and conversions to other media types.
 * <p>
 * "Work" shall mean the work of authorship, whether in Source or
 * Object form, made available under the License, as indicated by a
 * copyright notice that is included in or attached to the work
 * (an example is provided in the Appendix below).
 * <p>
 * "Derivative Works" shall mean any work, whether in Source or Object
 * form, that is based on (or derived from) the Work and for which the
 * editorial revisions, annotations, elaborations, or other modifications
 * represent, as a whole, an original work of authorship. For the purposes
 * of this License, Derivative Works shall not include works that remain
 * separable from, or merely link (or bind by name) to the interfaces of,
 * the Work and Derivative Works thereof.
 * <p>
 * "Contribution" shall mean any work of authorship, including
 * the original version of the Work and any modifications or additions
 * to that Work or Derivative Works thereof, that is intentionally
 * submitted to Licensor for inclusion in the Work by the copyright owner
 * or by an individual or Legal Entity authorized to submit on behalf of
 * the copyright owner. For the purposes of this definition, "submitted"
 * means any form of electronic, verbal, or written communication sent
 * to the Licensor or its representatives, including but not limited to
 * communication on electronic mailing lists, source code control systems,
 * and issue tracking systems that are managed by, or on behalf of, the
 * Licensor for the purpose of discussing and improving the Work, but
 * excluding communication that is conspicuously marked or otherwise
 * designated in writing by the copyright owner as "Not a Contribution."
 * <p>
 * "Contributor" shall mean Licensor and any individual or Legal Entity
 * on behalf of whom a Contribution has been received by Licensor and
 * subsequently incorporated within the Work.
 * <p>
 * 2. Grant of Copyright License. Subject to the terms and conditions of
 * this License, each Contributor hereby grants to You a perpetual,
 * worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 * copyright license to reproduce, prepare Derivative Works of,
 * publicly display, publicly perform, sublicense, and distribute the
 * Work and such Derivative Works in Source or Object form.
 * <p>
 * 3. Grant of Patent License. Subject to the terms and conditions of
 * this License, each Contributor hereby grants to You a perpetual,
 * worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 * (except as stated in this section) patent license to make, have made,
 * use, offer to sell, sell, import, and otherwise transfer the Work,
 * where such license applies only to those patent claims licensable
 * by such Contributor that are necessarily infringed by their
 * Contribution(s) alone or by combination of their Contribution(s)
 * with the Work to which such Contribution(s) was submitted. If You
 * institute patent litigation against any entity (including a
 * cross-claim or counterclaim in a lawsuit) alleging that the Work
 * or a Contribution incorporated within the Work constitutes direct
 * or contributory patent infringement, then any patent licenses
 * granted to You under this License for that Work shall terminate
 * as of the date such litigation is filed.
 * <p>
 * 4. Redistribution. You may reproduce and distribute copies of the
 * Work or Derivative Works thereof in any medium, with or without
 * modifications, and in Source or Object form, provided that You
 * meet the following conditions:
 * <p>
 * (a) You must give any other recipients of the Work or
 * Derivative Works a copy of this License; and
 * <p>
 * (b) You must cause any modified files to carry prominent notices
 * stating that You changed the files; and
 * <p>
 * (c) You must retain, in the Source form of any Derivative Works
 * that You distribute, all copyright, patent, trademark, and
 * attribution notices from the Source form of the Work,
 * excluding those notices that do not pertain to any part of
 * the Derivative Works; and
 * <p>
 * (d) If the Work includes a "NOTICE" text file as part of its
 * distribution, then any Derivative Works that You distribute must
 * include a readable copy of the attribution notices contained
 * within such NOTICE file, excluding those notices that do not
 * pertain to any part of the Derivative Works, in at least one
 * of the following places: within a NOTICE text file distributed
 * as part of the Derivative Works; within the Source form or
 * documentation, if provided along with the Derivative Works; or,
 * within a display generated by the Derivative Works, if and
 * wherever such third-party notices normally appear. The contents
 * of the NOTICE file are for informational purposes only and
 * do not modify the License. You may add Your own attribution
 * notices within Derivative Works that You distribute, alongside
 * or as an addendum to the NOTICE text from the Work, provided
 * that such additional attribution notices cannot be construed
 * as modifying the License.
 * <p>
 * You may add Your own copyright statement to Your modifications and
 * may provide additional or different license terms and conditions
 * for use, reproduction, or distribution of Your modifications, or
 * for any such Derivative Works as a whole, provided Your use,
 * reproduction, and distribution of the Work otherwise complies with
 * the conditions stated in this License.
 * <p>
 * 5. Submission of Contributions. Unless You explicitly state otherwise,
 * any Contribution intentionally submitted for inclusion in the Work
 * by You to the Licensor shall be under the terms and conditions of
 * this License, without any additional terms or conditions.
 * Notwithstanding the above, nothing herein shall supersede or modify
 * the terms of any separate license agreement you may have executed
 * with Licensor regarding such Contributions.
 * <p>
 * 6. Trademarks. This License does not grant permission to use the trade
 * names, trademarks, service marks, or product names of the Licensor,
 * except as required for reasonable and customary use in describing the
 * origin of the Work and reproducing the content of the NOTICE file.
 * <p>
 * 7. Disclaimer of Warranty. Unless required by applicable law or
 * agreed to in writing, Licensor provides the Work (and each
 * Contributor provides its Contributions) on an "AS IS" BASIS,
 * implied, including, without limitation, any warranties or conditions
 * PARTICULAR PURPOSE. You are solely responsible for determining the
 * appropriateness of using or redistributing the Work and assume any
 * risks associated with Your exercise of permissions under this License.
 * <p>
 * 8. Limitation of Liability. In no event and under no legal theory,
 * whether in tort (including negligence), contract, or otherwise,
 * unless required by applicable law (such as deliberate and grossly
 * negligent acts) or agreed to in writing, shall any Contributor be
 * liable to You for damages, including any direct, indirect, special,
 * incidental, or consequential damages of any character arising as a
 * result of this License or out of the use or inability to use the
 * Work (including but not limited to damages for loss of goodwill,
 * work stoppage, computer failure or malfunction, or any and all
 * other commercial damages or losses), even if such Contributor
 * has been advised of the possibility of such damages.
 * <p>
 * 9. Accepting Warranty or Additional Liability. While redistributing
 * the Work or Derivative Works thereof, You may choose to offer,
 * and charge a fee for, acceptance of support, warranty, indemnity,
 * or other liability obligations and/or rights consistent with this
 * License. However, in accepting such obligations, You may act only
 * on Your own behalf and on Your sole responsibility, not on behalf
 * of any other Contributor, and only if You agree to indemnify,
 * defend, and hold each Contributor harmless for any liability
 * incurred by, or claims asserted against, such Contributor by reason
 * of your accepting any such warranty or additional liability.
 * <p>
 * <p>
 * APPENDIX: How to apply the Apache License to your work.
 * <p>
 * To apply the Apache License to your work, attach the following
 * boilerplate notice, with the fields enclosed by brackets "[]"
 * replaced with your own identifying information. (Don't include
 * the brackets!)  The text should be enclosed in the appropriate
 * comment syntax for the file format. We also recommend that a
 * file or class name and description of purpose be included on the
 * same "printed page" as the copyright notice for easier
 * identification within third-party archives.
 * <p>
 * Copyright 2016 Alibaba Group
 * <p>
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * <p>
 * http://www.apache.org/licenses/LICENSE-2.0
 * <p>
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * See the License for the specific language governing permissions and
 * limitations under the License.
package com.ucar.weex.commons;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v4.app.ActivityCompat;
import android.support.v4.app.FragmentActivity;
import android.support.v4.content.ContextCompat;
import android.support.v4.content.LocalBroadcastManager;
import android.text.TextUtils;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Toast;

import com.taobao.weex.IWXRenderListener;
import com.taobao.weex.WXSDKEngine;
import com.taobao.weex.WXSDKInstance;
import com.taobao.weex.common.IWXDebugProxy;
import com.taobao.weex.common.WXRenderStrategy;
import com.ucar.weex.commons.util.CommonUtils;

import java.util.HashMap;
import java.util.Map;

public abstract class AbsWeexActivity extends FragmentActivity implements IWXRenderListener {
  private static final String TAG = "AbsWeexActivity";
  protected BroadcastReceiver mBroadcastReceiver;
  protected ViewGroup mContainer;
  protected WXSDKInstance mInstance;
  protected Uri mUri;
  private WxReloadListener mReloadListener;
  private WxRefreshListener mRefreshListener;
  private String mUrl;// "http://your_current_IP:12580/examples/build/index.js";
  private String mPageName = TAG;
  protected Boolean isLocalUrl = false;

  protected void onCreate(@Nullable Bundle savedInstanceState) {
    registerBroadcastReceiver(mBroadcastReceiver, null);

  protected final ViewGroup getContainer() {
    return mContainer;

  protected final void setContainer(ViewGroup container) {
    mContainer = container;

  protected void destoryWeexInstance() {
    if (mInstance != null) {
      mInstance = null;

  protected void createWeexInstance() {
    mInstance = new WXSDKInstance(this);

  protected void renderPageByURL(String url) {
    renderPageByURL(url, null);

  protected void renderPageByURL(String url, String jsonInitData) {
    CommonUtils.throwIfNull(mContainer, new RuntimeException("Can't render page, container is null"));
    Map<String, Object> options = new HashMap<>();
    options.put(WXSDKInstance.BUNDLE_URL, url);

  public String getPageName() {
    return mPageName;

  public void onStart() {
    if (mInstance != null) {

  public void onResume() {
    if (mInstance != null) {

  public void onPause() {
    if (mInstance != null) {

  public void onStop() {
    if (mInstance != null) {

  public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    if (mInstance != null) {
      mInstance.onRequestPermissionsResult(requestCode, permissions, grantResults);
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);

  public void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (mInstance != null) {
      mInstance.onActivityResult(requestCode, resultCode, data);
    super.onActivityResult(requestCode, resultCode, data);

  public void onDestroy() {
    if (mInstance != null) {


  public void onViewCreated(WXSDKInstance wxsdkInstance, View view) {
    if (mContainer != null) {

  public void onRefreshSuccess(WXSDKInstance wxsdkInstance, int width, int height) {


  public void runWithPermissionsCheck(int requestCode, String permission, Runnable runnable) {
    if (ContextCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED) {
      if (ActivityCompat.shouldShowRequestPermissionRationale(this, permission)) {
        Toast.makeText(this, "please give me the permission", Toast.LENGTH_SHORT).show();
      } else {
        ActivityCompat.requestPermissions(this, new String[]{permission}, requestCode);
    } else {
      if (runnable != null) {

  public void onRenderSuccess(WXSDKInstance instance, int width, int height) {


  public void onException(WXSDKInstance instance, String errCode, String msg) {


  public void setReloadListener(WxReloadListener reloadListener) {
    mReloadListener = reloadListener;

  public void registerBroadcastReceiver(BroadcastReceiver receiver, IntentFilter filter) {
    mBroadcastReceiver = receiver != null ? receiver : new DefaultBroadcastReceiver();
    if (filter == null) {
      filter = new IntentFilter();
        .registerReceiver(mBroadcastReceiver, filter);
    if (mReloadListener == null) {
      setReloadListener(new WxReloadListener() {

        public void onReload() {


    if (mRefreshListener == null) {
      setRefreshListener(new WxRefreshListener() {

        public void onRefresh() {


  public void unregisterBroadcastReceiver() {
    if (mBroadcastReceiver != null) {
      mBroadcastReceiver = null;

  public void setRefreshListener(WxRefreshListener refreshListener) {
    mRefreshListener = refreshListener;

  public String getUrl() {
    return mUrl;

  public void setUrl(String url) {
    mUrl = url;

  public void loadUrl(String url) {

  protected void preRenderPage() {


  protected void postRenderPage() {


  protected void renderPage() {

  protected boolean isLocalPage() {
    boolean isLocalPage = true;
    if (mUri != null) {
      String scheme = mUri.getScheme();
      isLocalPage = !mUri.isHierarchical() ||
          (!TextUtils.equals(scheme, "http") && !TextUtils.equals(scheme, "https"));
    return isLocalPage;

  public void setPageName(String pageName) {
    mPageName = pageName;

  public interface WxReloadListener {
    void onReload();

  public interface WxRefreshListener {
    void onRefresh();

  public class DefaultBroadcastReceiver extends BroadcastReceiver {
    public void onReceive(Context context, Intent intent) {
      if (IWXDebugProxy.ACTION_DEBUG_INSTANCE_REFRESH.equals(intent.getAction())) {
        if (mRefreshListener != null) {
      } else if (WXSDKEngine.JS_FRAMEWORK_RELOAD.equals(intent.getAction())) {
        if (mReloadListener != null) {