public void ReverseTwoCallbacksMethod(bool shouldSucceed, ReactCallback <string> onFailure, ReactCallback <string> onSuccess)
{
Debug.WriteLine($"{nameof(SampleModuleCS)}.{nameof(ReverseTwoCallbacksMethod)}({shouldSucceed})");
if (shouldSucceed)
{
onSuccess("ReverseTwoCallbacksMethod succeeded");
}
else
{
onFailure("ReverseTwoCallbacksMethod failed");
}
}
public void ExplicitPromiseMethodWithArgs(double arg, ReactCallback <double> resolve, ReactCallback <string> reject)
{
Debug.WriteLine($"{Name}.{nameof(ExplicitPromiseMethodWithArgs)}({arg})");
try
{
resolve(Math.PI);
}
catch (Exception ex)
{
reject(ex.Message);
}
}
public async void TwoCallbacksAsyncMethod(bool shouldSucceed, ReactCallback <string> onSuccess, ReactCallback <string> onFailure)
{
Debug.WriteLine($"{nameof(SampleModuleCS)}.{nameof(TwoCallbacksAsyncMethod)}({shouldSucceed})");
await Task.Run(() => { });
if (shouldSucceed)
{
onSuccess("TwoCallbacksMethod succeeded");
}
else
{
onFailure("TwoCallbacksMethod failed");
}
}
private ExpressionSyntax GenerateCallback(ReactCallback callback, SyntaxToken contextCallbackMethod)
{
var lambdaParams = new List <ParameterSyntax>(callback.CallbackParameters.Length);
var arguments = new List <ArgumentSyntax>(callback.CallbackParameters.Length);
arguments.Add(Argument(IdentifierName(ReactNativeNames.WriterLocalName)));
for (int i = 0; i < callback.CallbackParameters.Length; i++)
{
var paramType = callback.CallbackParameters[i].Type;
var identifierName = "arg" + i.ToString(CultureInfo.InvariantCulture);
lambdaParams.Add(Parameter(Identifier(identifierName)).WithType(paramType.ToTypeSyntax()));
arguments.Add(Argument(IdentifierName(identifierName)));
}
// generates:
// module.<callackName> = (ArgType0 arg0, ArgType1 arg0, ...) =>
// reactContext.<contextCallbackMethod>(
// eventEmitterName,
// eventName,
// writer => writer.WriteArgs(arg0, arg1, ...)
// )
return
(AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
MemberAccessExpression(ReactNativeNames.Module, Identifier(callback.Symbol.Name)),
ParenthesizedLambdaExpression(
parameterList: ParameterList(lambdaParams.ToArray()),
block: null,
expressionBody: InvocationExpression(
MemberAccessExpression(ReactNativeNames.ReactContextLocalName, contextCallbackMethod),
LiteralExpression(callback.CallbackContextName),
LiteralExpression(callback.Name),
ParenthesizedLambdaExpression(
parameterList: ParameterList(Parameter(ReactNativeNames.WriterLocalName)),
block: null,
expressionBody: InvocationExpression(
MemberAccessExpression(ReactTypes.JSValueWriter, ReactNativeNames.WriteArgsMethodName),
arguments
))))));
}
public void ExplicitCallbackMethodWithArgs(double arg, ReactCallback <double> callback)
{
Debug.WriteLine($"{Name}.{nameof(ExplicitCallbackMethodWithArgs)}({arg})");
callback(Math.PI);
}
public void ExplicitCallbackMethod(ReactCallback <double> callback)
{
Debug.WriteLine($"{Name}.{nameof(ExplicitCallbackMethod)}()");
callback(Math.PI);
}
