/// <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();
}
