function iOSExec() {
  ...
  if (!isInContextOfEvalJs && commandQueue.length == 1)  {
      // Èç¹ûÖ§³Ö XMLHttpRequest£¬ÔòʹÓà XMLHttpRequest ·½Ê½
      if (bridgeMode != jsToNativeModes.IFRAME_NAV) {
            // This prevents sending an XHR when there is already one being sent.
            // This should happen only in rare circumstances (refer to unit tests).
            if (execXhr && execXhr.readyState != 4) {
                execXhr = null;
            }
            // Re-using the XHR improves exec() performance by about 10%.
            execXhr = execXhr || new XMLHttpRequest();
            // Changing this to a GET will make the XHR reach the URIProtocol on 4.2.
            // For some reason it still doesn't work though...
            // Add a timestamp to the query param to prevent caching.
            execXhr.open('HEAD', "/!gap_exec?" + (+new Date()), true);
            if (!vcHeaderValue) {
                vcHeaderValue = /.*\((.*)\)/.exec(navigator.userAgent)[1];
            }
            execXhr.setRequestHeader('vc', vcHeaderValue);
            execXhr.setRequestHeader('rc', ++requestCount);
            if (shouldBundleCommandJson()) {
              // ÉèÖÃÇëÇóµÄÊý¾Ý
                execXhr.setRequestHeader('cmds', iOSExec.nativeFetchMessages());
            }
            // ·¢ÆðÇëÇó
            execXhr.send(null);
        } else {
          // Èç¹û²»Ö§³Ö XMLHttpRequest£¬ÔòʹÓÃ͸Ã÷ iframe µÄ·½Ê½£¬ÉèÖà iframe µÄ src ÊôÐÔ
            execIframe = execIframe || createExecIframe();
            execIframe.src = "gap://ready";
        }
    }
  ...
}

+ (BOOL)canInitWithRequest:(NSURLRequest*)theRequest
{
    NSURL* theUrl = [theRequest URL];
    NSString* theScheme = [theUrl scheme];

// ÅжÏÇëÇóÊÇ·ñΪ /!gap_exec
if ([[theUrl path] isEqualToString:@"/!gap_exec"]) {
NSString* viewControllerAddressStr = [theRequest valueForHTTPHeaderField:@"vc"];
if (viewControllerAddressStr == nil) {
NSLog(@"!cordova request missing vc header");
return NO;
}
long long viewControllerAddress = [viewControllerAddressStr longLongValue];
// Ensure that the UCCDVViewController has not been dealloc'ed.
UCCDVViewController* viewController = nil;
@synchronized(gRegisteredControllers) {
if (![gRegisteredControllers containsObject:
[NSNumber numberWithLongLong:viewControllerAddress]]) {
return NO;
}
viewController = (UCCDVViewController*)(void*)viewControllerAddress;
}

// »ñÈ¡ÇëÇóµÄÊý¾Ý
NSString* queuedCommandsJSON = [theRequest valueForHTTPHeaderField:@"cmds"];
NSString* requestId = [theRequest valueForHTTPHeaderField:@"rc"];
if (requestId == nil) {
NSLog(@"!cordova request missing rc header");
return NO;
}
...
}
...
}

// XHR mode does not work on iOS 4.2, so default to IFRAME_NAV for such devices.
// XHR mode¡¯s main advantage is working around a bug in -webkit-scroll, which
// doesn¡¯t exist in 4.X devices anyways

// UIWebView ¼ÓÔØ URL Ç°»Øµ÷µÄ·½·¨£¬·µ»Ø YES£¬Ôò¿ªÊ¼¼ÓÔØ´Ë URL£¬·µ»Ø NO£¬ÔòºöÂÔ´Ë URL
- (BOOL)webView:(UIWebView*)theWebView
          shouldStartLoadWithRequest:(NSURLRequest*)request
          navigationType:(UIWebViewNavigationType)navigationType
{
    NSURL* url = [request URL];

/*
* Execute any commands queued with cordova.exec() on the JS side.
* The part of the URL after gap:// is irrelevant.
*/
// ÅжÏÊÇ·ñ Cordova µÄÇëÇ󣬶ÔÓÚ JS ´úÂëÖÐ execIframe.src = "gap://ready" Õâ¾ä
if ([[url scheme] isEqualToString:@"gap"]) {
// »ñÈ¡ÇëÇóµÄÊý¾Ý£¬²¢¶ÔÊý¾Ý½øÐзÖÎö¡¢´¦Àí
[_commandQueue fetchCommandsFromJs];
return NO;
}
...
}

- (void)fetchCommandsFromJs
{
    // Grab all the queued commands from the JS side.
    NSString* queuedCommandsJSON = [_viewController.webView
                                      stringByEvaluatingJavaScriptFromString:
                                          @"cordova.require('cordova/exec').nativeFetchMessages()"];

[self enqueCommandBatch:queuedCommandsJSON];
if ([queuedCommandsJSON length] > 0) {
CDV_EXEC_LOG(@"Exec: Retrieved new exec messages by request.");
}
}

