public class ReactInstanceManager {

 /**
   * Trigger react context initialization asynchronously in a background async task. This enables
   * applications to pre-load the application JS, and execute global code before
   * {@link ReactRootView} is available and measured. This should only be called the first time the
   * application is set up, which is enforced to keep developers from accidentally creating their
   * application multiple times without realizing it.
   *
   * Called from UI thread.
   */
  public void createReactContextInBackground() {
    Assertions.assertCondition(
        !mHasStartedCreatingInitialContext,
        "createReactContextInBackground should only be called when creating the react " +
            "application for the first time. When reloading JS, e.g. from a new file, explicitly" +
            "use recreateReactContextInBackground");

    mHasStartedCreatingInitialContext = true;
    //进一步调用recreateReactContextInBackgroundInner()
    recreateReactContextInBackgroundInner();
  }

  /**
   * Recreate the react application and context. This should be called if configuration has
   * changed or the developer has requested the app to be reloaded. It should only be called after
   * an initial call to createReactContextInBackground.
   *
   * Called from UI thread.
   */
  public void recreateReactContextInBackground() {
    Assertions.assertCondition(
        mHasStartedCreatingInitialContext,
        "recreateReactContextInBackground should only be called after the initial " +
            "createReactContextInBackground call.");
    recreateReactContextInBackgroundInner();
  }

  private void recreateReactContextInBackgroundInner() {
    UiThreadUtil.assertOnUiThread();

    //开发模式，实现在线更新Bundle，晃动弹出调试菜单等功能，这一部分属于调试功能流程。
    if (mUseDeveloperSupport && mJSMainModuleName != null) {
      final DeveloperSettings devSettings = mDevSupportManager.getDevSettings();

      // If remote JS debugging is enabled, load from dev server.
      //判断是否处于开发模式，如果处于开发模式，则从Dev Server中获取JSBundle，如果不是则从文件中获取。
      if (mDevSupportManager.hasUpToDateJSBundleInCache() &&
          !devSettings.isRemoteJSDebugEnabled()) {
        // If there is a up-to-date bundle downloaded from server,
        // with remote JS debugging disabled, always use that.
        onJSBundleLoadedFromServer();
      } else if (mBundleLoader == null) {
        mDevSupportManager.handleReloadJS();
      } 
      
      else {
        mDevSupportManager.isPackagerRunning(
            new PackagerStatusCallback() {
              @Override
              public void onPackagerStatusFetched(final boolean packagerIsRunning) {
                UiThreadUtil.runOnUiThread(
                    new Runnable() {
                      @Override
                      public void run() {
                        //打包服务器已经运行，开始加载JS
                        if (packagerIsRunning) {
                          mDevSupportManager.handleReloadJS();
                        } else {
                          // If dev server is down, disable the remote JS debugging.
                          devSettings.setRemoteJSDebugEnabled(false);
                          recreateReactContextInBackgroundFromBundleLoader();
                        }
                      }
                    });
              }
            });
      }
      return;
    }

    //线上模式
    recreateReactContextInBackgroundFromBundleLoader();
  }
}

public class DevSupportManagerImpl implements
    DevSupportManager,
    PackagerCommandListener,
    DevInternalSettings.Listener {

      @Override
      public void handleReloadJS() {
        UiThreadUtil.assertOnUiThread();
    
        // dismiss redbox if exists
        if (mRedBoxDialog != null) {
          mRedBoxDialog.dismiss();
        }
    
        if (mDevSettings.isRemoteJSDebugEnabled()) {
          mDevLoadingViewController.showForRemoteJSEnabled();
          mDevLoadingViewVisible = true;
          reloadJSInProxyMode();
        } else {
          String bundleURL =
            mDevServerHelper.getDevServerBundleURL(Assertions.assertNotNull(mJSAppBundleName));
          reloadJSFromServer(bundleURL);
        }
      }
}

  protected String getJSMainModuleName() {
    return "index.android";
  }

public class BundleDownloader {

