[RFC][Bridge] Add support for JS async functions, backed by RCT_EXPORT_PROMISE

ide · ide · commit 0cdcfab65c55 · 2015-05-11T02:16:26.000-07:00
Adds support for JS async methods and helps guide people writing native modules w.r.t. the callbacks. With this diff, on the native side you write:

```objc
RCT_EXPORT_PROMISE(getValueAsync:(NSString *)key)
{
  NSError *error = nil;
  id value = [_nativeDataStore valueForKey:key error:&amp;error];

  // "resolve" and "reject" are automatically defined blocks that take
  // any object (nil is OK) and an NSError, respectively
  if (!error) {
    resolve(value);
  } else {
    reject(error);
  }
}
```

On the JS side, you can write:

```js
var {DemoDataStore} = require('react-native').NativeModules;
DemoDataStore.getValueAsync('sample-key').then((value) =&gt; {
  console.log('Got:', value);
}, (error) =&gt; {
  console.error(error);
  // "error" is an Error object whose message is the NSError's description.
  // The NSError's code and domain are also set, and the native trace is
  // available under
});
```

And if you take a time machine or use Babel w/stage 1, you can write:

```js
try {
  var value = await DemoDataStore.getValueAsync('sample-key');
  console.log('Got:', value);
} catch (error) {
  console.error(error);
}
```

For now the macro is defined as RCT_EXPORT_PROMISE_EXPERIMENTAL since I'd like to merge this and get real-world feedback on the API before committing to it.
diff --git a/Libraries/BatchedBridge/BatchingImplementation/BatchedBridgeFactory.js b/Libraries/BatchedBridge/BatchingImplementation/BatchedBridgeFactory.js
@@ -19,6 +19,7 @@ var slice = Array.prototype.slice;
 
 var MethodTypes = keyMirror({
   remote: null,
+  remoteAsync: null,
   local: null,
 });
 
@@ -36,21 +37,40 @@ var BatchedBridgeFactory = {
    */
   _createBridgedModule: function(messageQueue, moduleConfig, moduleName) {
     var remoteModule = mapObject(moduleConfig.methods, function(methodConfig, memberName) {
-      return methodConfig.type === MethodTypes.local ? null : function() {
-        var lastArg = arguments.length > 0 ? arguments[arguments.length - 1] : null;
-        var secondLastArg = arguments.length > 1 ? arguments[arguments.length - 2] : null;
-        var hasSuccCB = typeof lastArg === 'function';
-        var hasErrorCB = typeof secondLastArg === 'function';
-        hasErrorCB && invariant(
-          hasSuccCB,
-          'Cannot have a non-function arg after a function arg.'
-        );
-        var numCBs = (hasSuccCB ? 1 : 0) + (hasErrorCB ? 1 : 0);
-        var args = slice.call(arguments, 0, arguments.length - numCBs);
-        var onSucc = hasSuccCB ? lastArg : null;
-        var onFail = hasErrorCB ? secondLastArg : null;
-        return messageQueue.call(moduleName, memberName, args, onFail, onSucc);
-      };
+      switch (methodConfig.type) {
+        case MethodTypes.remote:
+          return function() {
+            var lastArg = arguments.length > 0 ? arguments[arguments.length - 1] : null;
+            var secondLastArg = arguments.length > 1 ? arguments[arguments.length - 2] : null;
+            var hasSuccCB = typeof lastArg === 'function';
+            var hasErrorCB = typeof secondLastArg === 'function';
+            hasErrorCB && invariant(
+              hasSuccCB,
+              'Cannot have a non-function arg after a function arg.'
+            );
+            var numCBs = (hasSuccCB ? 1 : 0) + (hasErrorCB ? 1 : 0);
+            var args = slice.call(arguments, 0, arguments.length - numCBs);
+            var onSucc = hasSuccCB ? lastArg : null;
+            var onFail = hasErrorCB ? secondLastArg : null;
+            messageQueue.call(moduleName, memberName, args, onFail, onSucc);
+          };
+
+        case MethodTypes.remoteAsync:
+          return function(...args) {
+            return new Promise((resolve, reject) => {
+              messageQueue.call(moduleName, memberName, args, (errorData) => {
+                var error = _createErrorFromErrorData(errorData);
+                reject(error);
+              }, resolve);
+            });
+          };
+
+        case MethodTypes.local:
+          return null;
+
+        default:
+          throw new Error('Unknown bridge method type: ' + methodConfig.type);
+      }
     });
     for (var constName in moduleConfig.constants) {
       warning(!remoteModule[constName], 'saw constant and method named %s', constName);
@@ -59,7 +79,6 @@ var BatchedBridgeFactory = {
     return remoteModule;
   },
 
-
   create: function(MessageQueue, modulesConfig, localModulesConfig) {
     var messageQueue = new MessageQueue(modulesConfig, localModulesConfig);
     return {
@@ -80,4 +99,13 @@ var BatchedBridgeFactory = {
   }
 };
 
+function _createErrorFromErrorData(errorData: ErrorData): Error {
+  var {
+    message,
+    ...extraErrorInfo,
+  } = errorData;
+  var error = new Error(message);
+  return Object.assign(error, extraErrorInfo);
+}
+
 module.exports = BatchedBridgeFactory;
diff --git a/Libraries/Utilities/MessageQueue.js b/Libraries/Utilities/MessageQueue.js
@@ -31,10 +31,17 @@ type ModulesConfig = {
       methodID: number;
     }};
   }
-}
+};
+
+type ErrorData = {
+  message: string;
+  domain: string;
+  code: number;
+  nativeStackIOS?: Array<string>;
+};
 