- (void)evalJs:(NSString*)js scheduledOnRunLoop:(BOOL)scheduledOnRunLoop
{
    js = [NSString stringWithFormat:
                  @"cordova.require('cordova/exec').nativeEvalAndFetch(function(){ %@ })",
                  js];
    if (scheduledOnRunLoop) {
        [self evalJsHelper:js];
    } else {
        [self evalJsHelper2:js];
    }
}

- (void)evalJsHelper2:(NSString*)js
{
CDV_EXEC_LOG(@"Exec: evalling: %@", [js substringToIndex:MIN([js length], 160)]);
NSString* commandsJSON = [_viewController.webView
stringByEvaluatingJavaScriptFromString:js];
if ([commandsJSON length] > 0) {
CDV_EXEC_LOG(@"Exec: Retrieved new exec messages by chaining.");
}

[_commandQueue enqueCommandBatch:commandsJSON];
}

- (void)evalJsHelper:(NSString*)js
{
// Cycle the run-loop before executing the JS.
// This works around a bug where sometimes alerts() within callbacks can cause
// dead-lock.
// If the commandQueue is currently executing, then we know that it is safe to
// execute the callback immediately.
// Using (dispatch_get_main_queue()) does *not* fix deadlocks for some reaon,
// but performSelectorOnMainThread: does.
if (![NSThread isMainThread] || !_commandQueue.currentlyExecuting) {
[self performSelectorOnMainThread:@selector(evalJsHelper2:)
withObject:js
waitUntilDone:NO];
} else {
[self evalJsHelper2:js];
}
}

// successCallback : ³É¹¦»Øµ÷·½·¨
// failCallback    : ʧ°Ü»Øµ÷·½·¨
// server          : ËùÒªÇëÇóµÄ·þÎñÃû×Ö
// action          : ËùÒªÇëÇóµÄ·þÎñ¾ßÌå²Ù×÷
// actionArgs      : ÇëÇó²Ù×÷Ëù´øµÄ²ÎÊý
cordova.exec(successCallback, failCallback, service, action, actionArgs);

function iOSExec() {
    ...
  // Éú³ÉÒ»¸ö callbackId µÄΨһ±êʶ£¬²¢°Ñ´Ë±êÖ¾Óë³É¹¦¡¢Ê§°Ü»Øµ÷·½·¨Ò»Æð±£´æÔÚ JS ¶Ë
    // Register the callbacks and add the callbackId to the positional
    // arguments if given.
    if (successCallback || failCallback) {
        callbackId = service + cordova.callbackId++;
        cordova.callbacks[callbackId] =
            {success:successCallback, fail:failCallback};
    }

actionArgs = massageArgsJsToNative(actionArgs);

// °Ñ callbackId£¬service£¬action£¬actionArgs ±£³Öµ½ commandQueue ÖÐ
// ÕâËĸö²ÎÊý¾ÍÊÇ×îºó·¢¸øÔ­Éú´úÂëµÄÊý¾Ý
var command = [callbackId, service, action, actionArgs];
commandQueue.push(JSON.stringify(command));
...
}

// »ñÈ¡ÇëÇóµÄÊý¾Ý£¬°üÀ¨ callbackId, service, action, actionArgs
iOSExec.nativeFetchMessages = function() {
// Each entry in commandQueue is a JSON string already.
if (!commandQueue.length) {
return '';
}
var json = '[' + commandQueue.join(',') + ']';
commandQueue.length = 0;
return json;
};

- (void)sendPluginResult:(CDVPluginResult*)result callbackId:(NSString*)callbackId
{
    CDV_EXEC_LOG(@"Exec(%@): Sending result. Status=%@", callbackId, result.status);
    // This occurs when there is are no win/fail callbacks for the call.
    if ([@"INVALID" isEqualToString : callbackId]) {
        return;
    }
    int status = [result.status intValue];
    BOOL keepCallback = [result.keepCallback boolValue];
    NSString* argumentsAsJSON = [result argumentsAsJSON];

// ½«ÇëÇóµÄ´¦Àí½á¹û¼° callbackId ͨ¹ýµ÷Óà JS ·½·¨·µ»Ø¸ø JS ¶Ë
NSString* js = [NSString stringWithFormat:
@"cordova.require('cordova/exec').nativeCallback('%@',%d,%@,%d)",
callbackId, status, argumentsAsJSON, keepCallback];

[self evalJsHelper:js];
}

 // ¸ù¾Ý callbackId ¼°ÊÇ·ñ³É¹¦±êʶ£¬ÕÒµ½»Øµ÷·½·¨£¬²¢°Ñ´¦Àí½á¹û´«¸ø»Øµ÷·½·¨
 callbackFromNative: function(callbackId, success, status, args, keepCallback) {
        var callback = cordova.callbacks[callbackId];
        if (callback) {
            if (success && status == cordova.callbackStatus.OK) {
                callback.success && callback.success.apply(null, args);
            } else if (!success) {
                callback.fail && callback.fail.apply(null, args);
            }

// Clear callback if not expecting any more results
if (!keepCallback) {
delete cordova.callbacks[callbackId];
}
}
}