     public void downloadBundleFromURL(
          final DevBundleDownloadListener callback,
          final File outputFile,
          final String bundleURL) {
        final Request request = new Request.Builder()
            .url(bundleURL)
            // FIXME: there is a bug that makes MultipartStreamReader to never find the end of the
            // multipart message. This temporarily disables the multipart mode to work around it, but
            // it means there is no progress bar displayed in the React Native overlay anymore.
            //.addHeader("Accept", "multipart/mixed")
            .build();
        mDownloadBundleFromURLCall = Assertions.assertNotNull(mClient.newCall(request));
        mDownloadBundleFromURLCall.enqueue(new Callback() {
          @Override
          public void onFailure(Call call, IOException e) {
            // ignore callback if call was cancelled
            if (mDownloadBundleFromURLCall == null || mDownloadBundleFromURLCall.isCanceled()) {
              mDownloadBundleFromURLCall = null;
              return;
            }
            mDownloadBundleFromURLCall = null;
    
            callback.onFailure(DebugServerException.makeGeneric(
                "Could not connect to development server.",
                "URL: " + call.request().url().toString(),
                e));
          }
    
          @Override
          public void onResponse(Call call, final Response response) throws IOException {
            // ignore callback if call was cancelled
            if (mDownloadBundleFromURLCall == null || mDownloadBundleFromURLCall.isCanceled()) {
              mDownloadBundleFromURLCall = null;
              return;
            }
            mDownloadBundleFromURLCall = null;
    
            final String url = response.request().url().toString();
    
            //contentType为application/javascript
            String contentType = response.header("content-type");
            Pattern regex = Pattern.compile("multipart/mixed;.*boundary=\"([^\"]+)\"");
            Matcher match = regex.matcher(contentType);
            if (match.find()) {
              String boundary = match.group(1);
              MultipartStreamReader bodyReader = new MultipartStreamReader(response.body().source(), boundary);
              boolean completed = bodyReader.readAllParts(new MultipartStreamReader.ChunkCallback() {
                @Override
                public void execute(Map<String, String> headers, Buffer body, boolean finished) throws IOException {
                  // This will get executed for every chunk of the multipart response. The last chunk
                  // (finished = true) will be the JS bundle, the other ones will be progress events
                  // encoded as JSON.
                  if (finished) {
                    // The http status code for each separate chunk is in the X-Http-Status header.
                    int status = response.code();
                    if (headers.containsKey("X-Http-Status")) {
                      status = Integer.parseInt(headers.get("X-Http-Status"));
                    }
                    processBundleResult(url, status, body, outputFile, callback);
                  } else {
                    if (!headers.containsKey("Content-Type") || !headers.get("Content-Type").equals("application/json")) {
                      return;
                    }
                    try {
                      JSONObject progress = new JSONObject(body.readUtf8());
                      String status = null;
                      if (progress.has("status")) {
                        status = progress.getString("status");
                      }
                      Integer done = null;
                      if (progress.has("done")) {
                        done = progress.getInt("done");
                      }
                      Integer total = null;
                      if (progress.has("total")) {
                        total = progress.getInt("total");
                      }
                      callback.onProgress(status, done, total);
                    } catch (JSONException e) {
                      FLog.e(ReactConstants.TAG, "Error parsing progress JSON. " + e.toString());
                    }
                  }
                }
              });
              if (!completed) {
                callback.onFailure(new DebugServerException(
                    "Error while reading multipart response.\n\nResponse code: " + response.code() + "\n\n" +
                    "URL: " + call.request().url().toString() + "\n\n"));
              }
            } else {
              // In case the server doesn't support multipart/mixed responses, fallback to normal download.
              //如果服务器不支持multipart/mixed的responses，则利用Okio将返回内容即JS Bundle写入缓存
              processBundleResult(url, response.code(), Okio.buffer(response.body().source()), outputFile, callback);
            }
          }
        });
      }
}

public class DevSupportManagerImpl implements
    DevSupportManager,
    PackagerCommandListener,
    DevInternalSettings.Listener {

    public void reloadJSFromServer(final String bundleURL) {
    mDevLoadingViewController.showForUrl(bundleURL);
    mDevLoadingViewVisible = true;

    mDevServerHelper.getBundleDownloader().downloadBundleFromURL(
        new DevBundleDownloadListener() {
          //Bundle下载成功
          @Override
          public void onSuccess() {
            mDevLoadingViewController.hide();
            mDevLoadingViewVisible = false;
            if (mBundleDownloadListener != null) {
              mBundleDownloadListener.onSuccess();
            }
            UiThreadUtil.runOnUiThread(
                new Runnable() {
                  @Override
                  public void run() {
                    mReactInstanceCommandsHandler.onJSBundleLoadedFromServer();
                  }
                });
          }

          @Override
          public void onProgress(@Nullable final String status, @Nullable final Integer done, @Nullable final Integer total) {
            mDevLoadingViewController.updateProgress(status, done, total);
            if (mBundleDownloadListener != null) {
              mBundleDownloadListener.onProgress(status, done, total);
            }
          }

          @Override
          public void onFailure(final Exception cause) {
            mDevLoadingViewController.hide();
            mDevLoadingViewVisible = false;
            if (mBundleDownloadListener != null) {
              mBundleDownloadListener.onFailure(cause);
            }
            FLog.e(ReactConstants.TAG, "Unable to download JS bundle", cause);
            UiThreadUtil.runOnUiThread(
                new Runnable() {
                  @Override
                  public void run() {
                    if (cause instanceof DebugServerException) {
                      DebugServerException debugServerException = (DebugServerException) cause;
                      showNewJavaError(debugServerException.getMessage(), cause);
                    } else {
                      showNewJavaError(
                          mApplicationContext.getString(R.string.catalyst_jsload_error),
                          cause);
                    }
                  }
                });
          }
        },
        mJSBundleTempFile,
        bundleURL);
  }
}      