-type NameToID = {[key:string]: number}
-type IDToName = {[key:number]: string}
+type NameToID = {[key:string]: number};
+type IDToName = {[key:number]: string};
 
 /**
  * So as not to confuse static build system.
@@ -290,6 +297,40 @@ var MessageQueueMixin = {
     );
   },
 
+  invokePromiseRejecterAndReturnFlushedQueue: function(cbID, errorData: ErrorData) {
+    if (this._enableLogging) {
+      this._loggedIncomingItems.push([new Date().getTime(), cbID, errorData]);
+    }
+    return guardReturn(
+      this._invokePromiseRejecter,
+      [cbID, errorData],
+      this._flushedQueueUnguarded,
+      this
+    );
+  },
+
+  _invokePromiseRejecter(cbID, errorData: ErrorData) {
+    try {
+      var error = this._createErrorFromErrorData(errorData);
+    } catch (e) {
+      // Clear out the related resources. Normally this is handled after
+      // invoking the callback but we haven't gone that far in this code path.
+      this._freeResourcesForCallbackID(cbID);
+      throw e;
+    }
+
+    this._invokeCallback(cbID, [error]);
+  },
+
+  _createErrorFromErrorData: function(errorData: ErrorData): Error {
+    var {
+      message,
+      ...extraErrorInfo,
+    } = errorData;
+    var error = new Error(message);
+    return Object.assign(error, extraErrorInfo);
+  },
+
   callFunction: function(moduleID, methodID, params) {
     return guardReturn(this._callFunction, [moduleID, methodID, params], null, this);
   },
diff --git a/React/Base/RCTBridge.m b/React/Base/RCTBridge.m
@@ -16,6 +16,7 @@
 #import <mach-o/dyld.h>
 #import <mach-o/getsect.h>
 
+#import "RCTBridgeModule_Internal.h"
 #import "RCTContextExecutor.h"
 #import "RCTConvert.h"
 #import "RCTEventDispatcher.h"
@@ -240,6 +241,7 @@ @interface RCTModuleMethod : NSObject
 @property (nonatomic, copy, readonly) NSString *moduleClassName;
 @property (nonatomic, copy, readonly) NSString *JSMethodName;
 @property (nonatomic, assign, readonly) SEL selector;
+@property (nonatomic, assign, readonly) RCTBridgeFunctionKind functionKind;
 
 @end
 
@@ -266,8 +268,10 @@ @implementation RCTModuleMethod
 - (instancetype)initWithReactMethodName:(NSString *)reactMethodName
                          objCMethodName:(NSString *)objCMethodName
                            JSMethodName:(NSString *)JSMethodName
+                           functionKind:(RCTBridgeFunctionKind)functionKind
 {
   if ((self = [super init])) {
+    _functionKind = functionKind;
     _methodName = reactMethodName;
     NSArray *parts = [[reactMethodName substringWithRange:(NSRange){2, reactMethodName.length - 3}] componentsSeparatedByString:@" "];
 
@@ -421,6 +425,43 @@ - (instancetype)initWithReactMethodName:(NSString *)reactMethodName
         } else if ([argumentName isEqualToString:@"RCTResponseSenderBlock"]) {
           addBlockArgument();
           useFallback = NO;
+        } else if ([argumentName isEqualToString:@"RCTPromiseResolverBlock"]) {
+          RCT_ARG_BLOCK(
+            if (RCT_DEBUG && ![json isKindOfClass:[NSNumber class]]) {
+              RCTLogError(@"Argument %tu (%@) of %@.%@ must be a Promise resolver ID", index,
+                          json, RCTBridgeModuleNameForClass(_moduleClass), _JSMethodName);
+              return;
+            }
+
+            // Marked as autoreleasing, because NSInvocation doesn't retain arguments
+            __autoreleasing RCTPromiseResolverBlock value = (^(id result) {
+              NSArray *arguments = result ? @[result] : @[];
+              [bridge _invokeAndProcessModule:@"BatchedBridge"
+                                       method:@"invokeCallbackAndReturnFlushedQueue"
+                                    arguments:@[json, arguments]
+                                      context:context];
+            });
+          )
+          useFallback = NO;
+        } else if ([argumentName isEqualToString:@"RCTPromiseRejecterBlock"]) {
+          RCT_ARG_BLOCK(
+            if (RCT_DEBUG && ![json isKindOfClass:[NSNumber class]]) {
+              RCTLogError(@"Argument %tu (%@) of %@.%@ must be a Promise resolver ID", index,
+                          json, RCTBridgeModuleNameForClass(_moduleClass), _JSMethodName);
+              return;
+            }
+
+            // Marked as autoreleasing, because NSInvocation doesn't retain arguments
+            __autoreleasing RCTPromiseRejecterBlock value = (^(NSError *error) {
+              NSDictionary *errorData = [RCTModuleMethod dictionaryFromError:error
+                                                                  stackTrace:[NSThread callStackSymbols]];
+              [bridge _invokeAndProcessModule:@"BatchedBridge"
+                                       method:@"invokeCallbackAndReturnFlushedQueue"
+                                    arguments:@[json, @[errorData]]
+                                      context:context];
+            });
+          )
+          useFallback = NO;
         }
       }
 
@@ -499,9 +540,18 @@ - (void)invokeWithBridge:(RCTBridge *)bridge
 
     // Safety check
     if (arguments.count != _argumentBlocks.count) {
+      NSInteger actualCount = arguments.count;
+      NSInteger expectedCount = _argumentBlocks.count;
+
+      // Subtract the implicit Promise resolver and rejecter functions for implementations of async functions
+      if (_functionKind == RCTBridgeFunctionKindAsync) {
+        actualCount -= 2;
+        expectedCount -= 2;
+      }
+
       RCTLogError(@"%@.%@ was called with %zd arguments, but expects %zd",
                   RCTBridgeModuleNameForClass(_moduleClass), _JSMethodName,
-                  arguments.count, _argumentBlocks.count);
+                  actualCount, expectedCount);
       return;
     }
   }
@@ -529,6 +579,26 @@ - (NSString *)description
   return [NSString stringWithFormat:@"<%@: %p; exports %@ as %@;>", NSStringFromClass(self.class), self, _methodName, _JSMethodName];
 }
 
++ (NSDictionary *)dictionaryFromError:(NSError *)error stackTrace:(NSArray *)stackTrace
+{
+  NSString *errorMessage;
+  NSMutableDictionary *errorInfo = [NSMutableDictionary dictionaryWithDictionary:@{
+    @"nativeStackIOS": stackTrace,
+  }];
+
+  if (error) {
+    errorMessage = error.localizedDescription ?: @"Unknown error from a native module";
+    errorInfo[@"domain"] = error.domain ?: RCTErrorDomain;
+    errorInfo[@"code"] = @(error.code);
+  } else {
+    errorMessage = @"Unknown error from a native module";
+    errorInfo[@"domain"] = RCTErrorDomain;
+    errorInfo[@"code"] = @(-1);
+  }
+
+  return RCTMakeError(errorMessage, nil, errorInfo);
+}
+
 @end
 
 /**
@@ -557,7 +627,7 @@ - (NSString *)description
 
     for (RCTHeaderValue addr = section->offset;
          addr < section->offset + section->size;
-         addr += sizeof(const char **) * 3) {
+         addr += sizeof(const char **) * 4) {
 
       // Get data entry
       const char **entries = (const char **)(mach_header + addr);
@@ -569,11 +639,13 @@ - (NSString *)description
         // Legacy support for RCT_EXPORT()
         moduleMethod = [[RCTModuleMethod alloc] initWithReactMethodName:@(entries[0])
                                                          objCMethodName:@(entries[0])
-                                                           JSMethodName:strlen(entries[1]) ? @(entries[1]) : nil];
+                                                           JSMethodName:strlen(entries[1]) ? @(entries[1]) : nil
+                                                           functionKind:(RCTBridgeFunctionKind)entries[3]];
       } else {
         moduleMethod = [[RCTModuleMethod alloc] initWithReactMethodName:@(entries[0])
                                                          objCMethodName:strlen(entries[1]) ? @(entries[1]) : nil
-                                                           JSMethodName:strlen(entries[2]) ? @(entries[2]) : nil];
+                                                           JSMethodName:strlen(entries[2]) ? @(entries[2]) : nil
+                                                           functionKind:(RCTBridgeFunctionKind)entries[3]];
       }
 
       // Cache method
@@ -607,7 +679,7 @@ - (NSString *)description
  *     },
  *     "methodName2": {
  *       "methodID": 1,
- *       "type": "remote"
+ *       "type": "remoteAsync"
  *     },
  *     etc...
  *   },
@@ -631,7 +703,7 @@ - (NSString *)description
       [methods enumerateObjectsUsingBlock:^(RCTModuleMethod *method, NSUInteger methodID, BOOL *_stop) {
         methodsByName[method.JSMethodName] = @{
           @"methodID": @(methodID),
-          @"type": @"remote",
+          @"type": method.functionKind == RCTBridgeFunctionKindAsync ? @"remoteAsync" : @"remote",
         };
       }];
 
diff --git a/React/Base/RCTBridgeModule.h b/React/Base/RCTBridgeModule.h
@@ -9,6 +9,8 @@
 
 #import <Foundation/Foundation.h>
 
+#import "RCTBridgeModule_Internal.h"
+
 @class RCTBridge;
 
 /**
@@ -17,6 +19,11 @@
  */
 typedef void (^RCTResponseSenderBlock)(NSArray *response);
 
