/// <summary> /// A package has been updated. Reload its extensions. /// </summary> /// <param name="sender">The catalog that the extensions belong to</param> /// <param name="args">Contains the package that was updated</param> private async void Catalog_PackageUpdated(AppExtensionCatalog sender, AppExtensionPackageUpdatedEventArgs args) { foreach (AppExtension ext in args.Extensions) { await LoadExtension(ext); } }
// package status has changed, could be invalid, licensing issue, app was on USB and removed, etc private async void Catalog_PackageStatusChanged(AppExtensionCatalog sender, AppExtensionPackageStatusChangedEventArgs args) { // get package status if (!(args.Package.Status.VerifyIsOK())) { // if it's offline unload only if (args.Package.Status.PackageOffline) { await UnloadExtensions(args.Package); } // package is being serviced or deployed else if (args.Package.Status.Servicing || args.Package.Status.DeploymentInProgress) { // ignore these package status events } // package is tampered or invalid or some other issue // glyphing the extensions would be a good user experience else { await RemoveExtensions(args.Package); } } // if package is now OK, attempt to load the extensions else { // try to load any extensions associated with this package await LoadExtensions(args.Package); } }
/// <summary> /// The status of a package has changed (it could be a licensing issue, the package was on USB and has been removed removed, etc) /// Unload extensions if a package went offline or is otherwise no longer available /// </summary> /// <param name="sender">The catalog that the extensions belong to</param> /// <param name="args">Contains the package that has changed status</param> private async void Catalog_PackageStatusChanged(AppExtensionCatalog sender, AppExtensionPackageStatusChangedEventArgs args) { if (!args.Package.Status.VerifyIsOK()) // If the package isn't ok, unload its extensions { // if it's offline, unload its extensions if (args.Package.Status.PackageOffline) { await UnloadExtensions(args.Package); } else if (args.Package.Status.Servicing || args.Package.Status.DeploymentInProgress) { // if the package is being serviced or deployed, ignore the status events } else { // Deal with an invalid or tampered with package, or other issue, by removing the extensions // Adding a UI glyph to the affected extensions could be a good user experience if you wish await RemoveExtensions(args.Package); } } else // The package is now OK--attempt to load its extensions { await LoadExtensions(args.Package); } }
private AppExtensionCatalog catalog; // the catalog of app extensions available to this host /// <summary> /// Builds a collection of extensions available to this host /// </summary> /// <param name="extensionContractName"> /// The contract string is defined in the extension host's Package.appxmanifest file under <uap3:AppExtensionHost><uap3:Name>MathExt</uap3:Name></uap3:AppExtensionHost> /// The string is defined in the extension's Package.appxmanifest file under <uap3:Extension Category="windows.appExtension"><uap3:AppExtension Name = "MathExt" ... > /// When these two strings match, the extension is loaded.</param> public ExtensionManager(string extensionContractName) { // catalog & contract ExtensionContractName = extensionContractName; catalog = AppExtensionCatalog.Open(ExtensionContractName); //_dispatcher = null; }
public ExtensionService(string extensionContractName) { // catalog & contract ExtensionContractName = extensionContractName; _catalog = AppExtensionCatalog.Open(ExtensionContractName); _catalog.PackageInstalled += _catalog_PackageInstalled; _catalog.PackageUninstalling += _catalog_PackageUninstalling; }
public static async Task <Extension> Load <T>(string lyricExtensionID) where T : Extension { if (lyricExtensionID.IsNullorEmpty()) { lyricExtensionID = Consts.AppUserModelId + "$|$BuiltIn"; } var catalog = AppExtensionCatalog.Open(Consts.ExtensionContract); var extesions = await catalog.FindAllAsync(); bool b = false; find : foreach (var ext in extesions) { if (lyricExtensionID == ext.AppInfo.AppUserModelId + Consts.ArraySeparator + ext.Id) { try { var properties = await ext.GetExtensionPropertiesAsync(); var categoryProperty = properties["Category"] as PropertySet; // parse Category var categories = (categoryProperty["#text"] as string).Split(';'); if (typeof(T) == typeof(LyricExtension) && categories.Contains("Lyric")) { return(new LyricExtension(ext, properties)); } if (typeof(T) == typeof(OnlineMetaExtension) && categories.Contains("OnlineMeta")) { return(new OnlineMetaExtension(ext, properties)); } if (typeof(T) == typeof(OnlineMusicExtension) && categories.Contains("OnlineMusic")) { return(new OnlineMusicExtension(ext, properties)); } // we have the exact extension, but it don't provide this kind of extension, return null return(null); } catch (Exception) { // if extension didn't write the correct manifest, may throw exception continue; } } } if (!b) { b = true; lyricExtensionID = Consts.AppUserModelId + "$|$BuiltIn"; goto find; } else { throw new InvalidOperationException("Can't find specific Extension"); } }
public ExtensionManager(string contract) { // extensions list _extensions = new ObservableCollection <Extension>(); // catalog & contract _contract = contract; _catalog = AppExtensionCatalog.Open(_contract); }
private async void Catalog_PackageInstalled(AppExtensionCatalog sender, AppExtensionPackageInstalledEventArgs args) { await _dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() => { foreach (AppExtension ext in args.Extensions) { await LoadExtension(ext); } }); }
private async void _catalog_PackageInstalled(AppExtensionCatalog sender, AppExtensionPackageInstalledEventArgs args) { await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () => { ExtensionList.Clear(); }); await FindAllExtensions(); }
public void Open(string contractName) { _catalog = AppExtensionCatalog.Open(contractName); _catalog.PackageInstalled += (s, e) => PackageInstalled?.Invoke(this, new AppExtensionPackageInstalledEventArgsWrapper(e)); _catalog.PackageUpdated += (s, e) => PackageUpdated?.Invoke(this, new AppExtensionPackageUpdatedEventArgsWrapper(e)); _catalog.PackageUninstalling += (s, e) => PackageUninstalling?.Invoke(this, new AppExtensionPackageUninstallingEventArgsWrapper(e)); _catalog.PackageUpdating += (s, e) => PackageUpdating?.Invoke(this, new AppExtensionPackageUpdatingEventArgsWrapper(e)); _catalog.PackageStatusChanged += (s, e) => PackageStatusChanged?.Invoke(this, new AppExtensionPackageStatusChangedEventArgsWrapper(e)); }
// package has been updated, so reload the extensions private async void Catalog_PackageUpdated(AppExtensionCatalog sender, AppExtensionPackageUpdatedEventArgs args) { await this.workerThread.Factory.StartNew(async() => { foreach (var ext in args.Extensions) { await LoadExtensionAsync(ext); } }).Unwrap(); }
private DataSourceManager() { this.catalog = AppExtensionCatalog.Open("StartReader.DataProviderSource"); this.catalog.PackageStatusChanged += this.refresh; this.catalog.PackageInstalled += this.refresh; this.catalog.PackageUpdated += this.refresh; this.catalog.PackageUninstalling += this.Catalog_PackageUninstalling; var ignore = RefreshAsync(); this.timer = new Timer(timerCallback, null, 60_000, 60_000); }
public AppExtensionsViewModel() { _catalog = AppExtensionCatalog.Open("licorne"); _catalog.PackageInstalled += Catalog_OnPackageInstalled; _catalog.PackageUninstalling += Catalog_OnPackageUninstalling; _catalog.PackageUpdated += _catalog_OnPackageUpdated; _catalog.PackageStatusChanged += _catalog_OnPackageStatusChanged; InitAsync(); }
/// <summary> /// A package has been updated. Reload its extensions. /// </summary> /// <param name="sender">The catalog that the extensions belong to</param> /// <param name="args">Contains the package that was updated</param> private async void Catalog_PackageUpdated(AppExtensionCatalog sender, AppExtensionPackageUpdatedEventArgs args) { // Run on the UI thread because the Extensions Tab UI updates as extensions are added or removed await _dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() => { foreach (AppExtension ext in args.Extensions) { await LoadExtension(ext); } }); }
private void Catalog_PackageUninstalling(AppExtensionCatalog sender, AppExtensionPackageUninstallingEventArgs args) { var pfn = args.Package.Id.FamilyName; var ext = this.sources.Where(ds => ds.PackageFamilyName == pfn).ToList(); foreach (var item in ext) { item.Close(); this.sources.Remove(item); } }
public ExtensionManager(string contract) { // extensions list _extensions = new ObservableCollection <Extension>(); // catalog & contract _contract = contract; _catalog = AppExtensionCatalog.Open(_contract); // using a method that uses the UI Dispatcher before initializing will throw an exception _dispatcher = null; }
public async Task Init() { _catalog = AppExtensionCatalog.Open(Consts.ExtensionContract); // set up extension management events _catalog.PackageInstalled += _catalog_PackageInstalled; _catalog.PackageUpdated += _catalog_PackageUpdated; _catalog.PackageUninstalling += _catalog_PackageUninstalling; _catalog.PackageUpdating += _catalog_PackageUpdating; _catalog.PackageStatusChanged += _catalog_PackageStatusChanged; // Scan all extensions await FindAllExtensions(); }
public async Task <Dictionary <string, object> > InvokeExtension(string extensionId, Dictionary <string, object> parameters) { Employee employee = new Employee(); //"com.extensions.yamoney.teststand" AppExtensionCatalog catalog = AppExtensionCatalog.Open(extensionId); var extensions = new System.Collections.Generic.List <AppExtension>(await catalog.FindAllAsync()); var employeeService = extensions[0]; var packageFamilyName = employeeService.Package.Id.FamilyName; IPropertySet properties = await employeeService.GetExtensionPropertiesAsync(); PropertySet serviceProperty = (PropertySet)properties["Service"]; var serviceName = serviceProperty["#text"].ToString(); AppServiceConnection connection = new AppServiceConnection { AppServiceName = serviceName, PackageFamilyName = packageFamilyName }; // Параметры подключения var message = new ValueSet(); // Параметры для передачи foreach (var kv in parameters) { message.Add(kv); } var status = await connection.OpenAsync(); // Открываем подключение using (connection) { if (status != AppServiceConnectionStatus.Success) // Проверяем статус { return(null); } var response = await connection.SendMessageAsync(message); // Отправляем сообщение и ждем ответа if (response.Status == AppServiceResponseStatus.Success) { return(response.Message.ToDictionary(kv => kv.Key, kv => kv.Value)); } else { return(null); } } }
public MainPage() { this.InitializeComponent(); _catalog = AppExtensionCatalog.Open("Atmosphere"); _catalog.PackageInstalled += _catalog_PackageInstalled; InstallPackageContent(); NavigationCacheMode = Windows.UI.Xaml.Navigation.NavigationCacheMode.Required; AppCallbacks appCallbacks = AppCallbacks.Instance; // Setup scripting bridge _bridge = new WinRTBridge.WinRTBridge(); appCallbacks.SetBridge(_bridge); appCallbacks.RenderingStarted += () => { RemoveSplashScreen(); }; this.Loaded += MainPage_Loaded; this.KeyDown += MainPage_KeyDown; _timer = new DispatcherTimer(); _timer.Interval = TimeSpan.FromSeconds(2); _timer.Tick += _timer_Tick; _timer.Start(); #if !UNITY_WP_8_1 appCallbacks.SetKeyboardTriggerControl(this); #endif appCallbacks.SetSwapChainPanel(GetSwapChainPanel()); appCallbacks.SetCoreWindowEvents(Window.Current.CoreWindow); appCallbacks.InitializeD3DXAML(); splash = ((App)App.Current).splashScreen; GetSplashBackgroundColor(); OnResize(); onResizeHandler = new WindowSizeChangedEventHandler((o, e) => OnResize()); Window.Current.SizeChanged += onResizeHandler; #if UNITY_WP_8_1 onRotationChangedHandler = new TypedEventHandler <DisplayInformation, object>((di, o) => { OnRotate(di); }); ExtendedSplashImage.RenderTransformOrigin = new Point(0.5, 0.5); var displayInfo = DisplayInformation.GetForCurrentView(); displayInfo.OrientationChanged += onRotationChangedHandler; OnRotate(displayInfo); SetupLocationService(); #endif }
public async Task InitAsync() { this.catalog = AppExtensionCatalog.Open(this.pluginName); // set up extension management events this.catalog.PackageInstalled += this.Catalog_PackageInstalled; this.catalog.PackageUpdated += this.Catalog_PackageUpdated; this.catalog.PackageUninstalling += this.Catalog_PackageUninstalling; this.catalog.PackageUpdating += this.Catalog_PackageUpdating; this.catalog.PackageStatusChanged += this.Catalog_PackageStatusChanged; // Scan all extensions await FindAllExtensionsAsync(); }
public void InitializeCatalog() { _catalog = AppExtensionCatalog.Open(_contract); AppSettings.Clear(); if (_dispatcher != null) { throw new Exception("Extension Manager for " + this._contract + " is already initialized."); } // thread that initializes the extension manager has the dispatcher _dispatcher = Windows.UI.Core.CoreWindow.GetForCurrentThread().Dispatcher; // set up extension management events _catalog.PackageInstalled += Catalog_PackageInstalled; _catalog.PackageUninstalling += Catalog_PackageUninstalling; _catalog.PackageUpdating += Catalog_PackageUpdating; _catalog.PackageUpdated += Catalog_PackageUpdated; _catalog.PackageStatusChanged += Catalog_PackageStatusChanged; }
// package status has changed, could be invalid, licensing issue, app was on USB and removed, etc private async void Catalog_PackageStatusChanged(AppExtensionCatalog sender, AppExtensionPackageStatusChangedEventArgs args) { // get package status if (!(args.Package.Status.VerifyIsOK())) { // if it's offline unload only if (args.Package.Status.PackageOffline) await UnloadUWPExtensions(args.Package); // package is being serviced or deployed else if (args.Package.Status.Servicing || args.Package.Status.DeploymentInProgress) { // ignore these package status events } // package is tampered or invalid or some other issue, remove the extensions else { await RemoveUWPExtensions(args.Package); } } // if package is now OK, attempt to load the extensions else { // try to load any extensions associated with this package await LoadUWPExtensions(args.Package); } }
// package has been updated, so reload the extensions private async void Catalog_PackageUpdated(AppExtensionCatalog sender, AppExtensionPackageUpdatedEventArgs args) { }
public ExtensionsProvider(string contract, IServiceFactory factory, IFilePicker picker) { var catalog = AppExtensionCatalog.Open(contract); var source = new SourceCache <AppExtension, string>(a => a.Id); Connect = ReactiveCommand.CreateFromTask(async() => { var initial = await catalog.FindAllAsync(); source.Edit(x => { x.Clear(); var findAllAsync = initial; x.AddOrUpdate(findAllAsync); refreshers.Dispose(); DisposableMixins.DisposeWith(Observable .FromEventPattern <AppExtensionPackageInstalledEventArgs>(catalog, "PackageInstalled") .Subscribe(args => x.AddOrUpdate(args.EventArgs.Extensions)), refreshers); DisposableMixins.DisposeWith(Observable .FromEventPattern <AppExtensionPackageUninstallingEventArgs>(catalog, "PackageUninstalling") .Subscribe(args => { }), refreshers); }); return(Unit.Default); }); Func <Task <byte[]> > GetLogo(AppExtension appExtension) { return(async() => { try { var open = await appExtension.AppInfo.DisplayInfo.GetLogo(new Size(1, 1)).OpenReadAsync(); var stream = open.AsStreamForRead(); return await StreamMixin.ReadBytes(stream); } catch (Exception e) { return null; } }); } Func <Task <IDictionaryBasedService> > GetService(AppExtension appExtension) { return(async() => { var connInfo = await appExtension.GetConnectionInfo(); return factory.Create(connInfo.Item1, connInfo.Item2); }); } ObservableChangeset = source .Connect() .Transform(ext => new ImportViewModel(ext.DisplayName, ext.Description, GetLogo(ext), GetService(ext), picker)); DisposableMixins.DisposeWith(ObservableChangeset .Bind(out extensions) .Subscribe(), disposables); DisposableMixins.DisposeWith(Connect.Execute() .Subscribe(), disposables); }
private async void Catalog_PackageUpdated(AppExtensionCatalog sender, AppExtensionPackageUpdatedEventArgs args) { await _dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async () => { foreach (AppExtension ext in args.Extensions) await LoadUWPExtension(ext); }); }
private void Catalog_OnPackageInstalled(AppExtensionCatalog sender, AppExtensionPackageInstalledEventArgs args) { RefreshOnDispatcherThread(); }
// package is updating, so just unload the extensions private async void Catalog_PackageUpdating(AppExtensionCatalog sender, AppExtensionPackageUpdatingEventArgs args) { await UnloadUWPExtensions(args.Package); }
/// <summary> /// A package is being updated. Unload all the extensions in the package. /// </summary> /// <param name="sender">The catalog that the extensions belong to</param> /// <param name="args">Contains the package that is updating</param> private async void Catalog_PackageUpdating(AppExtensionCatalog sender, AppExtensionPackageUpdatingEventArgs args) { await UnloadExtensions(args.Package); }
private void _catalog_PackageInstalled(AppExtensionCatalog sender, AppExtensionPackageInstalledEventArgs args) { InstallPackageContent(); PlaySoundFile(); }
// package is removed, so unload all the extensions in the package and remove it private async void Catalog_PackageUninstalling(AppExtensionCatalog sender, AppExtensionPackageUninstallingEventArgs args) { await RemoveUWPExtensions(args.Package); }
private void _catalog_PackageUninstalling(AppExtensionCatalog sender, AppExtensionPackageUninstallingEventArgs args) { }
/// <summary> /// A package has been removed. Remove all the extensions in the package. /// </summary> /// <param name="sender">The catalog that the extensions belong to</param> /// <param name="args">Contains the package that is uninstalling</param> private async void Catalog_PackageUninstalling(AppExtensionCatalog sender, AppExtensionPackageUninstallingEventArgs args) { await RemoveExtensions(args.Package); }
private void _catalog_PackageInstalled(AppExtensionCatalog sender, AppExtensionPackageInstalledEventArgs args) { }
public void InitializeCatalog() { _catalog = AppExtensionCatalog.Open(_contract); AppSettings.Clear(); if (_dispatcher != null) throw new Exception("Extension Manager for " + this._contract + " is already initialized."); // thread that initializes the extension manager has the dispatcher _dispatcher = Windows.UI.Core.CoreWindow.GetForCurrentThread().Dispatcher; // set up extension management events _catalog.PackageInstalled += Catalog_PackageInstalled; _catalog.PackageUninstalling += Catalog_PackageUninstalling; _catalog.PackageUpdating += Catalog_PackageUpdating; _catalog.PackageUpdated += Catalog_PackageUpdated; _catalog.PackageStatusChanged += Catalog_PackageStatusChanged; }
private void _catalog_OnPackageStatusChanged(AppExtensionCatalog sender, AppExtensionPackageStatusChangedEventArgs args) { RefreshOnDispatcherThread(); }