private final ReactInstanceDevCommandsHandler mDevInterface =
    new ReactInstanceDevCommandsHandler() {

      @Override
      public void onReloadWithJSDebugger(JavaJSExecutor.Factory jsExecutorFactory) {
        ReactInstanceManager.this.onReloadWithJSDebugger(jsExecutorFactory);
      }

      @Override
      public void onJSBundleLoadedFromServer() {
        ReactInstanceManager.this.onJSBundleLoadedFromServer();
      }

      @Override
      public void toggleElementInspector() {
        ReactInstanceManager.this.toggleElementInspector();
      }
    };

public class CatalystInstanceImpl implements CatalystInstance {

 /* package */ void setSourceURLs(String deviceURL, String remoteURL) {
    mSourceURL = deviceURL;
    jniSetSourceURL(remoteURL);
  }

  /* package */ void loadScriptFromAssets(AssetManager assetManager, String assetURL, boolean loadSynchronously) {
    mSourceURL = assetURL;
    jniLoadScriptFromAssets(assetManager, assetURL, loadSynchronously);
  }

  /* package */ void loadScriptFromFile(String fileName, String sourceURL, boolean loadSynchronously) {
    mSourceURL = sourceURL;
    jniLoadScriptFromFile(fileName, sourceURL, loadSynchronously);
  }

  //从URL里加载
  private native void jniSetSourceURL(String sourceURL);
  //从Asset里加载
  private native void jniLoadScriptFromAssets(AssetManager assetManager, String assetURL, boolean loadSynchronously);
  //从文件里加载
  private native void jniLoadScriptFromFile(String fileName, String sourceURL, boolean loadSynchronously);
}

public class UIImplementation {

  /**
   * Invoked by React to create a new node with a given tag, class name and properties.
   */
  public void createView(int tag, String className, int rootViewTag, ReadableMap props) {
    ReactShadowNode cssNode = createShadowNode(className);
    ReactShadowNode rootNode = mShadowNodeRegistry.getNode(rootViewTag);
    cssNode.setReactTag(tag);
    cssNode.setViewClassName(className);
    cssNode.setRootNode(rootNode);
    cssNode.setThemedContext(rootNode.getThemedContext());

    mShadowNodeRegistry.addNode(cssNode);

    ReactStylesDiffMap styles = null;
    if (props != null) {
      styles = new ReactStylesDiffMap(props);
      cssNode.updateProperties(styles);
    }

    handleCreateView(cssNode, rootViewTag, styles);
  }
  
    protected void handleCreateView(
        ReactShadowNode cssNode,
        int rootViewTag,
        @Nullable ReactStylesDiffMap styles) {
      if (!cssNode.isVirtual()) {
        mNativeViewHierarchyOptimizer.handleCreateView(cssNode, cssNode.getThemedContext(), styles);
      }
    }
}

public class NativeViewHierarchyManager {

    public void createView(
          ThemedReactContext themedContext,
          int tag,
          String className,
          @Nullable ReactStylesDiffMap initialProps) {
        UiThreadUtil.assertOnUiThread();
        SystraceMessage.beginSection(
            Systrace.TRACE_TAG_REACT_VIEW,
            "NativeViewHierarchyManager_createView")
            .arg("tag", tag)
            .arg("className", className)
            .flush();
        try {
          ViewManager viewManager = mViewManagers.get(className);
    
          View view = viewManager.createView(themedContext, mJSResponderHandler);
          mTagsToViews.put(tag, view);
          mTagsToViewManagers.put(tag, viewManager);
    
          // Use android View id field to store React tag. This is possible since we don't inflate
          // React views from layout xmls. Thus it is easier to just reuse that field instead of
          // creating another (potentially much more expensive) mapping from view to React tag
          view.setId(tag);
          if (initialProps != null) {
            viewManager.updateProperties(view, initialProps);
          }
        } finally {
          Systrace.endSection(Systrace.TRACE_TAG_REACT_VIEW);
        }
      }
}

@ReactPropertyHolder
public abstract class ViewManager<T extends View, C extends ReactShadowNode>
  extends BaseJavaModule {

     public final T createView(
         ThemedReactContext reactContext,
         JSResponderHandler jsResponderHandler) {
       T view = createViewInstance(reactContext);
       addEventEmitters(reactContext, view);
       if (view instanceof ReactInterceptingViewGroup) {
         ((ReactInterceptingViewGroup) view).setOnInterceptTouchEventListener(jsResponderHandler);
       }
       return view;
     }
}