public MediaSessionService(IJSRuntime jsRuntime)
{
_jsRuntime = jsRuntime;
_that = DotNetObjectReference.Create(this);
ServiceKey = Guid.NewGuid().ToString("N");
}
async Task Record()
{
var micModule = await moduleTask.Value;
await micModule.InvokeAsync <string>("record", audioRecorderDir, DotNetObjectReference.Create(this));
}
protected async Task Logout()
{
await JSRuntime.InvokeAsync <object>("FirebaseLogout", DotNetObjectReference.Create(this));
}
protected override async Task OnInitializedAsync()
{
EventKey = await JsRuntime.InvokeAsync <string>("fullscreenBlazorApi.subscribeToFullscreenChangedEvent", DotNetObjectReference.Create(this));
}
private async void Init(string modelURL, ElementReference video, object options = null)
{
Hash = Helper.UIDGenerator();
DotNet = DotNetObjectReference.Create(this);
await Runtime.InvokeVoidAsync("initImageClassifierVidML5", Hash, DotNet, modelURL, video, options);
}
private async Task IncrementCountJavaScript()
{
await js.InvokeVoidAsync("dotnetInstanceInvocation", DotNetObjectReference.Create(this));
}
private void AddEventListenerToFirstChildInternal <T>(object dom, string eventName, bool preventDefault, Action <T> callback)
{
if (!_domEventListeners.ContainsKey(FormatKey(dom, eventName)))
{
_jsRuntime.InvokeAsync <string>(JSInteropConstants.AddDomEventListenerToFirstChild, dom, eventName, preventDefault, DotNetObjectReference.Create(new Invoker <T>((p) =>
{
callback?.Invoke(p);
})));
}
}
private void RegisterServiceViaJsRuntime(IJSRuntime jsRuntime)
{
jsRuntime.InvokeVoidAsync("RegisterScrollInfoService", DotNetObjectReference.Create(this));
}
internal WebMidiInputProxy(string id)
{
objectProxy = DotNetObjectReference.Create(this);
this.id = id;
}
private void AddEventListenerInternal <T>(object dom, string eventName, Action <T> callback)
{
if (!_domEventListeners.ContainsKey($"{dom}-{eventName}"))
{
_jsRuntime.InvokeAsync <string>(JSInteropConstants.addDomEventListener, dom, eventName, DotNetObjectReference.Create(new Invoker <T>((p) =>
{
callback?.Invoke(p);
})));
}
}
protected ApiBaseObject(IJSInProcessObjectReference jsModule) : base(jsModule)
{
this.SelfRef = DotNetObjectReference.Create((T)this);
}
public BlazorBrowserResizeService(IJSRuntime jsRuntime)
{
this.JsRuntime = jsRuntime;
this.BrowserResizeServiceExtension = new BlazorBrowserResizeServiceExtension();
this.DotNetObjRef = DotNetObjectReference.Create(this.BrowserResizeServiceExtension);
}
public async Task RegisterAsync()
{
Id = await JSRuntime.InvokeAsync <object>("Skclusive.Material.Script.registerDetectTheme", DotNetObjectReference.Create(this));
}
protected override async Task OnAfterRenderAsync(bool firstRender)
{
if (eventHandlerIds == null)
{
eventHandlerIds = await jsRuntime.InvokeAsync <List <int> >("BlazorFabricContextualMenu.registerHandlers", this.RootElementReference, DotNetObjectReference.Create(this));
}
await base.OnAfterRenderAsync(firstRender);
}
/// <summary>
/// Creates an instance of the dev tools interop
/// </summary>
/// <param name="jsRuntime"></param>
public ReduxDevToolsInterop(IJSRuntime jsRuntime, ReduxDevToolsMiddlewareOptions options)
{
JSRuntime = jsRuntime;
DotNetRef = DotNetObjectReference.Create(this);
Options = options;
}
protected async Task IncrementCountJavacript()
{
await JS.InvokeVoidAsync("pruebaPuntoNETInstancia",
DotNetObjectReference.Create(this));
}
public InputFileJsCallbacksRelay(IInputFileJsCallbacks callbacks)
{
_callbacks = callbacks;
DotNetReference = DotNetObjectReference.Create(this);
}
protected override async Task OnAfterRenderAsync(bool firstRender)
{
if (firstRender)
{
_resizeEventToken = await jSRuntime.InvokeAsync <string>("BlazorFabricBaseComponent.registerResizeEvent", DotNetObjectReference.Create(new ResizeGroupInternal.InteropHelper(SetMeasureContainer)), "ResizeHappenedAsync");
}
if (_renderedData != null)
{
_hasRenderedContent = true;
}
double containerDimension = double.NaN;
//Debug.WriteLine($"IsMeasureContainer: {_measureContainer}");
if (_measureContainer)
{
var bounds = await this.GetBoundsAsync();
containerDimension = (this.Vertical ? bounds.height : bounds.width);
}
//Debug.WriteLine($"Container dimension: {_containerDimension}");
var state = await GetNextStateAsync(containerDimension);
if (state != null)
{
_dataToMeasure = state.DataToMeasure;
_measureContainer = state.MeasureContainer;
_renderedData = state.RenderedData;
_resizeDirection = state.ResizeDirection;
// Debug.WriteLine($"State changed: {_resizeDirection}");
StateHasChanged();
}
await base.OnAfterRenderAsync(firstRender);
}
/// <summary>
/// Creates an instance of the dev tools interop
/// </summary>
/// <param name="jsRuntime"></param>
public ReduxDevToolsInterop(IJSRuntime jsRuntime)
{
JSRuntime = jsRuntime;
DotNetRef = DotNetObjectReference.Create(this);
}
protected async Task InitJsListenerAsync()
{
await JSRuntime.InvokeVoidAsync("ScrollList.Init", "list-end", DotNetObjectReference.Create(this));
}
public void AddEventListener <T>(object dom, string eventName, Action <T> callback, bool exclusive = true, bool preventDefault = false)
{
if (exclusive)
{
_jsRuntime.InvokeAsync <string>(JSInteropConstants.AddDomEventListener, dom, eventName, preventDefault, DotNetObjectReference.Create(new Invoker <T>((p) =>
{
callback(p);
})));
}
else
{
string key = FormatKey(dom, eventName);
if (!_domEventListeners.ContainsKey(key))
{
_domEventListeners[key] = new List <DomEventSubscription>();
_jsRuntime.InvokeAsync <string>(JSInteropConstants.AddDomEventListener, dom, eventName, preventDefault, DotNetObjectReference.Create(new Invoker <string>((p) =>
{
for (var i = 0; i < _domEventListeners[key].Count; i++)
{
var subscription = _domEventListeners[key][i];
object tP = JsonSerializer.Deserialize(p, subscription.Type);
subscription.Delegate.DynamicInvoke(tP);
}
})));
}
_domEventListeners[key].Add(new DomEventSubscription(callback, typeof(T)));
}
}
protected override async Task OnAfterRenderAsync(bool firstRender)
{
baseModule = await JSRuntime !.InvokeAsync <IJSObjectReference>("import", BasePath);
if (firstRender)
{
_jsAvailable = true;
Rectangle?windowRect = await baseModule !.InvokeAsync <Rectangle>("getWindowRect");
foreach (object?item in Enum.GetValues(typeof(ResponsiveMode)))
{
if (windowRect.Width <= ResponsiveModeUtils.RESPONSIVE_MAX_CONSTRAINT[(int)item])
{
CurrentMode = (ResponsiveMode)item;
break;
}
}
_resizeEventGuid = Guid.NewGuid().ToString().Replace("-", "");
_resizeEventTokenTask = baseModule !.InvokeAsync <string>("registerResizeEvent", DotNetObjectReference.Create(this), "OnResizedAsync", _resizeEventGuid);
StateHasChanged(); // we will never have window size until after first render, so re-render after this to update the component with ResponsiveMode info.
}
await base.OnAfterRenderAsync(firstRender);
}
protected override void OnInitialized()
{
_currentInstance = DotNetObjectReference.Create(this);
}
internal StackBlazeInterop(StackBlazeGrid sender, IJSRuntime jSRuntime, StackBlazeService c)
{
this.JSRuntime = jSRuntime ?? throw new ArgumentNullException(nameof(jSRuntime));
this.Grid = sender;
this.serviceRef = DotNetObjectReference.Create(c);
}
private async void Init(string model, object opt = null)
{
Hash = Helper.UIDGenerator();
DotNet = DotNetObjectReference.Create(this);
await Runtime.InvokeVoidAsync("initImageClassifierStrML5", Hash, DotNet, model, opt);
}
private async Task On(string eventType)
{
DotNetObjectReference <Evented> eventedClass = DotNetObjectReference.Create(this);
await this.EventedJsInterop.OnCallback(eventedClass, this.JsReference, eventType);
}
public ValueTask <bool> Init(ElementReference elementRef, object componentRef)
{
return(runtime.InvokeAsync <bool>($"{BLAZORISE_NAMESPACE}.init", elementRef, DotNetObjectReference.Create(componentRef)));
}
private async Task SetRegistrationsAsync()
{
//if (ShouldListenForOuterClick())
//{
// _mouseDownId = await JSRuntime.InvokeAsync<int>("BlazorFluentUiPanel.registerMouseDownHandler", panelElement, DotNetObjectReference.Create(this));
//}
if (ShouldListenForOuterClick() && _mouseDownId == -1)
{
_mouseDownId = -2;
_mouseDownId = await JSRuntime.InvokeAsync <int>("BlazorFluentUiPanel.registerMouseDownHandler", panelElement, DotNetObjectReference.Create(this));
}
else if (!ShouldListenForOuterClick() && _mouseDownId > -1)
{
await JSRuntime.InvokeVoidAsync("BlazorFluentUiPanel.unregisterHandler", _mouseDownId);
}
if (IsOpen && _resizeId == -1)
{
_resizeId = -2;
_resizeId = await JSRuntime.InvokeAsync <int>("BlazorFluentUiPanel.registerSizeHandler", DotNetObjectReference.Create(this));
//listen for lightdismiss
}
else if (!IsOpen && _resizeId > -1)
{
await JSRuntime.InvokeVoidAsync("BlazorFluentUiPanel.unregisterHandler", _resizeId);
}
if (IsOpen && !_scrollerRegistered)
{
_scrollerRegistered = true;
_scrollerEventId = await JSRuntime.InvokeAsync <List <int> >("BlazorFluentUiPanel.makeElementScrollAllower", scrollableContent);
}
if (!IsOpen && _scrollerRegistered)
{
var copied = _scrollerEventId.ToList();
_scrollerEventId.Clear();
_scrollerRegistered = false;
foreach (var id in copied)
{
await JSRuntime.InvokeVoidAsync("BlazorFluentUiPanel.unregisterHandler", id);
}
}
}
private async Task SetOnbeforeunload()
{
await JsRuntime.InvokeAsync <object>("blazorJSPongInterop.setOnbeforeunload", DotNetObjectReference.Create(this));
}
public ValueTask <string> CallHelloHelperGetHelloMessage(string?name)
{
dotNetHelper = DotNetObjectReference.Create(new HelloHelper(name));
return(js.InvokeAsync <string>("sayHello1", dotNetHelper));
}
