protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
if (Build.VERSION.SdkInt >= BuildVersionCodes.M)
{
if (!Settings.CanDrawOverlays(this))
{
Intent intent = new Intent(Settings.ActionManageOverlayPermission, Uri.Parse("package:" + PackageName));
StartActivityForResult(intent, OVERLAY_PERMISSION_REQ_CODE);
}
}
mReactRootView = new ReactRootView(this);
mReactInstanceManager = ReactInstanceManager.Builder()
.SetApplication(Application)
.SetBundleAssetName("index.android.bundle")
.SetJSMainModulePath("index")
.AddPackage(new MainReactPackage())
.AddPackage(new ApiPackage())
.AddPackage(new SvgPackage())
#if DEBUG
.SetUseDeveloperSupport(true)
#else
.SetUseDeveloperSupport(false)
#endif
.SetInitialLifecycleState(LifecycleState.Resumed)
.Build();
mReactRootView.StartReactApplication(mReactInstanceManager, "MyReactNativeApp", null);
SetContentView(mReactRootView);
}
public async Task ReactInstanceManager_DisposeAsync_WhileBusy()
{
var jsBundleFile = "ms-appx:///Resources/test.js";
ReactInstanceManager manager = null;
await DispatcherHelpers.CallOnDispatcherAsync(() => manager = CreateReactInstanceManager(jsBundleFile));
var reactContext = await DispatcherHelpers.CallOnDispatcherAsync(
() => manager.CreateReactContextAsync(CancellationToken.None));
var e = new AutoResetEvent(false);
reactContext.RunOnNativeModulesQueueThread(() =>
{
e.WaitOne();
var x = DispatcherHelpers.CallOnDispatcherAsync(() =>
{
return(42);
}).Result;
});
var task = DispatcherHelpers.CallOnDispatcherAsync(async() =>
{
e.Set();
await DisposeInstanceManager(manager);
;
});
var completedTask = await Task.WhenAny(
Task.Delay(5000),
task);
Assert.IsTrue(task.IsCompleted);
}
private static async Task CloseView(ReactInstanceManager manager, CoreDispatcher dispatcher)
{
await DispatcherHelpers.CallOnDispatcherAsync(dispatcher, async() =>
{
var window = Window.Current;
if (window != null)
{
var frame = window.Content as Frame;
if (frame != null)
{
var page = frame.Content as Page;
if (page != null)
{
var rootView = page.Content as ReactRootView;
if (rootView != null)
{
await rootView.StopReactApplicationAsync();
Window.Current.Close();
page.Content = null;
}
}
}
}
});
}
private void CreateReactView()
{
if (RendererManager.Debug && !Settings.CanDrawOverlays(RendererManager.Activity))
{
// Debug mode without overlay permissions not supported.
System.Console.WriteLine("[ReactNative.Forms] Debug mode without overlay permissions not supported.");
return;
}
_rootView = new ReactRootView(Context);
_instanceManager = ReactInstanceManager.Builder()
.SetApplication(RendererManager.Activity.Application)
.SetBundleAssetName(Element.BundleName)
.SetJSMainModulePath(Element.ModulePath)
.AddPackage(new MainReactPackage())
.SetUseDeveloperSupport(RendererManager.Debug)
.SetInitialLifecycleState(LifecycleState.Resumed)
.Build();
_instanceManager.AddReactInstanceEventListener(this);
// convert dictionary to bundle
var props = new Bundle();
foreach (KeyValuePair <string, object> entry in Element.Properties)
{
props.PutString(entry.Key, (string)entry.Value);
}
_rootView.StartReactApplication(_instanceManager, Element.ModuleName, props);
}
public async Task ReactInstanceManager_Lifecycle_Missing_Background()
{
var jsBundleFile = "ms-appx:///Resources/test.js";
ReactInstanceManager manager = null;
await DispatcherHelpers.CallOnDispatcherAsync(() => manager = CreateReactInstanceManager(jsBundleFile, LifecycleState.Foreground));
var listener = new LifecycleEventsListener(new LifecycleEventsListener.Step[]
{
LifecycleEventsListener.Step.EnteredBackground,
LifecycleEventsListener.Step.Suspend,
});
await DispatcherHelpers.CallOnDispatcherAsync(async() =>
{
var context = await manager.CreateReactContextAsync(CancellationToken.None);
context.AddBackgroundEventListener(listener);
context.AddLifecycleEventListener(listener);
manager.OnSuspend();
context.RemoveLifecycleEventListener(listener);
context.RemoveBackgroundEventListener(listener);
});
listener.Dispose();
await DispatcherHelpers.CallOnDispatcherAsync(async() => await DisposeInstanceManager(manager));
}
private static async Task DisposeInstanceManager(ReactInstanceManager manager)
{
await manager.DisposeAsync();
// Go back to the initial state as set by the host test app
ReactNative.Bridge.DispatcherHelpers.Initialize();
}
public async Task ReactRootView_SecondaryWindowStress()
{
var jsBundleFile = "ms-appx:///Resources/mwtest.js";
ReactInstanceManager manager = null;
await DispatcherHelpers.CallOnDispatcherAsync(() => manager = CreateReactInstanceManager(jsBundleFile));
var reactContext = await DispatcherHelpers.CallOnDispatcherAsync(
() => manager.CreateReactContextAsync(CancellationToken.None));
int currentDelay = 2000;
for (int i = 0; i < 30; i++)
{
currentDelay /= 2;
// Create a window
var dispatcher = await CreateView(() =>
{
var rv = new ReactRootView();
rv.StartReactApplication(
manager,
"alt_window",
null);
return(rv);
});
await Task.Delay(currentDelay);
await CloseView(manager, dispatcher);
}
await DispatcherHelpers.CallOnDispatcherAsync(async() => await DisposeInstanceManager(manager));
}
public async Task ReactInstanceManager_CreateReactContextAsync_EnsuresOneCall()
{
var jsBundleFile = "ms-appx:///Resources/test.js";
ReactInstanceManager manager = null;
await DispatcherHelpers.CallOnDispatcherAsync(() => manager = CreateReactInstanceManager(jsBundleFile));
var caught = false;
await DispatcherHelpers.CallOnDispatcherAsync(async() =>
{
var task = manager.CreateReactContextAsync(CancellationToken.None);
try
{
await manager.CreateReactContextAsync(CancellationToken.None);
}
catch (InvalidOperationException)
{
caught = true;
}
});
Assert.IsTrue(caught);
await DispatcherHelpers.CallOnDispatcherAsync(async() => await DisposeInstanceManager(manager));
}
public async Task ReactInstanceManager_GetOrCreateReactContextAsync_Create()
{
var jsBundleFile = "ms-appx:///Resources/test.js";
ReactInstanceManager manager = null;
await DispatcherHelpers.CallOnDispatcherAsync(() => manager = CreateReactInstanceManager(jsBundleFile));
var reactContext = await DispatcherHelpers.CallOnDispatcherAsync(() => manager.GetOrCreateReactContextAsync(CancellationToken.None));
Assert.IsNotNull(reactContext);
await DispatcherHelpers.CallOnDispatcherAsync(async() => await DisposeInstanceManager(manager));
}
public async Task ReactInstanceManager_TryGetReactContextAsync_Finished()
{
var jsBundleFile = "ms-appx:///Resources/test.js";
ReactInstanceManager manager = null;
await DispatcherHelpers.CallOnDispatcherAsync(() => manager = CreateReactInstanceManager(jsBundleFile));
var initialContext = await DispatcherHelpers.CallOnDispatcherAsync(async() =>
await manager.CreateReactContextAsync(CancellationToken.None));
var context = await DispatcherHelpers.CallOnDispatcherAsync(async() =>
await manager.TryGetReactContextAsync(CancellationToken.None));
Assert.AreSame(initialContext, context);
await DispatcherHelpers.CallOnDispatcherAsync(async() => await DisposeInstanceManager(manager));
}
public async Task ReactInstanceManager_CreateReactContextAsync_Canceled()
{
var jsBundleFile = "ms-appx:///Resources/test.js";
ReactInstanceManager manager = null;
await DispatcherHelpers.CallOnDispatcherAsync(() => manager = CreateReactInstanceManager(jsBundleFile));
var cancellationTokenSource = new CancellationTokenSource();
cancellationTokenSource.Cancel();
await AssertEx.ThrowsAsync <OperationCanceledException>(
async() => await DispatcherHelpers.CallOnDispatcherAsync(() =>
manager.CreateReactContextAsync(cancellationTokenSource.Token)),
ex => Assert.AreEqual(cancellationTokenSource.Token, ex.CancellationToken));
await DispatcherHelpers.CallOnDispatcherAsync(async() => await DisposeInstanceManager(manager));
}
public async Task ReactInstanceManager_OnBackPressed_NoContext()
{
var waitHandle = new AutoResetEvent(false);
ReactInstanceManager manager = null;
await DispatcherHelpers.CallOnDispatcherAsync(() => manager = CreateReactInstanceManager());
await DispatcherHelpers.RunOnDispatcherAsync(() =>
{
manager.OnResume(() => waitHandle.Set());
manager.OnBackPressed();
});
Assert.IsTrue(waitHandle.WaitOne());
await DispatcherHelpers.CallOnDispatcherAsync(async() => await DisposeInstanceManager(manager));
}
private void startReactNative()
{
mReactRootView = new ReactRootView(this);
mReactInstanceManager = ReactInstanceManager.Builder()
.SetApplication(Application)
.SetBundleAssetName("index.android.bundle")
.SetJSMainModulePath("index")
.AddPackage(new MainReactPackage())
#if DEBUG
.SetUseDeveloperSupport(true)
#else
.SetUseDeveloperSupport(false)
#endif
.SetInitialLifecycleState(LifecycleState.Resumed)
.Build();
mReactRootView.StartReactApplication(mReactInstanceManager, "MyReactNativeApp", null);
SetContentView(mReactRootView);
}
public async Task ReactInstanceManager_RecreateReactContextAsync()
{
var jsBundleFile = "ms-appx:///Resources/test.js";
ReactInstanceManager manager = null;
await DispatcherHelpers.CallOnDispatcherAsync(() => manager = CreateReactInstanceManager(jsBundleFile));
var task = default(Task <ReactContext>);
var reactContext = await DispatcherHelpers.CallOnDispatcherAsync(async() =>
{
task = manager.CreateReactContextAsync(CancellationToken.None);
return(await manager.RecreateReactContextAsync(CancellationToken.None));
});
var initialReactContext = await task;
Assert.IsNotNull(reactContext);
Assert.AreEqual(jsBundleFile, manager.SourceUrl);
Assert.AreNotEqual(initialReactContext, reactContext);
await DispatcherHelpers.CallOnDispatcherAsync(async() => await DisposeInstanceManager(manager));
}
public async Task ReactInstanceManager_ArgumentChecks()
{
ReactInstanceManager manager = null;
await DispatcherHelpers.CallOnDispatcherAsync(() => manager = CreateReactInstanceManager());
await AssertEx.ThrowsAsync <ArgumentNullException>(
async() => await DispatcherHelpers.CallOnDispatcherAsync(() =>
manager.AttachMeasuredRootViewAsync(null)),
ex => Assert.AreEqual("rootView", ex.ParamName));
await AssertEx.ThrowsAsync <ArgumentNullException>(
async() => await DispatcherHelpers.CallOnDispatcherAsync(() =>
manager.CreateAllViewManagers(null)),
ex => Assert.AreEqual("reactContext", ex.ParamName));
await AssertEx.ThrowsAsync <ArgumentNullException>(
async() => await DispatcherHelpers.CallOnDispatcherAsync(() =>
manager.DetachRootViewAsync(null)),
ex => Assert.AreEqual("rootView", ex.ParamName));
await DispatcherHelpers.CallOnDispatcherAsync(async() => await DisposeInstanceManager(manager));
}
protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
{
base.OnElementPropertyChanged(sender, e);
switch (e.PropertyName)
{
case nameof(ReactView.PackagerUrl):
case nameof(ReactView.BundleName):
case nameof(ReactView.ModulePath):
case nameof(ReactView.ModuleName):
case nameof(ReactView.Properties):
// Kill everything.
_instanceManager.DetachRootView(_rootView);
_instanceManager.Destroy();
_instanceManager = null;
_rootView = null;
// Recreate view.
CreateReactView();
break;
}
}
public async Task <ReactContext> GetCurrentReactContext()
{
return(await ReactInstanceManager.GetOrCreateReactContextAsync(CancellationToken.None));
}