+typedef void (^RCTPromiseResolverBlock)(id result);
+
+typedef void (^RCTPromiseRejecterBlock)(NSError *error);
+
+
 /**
  * This constant can be returned from +methodQueue to force module
  * methods to be called on the JavaScript thread. This can have serious
@@ -83,7 +90,28 @@ extern const dispatch_queue_t RCTJSThread;
  * { ... }
  */
 #define RCT_REMAP_METHOD(js_name, method) \
-  RCT_EXTERN_REMAP_METHOD(js_name, method) \
+  _RCT_REMAP_METHOD_INTERNAL(js_name, method, RCTBridgeFunctionKindNormal) \
+
+#define RCT_EXPORT_PROMISE_EXPERIMENTAL(method) \
+  RCT_REMAP_PROMISE_EXPERIMENTAL(, method)
+
+// XXX(ide): is there a trick to support 0-arg methods just one macro?
+#define RCT_EXPORT_NULLARY_PROMISE_EXPERIMENTAL(method) \
+  _RCT_REMAP_METHOD_INTERNAL( \
+    , \
+    method:(RCTPromiseRejecterBlock)reject __rct_resolver:(RCTPromiseResolverBlock)resolve, \
+    RCTBridgeFunctionKindAsync \
+  )
+
+#define RCT_REMAP_PROMISE_EXPERIMENTAL(js_name, method) \
+  _RCT_REMAP_METHOD_INTERNAL( \
+    js_name, \
+    method __rct_rejecter:(RCTPromiseRejecterBlock)reject __rct_resolver:(RCTPromiseResolverBlock)resolve, \
+    RCTBridgeFunctionKindAsync \
+  )
+
+#define _RCT_REMAP_METHOD_INTERNAL(js_name, method, functionKind) \
+  _RCT_EXTERN_REMAP_METHOD_INTERNAL(js_name, method, functionKind) \
   - (void)method
 
 /**
@@ -139,10 +167,25 @@ extern const dispatch_queue_t RCTJSThread;
  * Similar to RCT_EXTERN_REMAP_METHOD but allows setting a custom JavaScript name
  */
 #define RCT_EXTERN_REMAP_METHOD(js_name, method) \
