// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { if (!useWASM) { app.UseResponseCompression(); if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); app.UseBlazorDebugging(); } else { app.UseExceptionHandler("/Home/Error"); } app.UseClientSideBlazorFiles <BlazorMobile.Sample.Blazor.Program>(); app.UseStaticFiles(); app.UseRouting(); app.UseEndpoints(endpoints => { endpoints.MapBlazorHub(); endpoints.MapDefaultControllerRoute(); endpoints.MapBlazorMobileRequestValidator(); endpoints.MapFallbackToPage("/server_index"); }); //Initialize Blazor app from .NET Core / Server-side BlazorMobileService.Init((bool success) => { Console.WriteLine($"Initialization success: {success}"); Console.WriteLine("Device is: " + BlazorDevice.RuntimePlatform); }); } app.UseBlazorMobileWithElectronNET <App>(useWASM); //Theses line must be registered after 'UseBlazorMobileWithElectronNET' as it internally call Xamarin.Forms.Init() if (useWASM) { BlazorWebViewService.Init(); //Register our Blazor app package WebApplicationFactory.RegisterAppStreamResolver(AppPackageHelper.ResolveAppPackageStream); } Forms.ConfigureBrowserWindow(new BrowserWindowOptions() { //Configure the BrowserWindow that will be used for the Blazor application }); //Launch the Blazor app Forms.LoadApplication(new App()); // If your code already started your BlazorWebView.LaunchBlazorApp method, you should retrieve here the Electron main BrowserWindow used to create it. // Otherwise, return a null Task value var myBrowserWindow = Forms.GetBrowserWindow(); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { app.UseResponseCompression(); if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); app.UseBlazorDebugging(); } else { app.UseExceptionHandler("/Home/Error"); } app.UseClientSideBlazorFiles <BlazorMobile.Sample.Blazor.Program>(); app.UseStaticFiles(); app.UseRouting(); app.UseEndpoints(endpoints => { endpoints.MapBlazorHub(); endpoints.MapDefaultControllerRoute(); endpoints.MapFallbackToPage("/server_index"); }); BlazorMobileService.EnableClientToDeviceRemoteDebugging("127.0.0.1", 8888); BlazorMobileService.Init((bool success) => { Console.WriteLine($"Initialization success: {success}"); Console.WriteLine("Device is: " + BlazorDevice.RuntimePlatform); }); }
private void BlazorMobileService_OnBlazorMobileLoaded(object source, BlazorMobileOnFinishEventArgs args) { //BlazorMobile is ready. We should call StateHasChanged method in order to call BuildRenderTree again. //This time, it should load your app with base.BuildRenderTree() method call. BlazorMobileService.HideElementById("placeholder"); StateHasChanged(); }
public static async Task Main(string[] args) { var builder = WebAssemblyHostBuilder.CreateDefault(args); #region Services registration ServicesHelper.ConfigureCommonServices(builder.Services); #endregion #region DEBUG //Only if you want to test WebAssembly with remote debugging from a dev machine BlazorMobileService.EnableClientToDeviceRemoteDebugging("127.0.0.1", 8888); #endregion BlazorMobileService.Init((bool success) => { Console.WriteLine($"Initialization success: {success}"); Console.WriteLine("Device is: " + BlazorDevice.RuntimePlatform); }); builder.RootComponents.Add <MobileApp>("app"); await builder.Build().RunAsync(); }
/// <summary> /// Call of this method will notify to BlazorMobile that the runtime is actually running under ElectronNET (server-side) and will also start your ElectronNET application. /// NOTE: Usage of blazor.server.js in your starting page is mandatory. /// If using BlazorMobile.Build on your Blazor base project, you should add a link reference to 'server_index.cshtml' in your server project from the base project, and register this file at app start. /// See BlazorMobile documentation for more info. /// <param name="useWASM">If 'useWASM' is set to true, the Electron app will fallback to a full WASM engine. This can be great if you need to use some BlazorMobile API that require to run in WASM mode, like side-loading other Blazor packages. However this option will disable full .NET Core / C# debug support during development time, as it will fallback to the WebAssembly debug current implementation</param> /// </summary> public static IApplicationBuilder UseBlazorMobileWithElectronNET <TFormsApplication>(this IApplicationBuilder app, bool useWASM) where TFormsApplication : BlazorApplication { if (!useWASM && !BlazorMobileService.IsInitCalled()) { throw new InvalidOperationException($"BlazorMobileService.Init() method should be called before calling {nameof(UseBlazorMobileWithElectronNET)}"); } ContextHelper.SetElectronNETUsage(true, useWASM); PlatformHelper.SetIsElectronActive(() => HybridSupport.IsElectronActive); if (!useWASM) { //Bridging Native receive method in memory on ElectronNET implementation ContextHelper.SetNativeReceive(ContextBridge.Receive); } BlazorWebViewFactory.SetInternalElectronBlazorWebView(typeof(ElectronBlazorWebView)); app.UseStaticFiles(); Forms.Init(); DependencyService.Register <IApplicationStoreService, ApplicationStoreService>(); return(app); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { app.UseResponseCompression(); if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); app.UseBlazorDebugging(); } else { app.UseExceptionHandler("/Home/Error"); } app.UseClientSideBlazorFiles <InteropBlazorApp.Startup>(); app.UseRouting(); app.UseEndpoints(endpoints => { endpoints.MapBlazorHub(); endpoints.MapFallbackToPage("/server_index"); }); BlazorMobileService.Init((bool success) => { Console.WriteLine($"Initialization success: {success}"); Console.WriteLine("Device is: " + BlazorDevice.RuntimePlatform); }); app.UseBlazorMobileWithElectronNET <App>(); }
public static async Task Main(string[] args) { var builder = WebAssemblyHostBuilder.CreateDefault(args); builder.Services.AddSingleton(new HttpClient { BaseAddress = new Uri(builder.HostEnvironment.BaseAddress) }); #region Services registration ServicesHelper.ConfigureCommonServices(builder.Services); #endregion #if DEBUG //Only if you want to test WebAssembly with remote debugging from a dev machine BlazorMobileService.EnableClientToDeviceRemoteDebugging("127.0.0.1", 8888); #endif BlazorMobileService.OnBlazorMobileLoaded += (object source, BlazorMobileOnFinishEventArgs eventArgs) => { Console.WriteLine($"Initialization success: {eventArgs.Success}"); Console.WriteLine("Device is: " + BlazorDevice.RuntimePlatform); }; builder.RootComponents.Add <MobileApp>("app"); await builder.Build().RunAsync(); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { app.UseResponseCompression(); if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } else { app.UseExceptionHandler("/Home/Error"); } app.UseBlazorFrameworkFiles(); app.UseStaticFiles(); app.UseRouting(); app.UseEndpoints(endpoints => { endpoints.MapBlazorHub(); endpoints.MapFallbackToPage("/server_index"); }); BlazorMobileService.EnableClientToDeviceRemoteDebugging("127.0.0.1", 8891); BlazorMobileService.OnBlazorMobileLoaded += (object source, BlazorMobileOnFinishEventArgs eventArgs) => { Console.WriteLine($"Initialization success: {eventArgs.Success}"); Console.WriteLine("Device is: " + BlazorDevice.RuntimePlatform); }; }
public void CallJSInvokableMethod(string assembly, string method, params object[] args) { if (ContextHelper.IsUsingWASM()) { WebViewHelper.CallJSInvokableMethod(assembly, method, args); } else { BlazorMobileService.SendMessageToJSInvokableMethod(assembly, method, args); } }
private void BlazorMobileService_OnBlazorMobileLoaded(object source, BlazorMobileOnFinishEventArgs args) { //InvokeAsync is mainly needed for .NET Core implementation that need the renderer context InvokeAsync(() => { //BlazorMobile is ready. We should call StateHasChanged method in order to call BuildRenderTree again. //This time, it should load your app with base.BuildRenderTree() method call. BlazorMobileService.HideElementById("placeholder"); StateHasChanged(); }); }
public void PostMessage <TArgs>(string messageName, TArgs args) { if (ContextHelper.IsUsingWASM()) { WebViewHelper.PostMessage(messageName, typeof(TArgs), new object[] { args }); } else { BlazorMobileService.SendMessageToSubscribers(messageName, typeof(TArgs), new object[] { args }); } }
public void Configure(IComponentsApplicationBuilder app) { #region DEBUG //Only if you want to test WebAssembly with remote debugging from a dev machine BlazorMobileService.EnableClientToDeviceRemoteDebugging("127.0.0.1", 8888); #endregion BlazorMobileService.Init((bool success) => { Console.WriteLine($"Initialization success: {success}"); Console.WriteLine("Device is: " + BlazorDevice.RuntimePlatform); }); app.AddComponent <MobileApp>("app"); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { app.UseResponseCompression(); if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); app.UseBlazorDebugging(); } else { app.UseExceptionHandler("/Home/Error"); } app.UseClientSideBlazorFiles <InteropBlazorApp.Program>(); app.UseStaticFiles(); app.UseRouting(); app.UseEndpoints(endpoints => { endpoints.MapBlazorHub(); endpoints.MapBlazorMobileRequestValidator(); endpoints.MapFallbackToPage("/server_index"); }); BlazorMobileService.Init((bool success) => { Console.WriteLine($"Initialization success: {success}"); Console.WriteLine("Device is: " + BlazorDevice.RuntimePlatform); }); app.UseBlazorMobileWithElectronNET <App>(); Forms.ConfigureBrowserWindow(new BrowserWindowOptions() { //Configure the BrowserWindow that will be used for the Blazor application }); //Launch the Blazor app Forms.LoadApplication(new App()); // If your code already started your BlazorWebView.LaunchBlazorApp method, you should retrieve here the Electron main BrowserWindow used to create it. // Otherwise, return a null Task value var myBrowserWindow = Forms.GetBrowserWindow(); }
/// <summary> /// Call of this method will notify to BlazorMobile that the runtime is actually running under ElectronNET (server-side) and will also start your ElectronNET application. /// NOTE: Usage of blazor.server.js in your starting page is mandatory. /// If using BlazorMobile.Build on your Blazor base project, you should add a link reference to 'server_index.cshtml' in your server project from the base project, and register this file at app start. /// See BlazorMobile documentation for more info. /// </summary> public static IApplicationBuilder UseBlazorMobileWithElectronNET <TFormsApplication>(this IApplicationBuilder app) where TFormsApplication : BlazorApplication { if (!BlazorMobileService.IsInitCalled()) { throw new InvalidOperationException($"BlazorMobileService.Init() method should be called before calling {nameof(UseBlazorMobileWithElectronNET)}"); } ContextHelper.SetElectronNETUsage(true); //Bridging Native receive method in memory on ElectronNET implementation ContextHelper.SetNativeReceive(ContextBridge.Receive); BlazorWebViewFactory.SetInternalElectronBlazorWebView(typeof(ElectronBlazorWebView)); app.UseStaticFiles(); Forms.Init(); return(app); }
private async Task SetRemoteDebugEndpoint() { string uri = BlazorMobileService.GetContextBridgeURI(); await Runtime.InvokeVoidAsync("BlazorXamarin.SetDebugRemoteEndpoint", uri); }
internal void OnFinishEvent() { BlazorMobileService.SendOnBlazorMobileLoaded(this, BlazorMobileSuccess); }
protected override void BuildRenderTree(RenderTreeBuilder builder) { //This component must be rendered once! //Even if the javascript script is not re-renderer if the component is called twice, it should be already available in the DOM if (_isInitialized) { return; } builder.OpenElement(0, "script"); builder.AddAttribute(1, "type", "text/javascript"); builder.AddMarkupContent(1, ContextBridgeHelper.GetBlazorXamarinJavascript() + ContextBridgeHelper.GetContextBridgeJavascript().Replace("%_contextBridgeURI%", BlazorMobileService.GetContextBridgeURI())); builder.CloseElement(); _isInitialized = true; }
protected override void BuildRenderTree(RenderTreeBuilder builder) { //This component must be rendered once! //If the component is disposed and then re-rendered, then something is wrong with the current project configuration if (_isInitialized) { return; } builder.OpenElement(0, "script"); builder.AddAttribute(1, "type", "text/javascript"); builder.AddContent(1, ContextBridgeHelper.GetBlazorXamarinJavascript() + ContextBridgeHelper.GetContextBridgeJavascript().Replace("%_contextBridgeURI%", BlazorMobileService.GetContextBridgeURI())); builder.CloseElement(); _isInitialized = true; }
protected override void BuildRenderTree(RenderTreeBuilder builder) { //This component must be rendered once! //If the component is disposed and then re-rendered, then something is wrong with the current project configuration if (_isInitialized) { return; } if (ContextHelper.IsBlazorMobile()) { builder.OpenElement(0, "script"); builder.AddContent(1, @" window.BlazorXamarinRuntimeCheck = function () { if (window.contextBridge == null || window.contextBridge == undefined) { return false; } return true; }; "); builder.CloseElement(); //Add server side remote to client remote debugging builder.OpenElement(0, "script"); builder.AddContent(1, ContextBridgeHelper.GetInjectableJavascript(false).Replace("%_contextBridgeURI%", BlazorMobileService.GetContextBridgeURI())); builder.CloseElement(); } else if (ContextHelper.IsElectronNET()) { //Add electronNET helpers builder.OpenElement(0, "script"); builder.AddContent(1, ContextBridgeHelper.GetElectronNETJavascript()); builder.CloseElement(); } _isInitialized = true; }