public async Task Timing_Repeat()
{
await DispatcherHelpers.RunOnDispatcherAsync(ReactChoreographer.Initialize);
var ids = new List <int>();
var repeat = 10;
var interval = 200;
var countdown = new CountdownEvent(repeat);
var context = CreateReactContext(new MockInvocationHandler((name, args) =>
{
Assert.AreEqual(name, nameof(JSTimers.callTimers));
ids.AddRange((IList <int>)args[0]);
if (countdown.CurrentCount > 0)
{
var t = ThreadPool.RunAsync(_ => countdown.Signal());
}
}));
var timing = new Timing(context);
timing.Initialize();
await DispatcherHelpers.RunOnDispatcherAsync(context.OnResume);
var id = 42;
var now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
timing.createTimer(id, interval, now, true);
Assert.IsTrue(countdown.Wait(interval * repeat * 2));
timing.deleteTimer(id);
Assert.AreEqual(42, ids.Distinct().SingleOrDefault());
Assert.IsTrue(ids.Count >= repeat);
await DispatcherHelpers.CallOnDispatcherAsync(context.DisposeAsync);
await DispatcherHelpers.RunOnDispatcherAsync(ReactChoreographer.Dispose);
}
public async Task Timing_Zero_Repeat()
{
var ids = new List <int>();
var countdown = new CountdownEvent(60);
var context = CreateReactContext(new MockInvocationHandler((name, args) =>
{
Assert.AreEqual(name, nameof(JSTimersExecution.callTimers));
ids.AddRange((IList <int>)args[0]);
countdown.Signal();
}));
var timing = new Timing(context);
timing.Initialize();
await DispatcherHelpers.RunOnDispatcherAsync(context.OnResume);
// Callback is called directly
timing.createTimer(42, 0, DateTimeOffset.Now.ToUnixTimeMilliseconds(), true);
countdown.Wait();
timing.deleteTimer(42);
await DispatcherHelpers.RunOnDispatcherAsync(context.Dispose);
}
public async Task Timing_Zero_NoRepeat()
{
var ids = new List <int>();
var waitHandle = new AutoResetEvent(false);
var context = CreateReactContext(new MockInvocationHandler((name, args) =>
{
Assert.AreEqual(name, nameof(JSTimersExecution.callTimers));
ids.AddRange((IList <int>)args[0]);
waitHandle.Set();
}));
var timing = new Timing(context);
timing.Initialize();
await DispatcherHelpers.RunOnDispatcherAsync(context.OnResume);
// Callback is called directly
timing.createTimer(42, 0, DateTimeOffset.Now.ToUnixTimeMilliseconds(), false);
Assert.IsTrue(new[] { 42 }.SequenceEqual(ids));
await DispatcherHelpers.RunOnDispatcherAsync(context.Dispose);
}
public async Task UIManagerModule_getConstantsForViewManager()
{
await DispatcherHelpers.RunOnDispatcherAsync(ReactChoreographer.Initialize);
var context = new ReactContext();
var viewManagers = new List <IViewManager> {
new TestViewManager()
};
var uiImplementationProvider = new UIImplementationProvider();
using (var actionQueue = new ActionQueue(ex => { }))
{
var module = await DispatcherHelpers.CallOnDispatcherAsync(() => new UIManagerModule(context, viewManagers, uiImplementationProvider, actionQueue, UIManagerModuleOptions.LazyViewManagers));
var constants = module.getConstantsForViewManager("Test");
Assert.AreEqual(42, constants.GetMap("directEventTypes").GetValue("otherSelectionChange").Value <int>());
Assert.AreEqual(42, constants.GetMap("directEventTypes").GetMap("topSelectionChange").GetValue("registrationName").Value <int>());
Assert.AreEqual(42, constants.GetMap("directEventTypes").GetMap("topLoadingStart").GetValue("foo").Value <int>());
Assert.AreEqual(42, constants.GetMap("directEventTypes").GetValue("topLoadingError").Value <int>());
}
await DispatcherHelpers.RunOnDispatcherAsync(ReactChoreographer.Dispose);
}
public async Task UIManagerModule_Constants_ViewManager_LazyConstants()
{
await DispatcherHelpers.RunOnDispatcherAsync(ReactChoreographer.Initialize);
var context = new ReactContext();
var viewManagers = new List <IViewManager> {
new TestViewManager()
};
var uiImplementationProvider = new UIImplementationProvider();
using (var actionQueue = new ActionQueue(ex => { }))
{
var module = await DispatcherHelpers.CallOnDispatcherAsync(() => new UIManagerModule(context, viewManagers, uiImplementationProvider, actionQueue, UIManagerModuleOptions.LazyViewManagers));
var obj = ((INativeModule)module).Constants.GetValue("ViewManagerNames");
var viewManagerNames = obj as JArray;
Assert.IsNotNull(viewManagerNames);
Assert.AreEqual(1, viewManagerNames.Count());
Assert.AreEqual("Test", viewManagerNames.Single().Value <string>());
}
await DispatcherHelpers.RunOnDispatcherAsync(ReactChoreographer.Dispose);
}
public async Task EventDispatcher_NonCoalesced()
{
await DispatcherHelpers.RunOnDispatcherAsync(ReactChoreographer.Initialize);
var waitDispatched = new AutoResetEvent(false);
var executor = new MockJavaScriptExecutor
{
OnCallFunctionReturnFlushedQueue = (p0, p1, p2) =>
{
waitDispatched.Set();
return(EmptyResponse);
},
OnFlushQueue = () => EmptyResponse,
OnInvokeCallbackAndReturnFlushedQueue = (_, __) => EmptyResponse
};
var context = await CreateContextAsync(executor);
var dispatcher = new EventDispatcher(context);
await DispatcherHelpers.RunOnDispatcherAsync(dispatcher.OnResume);
var e1 = new NonCoalescedEvent(42, "Foo");
var e2 = new NonCoalescedEvent(42, "Foo");
using (BlockJavaScriptThread(context))
{
dispatcher.DispatchEvent(e1);
dispatcher.DispatchEvent(e2);
}
Assert.IsTrue(waitDispatched.WaitOne());
Assert.IsTrue(waitDispatched.WaitOne());
await DispatcherHelpers.CallOnDispatcherAsync(context.DisposeAsync);
await DispatcherHelpers.RunOnDispatcherAsync(ReactChoreographer.Dispose);
}
public async Task EventDispatcher_DispatchedAfterSuspend_ThenResume()
{
await DispatcherHelpers.RunOnDispatcherAsync(ReactChoreographer.Initialize);
var waitDispatched = new AutoResetEvent(false);
var executor = new MockJavaScriptExecutor
{
OnCallFunctionReturnFlushedQueue = (p0, p1, p2) =>
{
waitDispatched.Set();
return(EmptyResponse);
},
OnFlushQueue = () => EmptyResponse,
OnInvokeCallbackAndReturnFlushedQueue = (_, __) => EmptyResponse
};
var context = await CreateContextAsync(executor);
var dispatcher = new EventDispatcher(context);
await DispatcherHelpers.RunOnDispatcherAsync(dispatcher.OnResume);
var testEvent = new MockEvent(42, "Foo");
await DispatcherHelpers.RunOnDispatcherAsync(dispatcher.OnSuspend);
dispatcher.DispatchEvent(testEvent);
Assert.IsFalse(waitDispatched.WaitOne(500));
await DispatcherHelpers.RunOnDispatcherAsync(dispatcher.OnResume);
Assert.IsTrue(waitDispatched.WaitOne());
await DispatcherHelpers.CallOnDispatcherAsync(context.DisposeAsync);
await DispatcherHelpers.RunOnDispatcherAsync(ReactChoreographer.Dispose);
}
public void UpdateImage(Image image, Uri uri)
{
ImageRequest request = ImageRequestBuilder
.NewBuilderWithSource(uri)
.SetProgressiveRenderingEnabled(true)
.Build();
var dataSource = _imagePipeline.FetchDecodedImage(request, null);
var dataSubscriber = new BaseDataSubscriberImpl <CloseableReference <CloseableImage> >(
async bitmapDataSource =>
{
if (bitmapDataSource != null)
{
var reference = bitmapDataSource.GetResult();
try
{
SoftwareBitmap bitmap = ((CloseableBitmap)reference.Get()).UnderlyingBitmap;
await DispatcherHelpers.RunOnDispatcherAsync(() =>
{
var writeableBitmap = new WriteableBitmap(bitmap.PixelWidth, bitmap.PixelHeight);
bitmap.CopyToBuffer(writeableBitmap.PixelBuffer);
image.Source = writeableBitmap;
})
.ConfigureAwait(false);
}
finally
{
CloseableReference <CloseableImage> .CloseSafely(reference);
}
}
},
_ => { });
dataSource.Subscribe(dataSubscriber, CallerThreadExecutor.Instance);
}
public async Task Timing_ManyTimers()
{
await DispatcherHelpers.RunOnDispatcherAsync(ReactChoreographer.Initialize);
var count = 1000;
var ids = new List <int>(count);
var countdown = new CountdownEvent(count);
var context = CreateReactContext(new MockInvocationHandler((name, args) =>
{
Assert.AreEqual(name, nameof(JSTimers.callTimers));
var currentIds = (IList <int>)args[0];
ids.AddRange(currentIds);
for (var i = 0; i < currentIds.Count; ++i)
{
countdown.Signal();
}
}));
var timing = new Timing(context);
timing.Initialize();
await DispatcherHelpers.RunOnDispatcherAsync(context.OnResume);
var now = DateTimeOffset.Now.ToUnixTimeMilliseconds();
for (var i = 0; i < count; ++i)
{
timing.createTimer(i, i, now, false);
}
Assert.IsTrue(countdown.Wait(count * 2));
await DispatcherHelpers.CallOnDispatcherAsync(context.DisposeAsync);
await DispatcherHelpers.RunOnDispatcherAsync(ReactChoreographer.Dispose);
}
public async Task ReactInstance_GetModules()
{
var module = new TestNativeModule();
var registry = new NativeModuleRegistry.Builder()
.Add(module)
.Build();
var jsRegistry = new JavaScriptModuleRegistry.Builder()
.Add <TestJavaScriptModule>()
.Build();
var executor = new MockJavaScriptExecutor((p0, p1, p2) => JValue.CreateNull());
var builder = new ReactInstance.Builder()
{
QueueConfigurationSpec = ReactQueueConfigurationSpec.Default,
Registry = registry,
JavaScriptModuleRegistry = jsRegistry,
JavaScriptExecutorFactory = () => executor,
BundleLoader = JavaScriptBundleLoader.CreateFileLoader("ms-appx:///Resources/test.js"),
NativeModuleCallExceptionHandler = _ => { }
};
var instance = await DispatcherHelpers.CallOnDispatcherAsync(() => builder.Build());
var actualModule = instance.GetNativeModule <TestNativeModule>();
Assert.AreSame(module, actualModule);
var firstJSModule = instance.GetJavaScriptModule <TestJavaScriptModule>();
var secondJSModule = instance.GetJavaScriptModule <TestJavaScriptModule>();
Assert.AreSame(firstJSModule, secondJSModule);
await DispatcherHelpers.RunOnDispatcherAsync(instance.Dispose);
}
/// <summary>
/// Fetches the encoded BitmapImage.
/// </summary>
/// <param name="uri">The image uri.</param>
/// <param name="token">The cancellation token.</param>
/// <returns>The encoded BitmapImage.</returns>
/// <exception cref="IOException">
/// If the image uri can't be found.
/// </exception>
public Task <BitmapImage> FetchEncodedBitmapImageAsync(
Uri uri,
CancellationToken token = default(CancellationToken))
{
var taskCompletionSource = new TaskCompletionSource <BitmapImage>();
var dataSource = FetchEncodedImage(ImageRequest.FromUri(uri), null);
var dataSubscriber = new BaseDataSubscriberImpl <CloseableReference <IPooledByteBuffer> >(
async response =>
{
CloseableReference <IPooledByteBuffer> reference = response.GetResult();
if (reference != null)
{
//----------------------------------------------------------------------
// Phong Cao: InMemoryRandomAccessStream can't write anything < 16KB.
// http://stackoverflow.com/questions/25928408/inmemoryrandomaccessstream-incorrect-behavior
//----------------------------------------------------------------------
IPooledByteBuffer inputStream = reference.Get();
int supportedSize = Math.Max(16 * ByteConstants.KB, inputStream.Size);
// Allocate temp buffer for stream convert
byte[] bytesArray = default(byte[]);
CloseableReference <byte[]> bytesArrayRef = default(CloseableReference <byte[]>);
try
{
bytesArrayRef = _flexByteArrayPool.Get(supportedSize);
bytesArray = bytesArrayRef.Get();
}
catch (Exception)
{
// Allocates the byte array since the pool couldn't provide one
bytesArray = new byte[supportedSize];
}
try
{
inputStream.Read(0, bytesArray, 0, inputStream.Size);
await DispatcherHelpers.RunOnDispatcherAsync(async() =>
{
using (var outStream = new InMemoryRandomAccessStream())
using (var writeStream = outStream.AsStreamForWrite())
{
await writeStream.WriteAsync(bytesArray, 0, supportedSize);
outStream.Seek(0);
BitmapImage bitmapImage = new BitmapImage();
await bitmapImage.SetSourceAsync(outStream).AsTask().ConfigureAwait(false);
taskCompletionSource.SetResult(bitmapImage);
}
})
.ConfigureAwait(false);
}
catch (Exception e)
{
taskCompletionSource.SetException(e);
}
finally
{
CloseableReference <IPooledByteBuffer> .CloseSafely(reference);
CloseableReference <byte[]> .CloseSafely(bytesArrayRef);
}
}
else
{
taskCompletionSource.SetResult(null);
}
},
response =>
{
taskCompletionSource.SetException(response.GetFailureCause());
});
dataSource.Subscribe(dataSubscriber, _handleResultExecutor);
token.Register(() =>
{
dataSource.Close();
taskCompletionSource.TrySetCanceled();
});
return(taskCompletionSource.Task);
}