+  _RCT_EXTERN_REMAP_METHOD_INTERNAL(js_name, method, RCTBridgeFunctionKindNormal)
+
+/**
+ * Internal implementation of RCTExport
+ *
+ * @param js_name       method name exposed to JavaScript
+ * @param method        name of the Objective-C method being exported
+ * @param functionKind  kind of JavaScript function to define; one of RCTBridgeFunctionKind
+ */
+#define _RCT_EXTERN_REMAP_METHOD_INTERNAL(js_name, method, functionKind) \
   - (void)__rct_export__##method { \
     __attribute__((used, section("__DATA,RCTExport"))) \
     __attribute__((__aligned__(1))) \
-    static const char *__rct_export_entry__[] = { __func__, #method, #js_name }; \
+    static const char *__rct_export_entry__[] = { \
+      __func__, \
+      #method, \
+      #js_name, \
+      (char *)functionKind \
+    }; \
   }
 
 /**
@@ -152,7 +195,7 @@ extern const dispatch_queue_t RCTJSThread;
   _Pragma("message(\"RCT_EXPORT is deprecated. Use RCT_EXPORT_METHOD instead.\")") \
   __attribute__((used, section("__DATA,RCTExport"))) \
   __attribute__((__aligned__(1))) \
-  static const char *__rct_export_entry__[] = { __func__, #js_name, NULL }
+  static const char *__rct_export_entry__[] = { __func__, #js_name, NULL, RCTBridgeFunctionKindNormal }
 
 /**
  * The queue that will be used to call all exported methods. If omitted, this
diff --git a/React/Base/RCTBridgeModule_Internal.h b/React/Base/RCTBridgeModule_Internal.h
diff --git a/React/React.xcodeproj/project.pbxproj b/React/React.xcodeproj/project.pbxproj
