private void OnAppStartup(object sender, StartupEventArgs e)
{
if (!String.IsNullOrEmpty(ApplicationStartupParameters.Current.Language) &&
!ApplicationStartupParameters.Current.Language.StartsWith("EN", StringComparison.InvariantCultureIgnoreCase))
{
var culture = new CultureInfo(ApplicationStartupParameters.Current.Language);
var catalog = new DeploymentCatalog(
new Uri(String.Format("{0}.{1}.xap", "Silverlight", culture.TwoLetterISOLanguageName), UriKind.Relative));
CompositionHost.Initialize(catalog);
catalog.DownloadCompleted += (s, args) =>
{
if (null == args.Error)
{
Thread.CurrentThread.CurrentCulture = culture;
Thread.CurrentThread.CurrentUICulture = culture;
Start();
}
else
{
// cannot download resources for specific language, continue with default language
Start();
}
};
catalog.DownloadAsync();
}
else
{
Start();
}
}
public void Execute(ActionExecutionContext context)
{
DeploymentCatalog catalog;
if(Catalogs.TryGetValue(uri, out catalog))
Completed(this, new ResultCompletionEventArgs());
else
{
catalog = new DeploymentCatalog(new Uri("/ClientBin/" + uri, UriKind.RelativeOrAbsolute));
catalog.DownloadCompleted += (s, e) =>{
if(e.Error == null)
{
Catalogs[uri] = catalog;
Catalog.Catalogs.Add(catalog);
catalog.Parts
.Select(part => ReflectionModelServices.GetPartType(part).Value.Assembly)
.Where(assembly => !AssemblySource.Instance.Contains(assembly))
.Apply(x => AssemblySource.Instance.Add(x));
}
else Loader.Hide().Execute(context);
Completed(this, new ResultCompletionEventArgs {
Error = e.Error,
WasCancelled = false
});
};
catalog.DownloadAsync();
}
}
private DeploymentCatalog CreateCatalog(string url)
{
var catalog = new DeploymentCatalog(url);
catalog.DownloadCompleted += (catalog_DownloadCompleted);
catalog.DownloadAsync();
return catalog;
}
public void LoadDeploymentCatalog(string path)
{
DeploymentCatalog catalog = new DeploymentCatalog(path);
catalog.DownloadCompleted += CatalogDownloadCompleted;
catalog.DownloadProgressChanged += CatalogDownloadProgressChanged;
catalog.DownloadAsync();
Catalog.Catalogs.Add(catalog);
}
private void Application_Startup(object sender, StartupEventArgs e)
{
var xapCatalog = new DeploymentCatalog("/ClientBin/ContosoAutomotive.Woodgrove.SL.xap");
xapCatalog.DownloadCompleted += new EventHandler<System.ComponentModel.AsyncCompletedEventArgs>(xapCatalog_DownloadCompleted);
xapCatalog.DownloadAsync();
var catalog = new AggregateCatalog(new DeploymentCatalog(), xapCatalog);
var container = new CompositionContainer(catalog);
this.RootVisual = container.GetExportedValue<CashMaker>();
}
public void AddXap(string uri)
{
DeploymentCatalog catalog;
if (!_catalogs.TryGetValue(uri, out catalog))
{
catalog = new DeploymentCatalog(uri);
catalog.DownloadAsync();
_catalogs[uri] = catalog;
}
_aggregateCatalog.Catalogs.Add(catalog);
}
public void AddXap(string uri, Action<AsyncCompletedEventArgs> completedAction = null )
{
DeploymentCatalog catalog;
if (!_catalogs.TryGetValue(uri, out catalog))
{
catalog = new DeploymentCatalog(uri);
if (completedAction != null)
catalog.DownloadCompleted += (s, e) => completedAction(e);
else
catalog.DownloadCompleted += new EventHandler<System.ComponentModel.AsyncCompletedEventArgs>(catalog_DownloadCompleted);
catalog.DownloadAsync();
_catalogs[uri] = catalog;
_aggregateCatalog.Catalogs.Add(catalog);
}
}
/// <summary>Starts the downloading of a XAP package.</summary>
/// <param name="packageUri">The URI of the XAP file to download.</param>
/// <param name="callback">The callback to invoke when the operation is complete.</param>
public void DownloadAsync(Uri packageUri, CallbackAction<IPackage> callback)
{
// Setup initial conditions.
if (packageUri == null) throw new ArgumentNullException("packageUri");
// Start the download.
var downloader = new DeploymentCatalog(packageUri);
downloader.DownloadCompleted += (s, args) =>
{
if (callback == null) return;
var callbackPayload = new Callback<IPackage>
{
Cancelled = args.Cancelled,
Error = args.Error,
};
if (!callbackPayload.HasError) callbackPayload.Result = new PackageWrapper(downloader);
callback(callbackPayload);
};
downloader.DownloadAsync();
}
public void Load(Panel element, string uri, Action<Panel, string> action, Action<Panel, string> undoAction)
{
if (!string.IsNullOrEmpty(uri))
{
if (action != null)
{
_actions[uri] = action;
}
if (undoAction != null)
{
_undoActions[uri] = undoAction;
}
if (element != null)
{
_panels[uri] = element;
}
if (_catalogs.ContainsKey(uri))
{
_actions[uri](_panels[uri], uri);
return;
}
var catalog = new DeploymentCatalog(uri);
catalog.DownloadCompleted += (s, e) =>
{
if (e.Error != null)
{
throw e.Error;
}
_actions[uri](_panels[uri], uri);
};
catalog.DownloadAsync();
_catalogs[uri] = catalog;
_aggregateCatalog.Catalogs.Add(catalog);
}
}
/// <summary>
/// Creates a DeploymentCatalog that targets the specified path. This
/// method asynchronously downloads the XAP files in the target folder
/// and will update the catalog as it completes.
/// </summary>
/// <param name="path">The path to download XAP files from</param>
/// <returns>the DeploymentCatalog that was created</returns>
private static DeploymentCatalog GetDeploymentCatalog(string path)
{
if (string.IsNullOrEmpty(path))
throw new ArgumentNullException("path", "The provided path was empty");
DeploymentCatalog catalog = new DeploymentCatalog(path);
catalog.DownloadCompleted += (s, e) => DownloadCompleted(s, e);
catalog.DownloadAsync();
return catalog;
}
private void HandleDownloadCompleted(DeploymentCatalog deploymentCatalog, AsyncCompletedEventArgs e)
{
List<ModuleInfo> moduleInfos = this.GetDownloadingModules(deploymentCatalog.Uri);
Exception error = e.Error;
if (error == null)
{
try
{
this.RecordDownloadComplete(deploymentCatalog.Uri);
foreach (ModuleInfo moduleInfo in moduleInfos)
{
this.downloadedPartCatalogs.Add(moduleInfo, deploymentCatalog);
}
this.RecordDownloadSuccess(deploymentCatalog.Uri);
}
catch (Exception ex)
{
error = ex;
}
}
foreach (ModuleInfo moduleInfo in moduleInfos)
{
this.RaiseLoadModuleCompleted(moduleInfo, error);
}
}
private void HandleDownloadProgressChanged(DeploymentCatalog deploymentCatalog, DownloadProgressChangedEventArgs e)
{
List<ModuleInfo> moduleInfos = this.GetDownloadingModules(deploymentCatalog.Uri);
foreach (ModuleInfo moduleInfo in moduleInfos)
{
this.RaiseModuleDownloadProgressChanged(moduleInfo, e.BytesReceived, e.TotalBytesToReceive);
}
}
private void DownloadModuleFromUri(ModuleInfo moduleInfo, Uri uri)
{
DeploymentCatalog deploymentCatalog = new DeploymentCatalog(uri);
try
{
// If this module has already been downloaded, fire the completed event.
if (this.IsSuccessfullyDownloaded(deploymentCatalog.Uri))
{
this.RaiseLoadModuleCompleted(moduleInfo, null);
}
else
{
bool needToStartDownload = !this.IsDownloading(uri);
// I record downloading for the moduleInfo even if I don't need to start a new download
this.RecordDownloading(uri, moduleInfo);
if (needToStartDownload)
{
deploymentCatalog.DownloadProgressChanged += this.DeploymentCatalog_DownloadProgressChanged;
deploymentCatalog.DownloadCompleted += this.DeploymentCatalog_DownloadCompleted;
deploymentCatalog.DownloadAsync();
}
}
}
catch (Exception)
{
// if there is an exception between creating the deployment catalog and calling DownloadAsync,
// the deployment catalog needs to be disposed.
// otherwise, it is added to the compositioncontainer which should handle this.
deploymentCatalog.Dispose();
throw;
}
}
public override void Load(Uri targetUri, Uri currentUri)
{
try
{
if (!parent._initialized)
parent.Initialize();
var saveTargetUri = targetUri;
if (!targetUri.IsAbsoluteUri)
targetUri = new Uri("MEF:///" + targetUri.OriginalString);
string xap = null;
if (_uriMap.TryGetValue(saveTargetUri, out xap) && xap != null && !_loadedXaps.Contains(xap))
{
var dc = new DeploymentCatalog(xap);
dc.DownloadCompleted += (s, e) =>
{
if (e.Error != null)
{
this.Error(e.Error);
return;
}
_catalog.Catalogs.Add(dc);
_loadedXaps.Add(xap);
NavigateToPage(targetUri);
};
dc.DownloadAsync();
}
else
NavigateToPage(targetUri);
}
catch (Exception e)
{
Error(e);
}
}
private void DownloadCatalogAsync(Uri uri)
{
var catalog = new DeploymentCatalog(uri);
catalog.DownloadCompleted += catalog_DownloadCompleted;
catalog.DownloadAsync();
mainCatalog.Catalogs.Add(catalog);
}
/// <summary />
private void InitializeCatalogs()
{
// load remote catalogs
IDictionary<string, string> args = Application.Current.Host.InitParams;
if (args != null && args.ContainsKey("xap"))
{
string value = args["xap"];
string[] collection = value.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string xap in collection)
{
bool absoluteUri = xap.IndexOf("://", StringComparison.OrdinalIgnoreCase) >= 0;
Uri uri = new Uri(xap, absoluteUri ? UriKind.Absolute : UriKind.Relative);
DeploymentCatalog dc = new DeploymentCatalog(uri);
dc.DownloadCompleted += this.DownloadCompleted;
this.pendingDeployments.Add(dc);
this.catalogCollection.Catalogs.Add(dc);
dc.DownloadAsync();
}
}
}
/// <summary>
/// Can optionally be called ahead of time to preload all the plugins and speed up the loading of video
/// </summary>
private static void InitializeCompositionContainer()
{
lock (SyncObject)
{
if (PluginsCatalog == null || PluginsContainer == null)
{
#if WINDOWS_PHONE
var currentAssembliesCatalog = new DeploymentCatalog(a => !AssembliesToExclude.Any(n => a.FullName.StartsWith(n)));
#else
var currentAssembliesCatalog = new DeploymentCatalog();
#endif
PluginsCatalog = new AggregateCatalog(currentAssembliesCatalog);
PluginsContainer = new CompositionContainer(PluginsCatalog);
}
}
}
private void HandleDownloadCompleted(DeploymentCatalog deploymentCatalog, AsyncCompletedEventArgs e)
{
ModuleInfo moduleInfo = GetDownloadingModule(deploymentCatalog.Uri);
Exception error = e.Error;
if (error == null)
{
try
{
this.RecordDownloadComplete(deploymentCatalog.Uri);
this.AggregateCatalog.Catalogs.Add(deploymentCatalog);
this.RecordDownloadSuccess(deploymentCatalog.Uri);
}
catch (Exception ex)
{
error = ex;
}
}
this.RaiseLoadModuleCompleted(moduleInfo, error);
}
public PackageWrapper(DeploymentCatalog downloader)
{
Uri = downloader.Uri;
Parts = downloader.Parts;
}
/// <summary>
/// Attempts to load the plug-ins at the specified location.
/// </summary>
/// <param name="xapLocation"></param>
public void BeginAddExternalPackage(Uri xapLocation)
{
var catalog = new DeploymentCatalog(xapLocation);
catalog.DownloadCompleted += new EventHandler<AsyncCompletedEventArgs>(Catalog_DownloadCompleted);
catalog.DownloadProgressChanged += new EventHandler<DownloadProgressChangedEventArgs>(Catalog_DownloadProgressChanged);
catalog.DownloadAsync();
}
private void addAndDownloadDeploymentCatalogs(IEnumerable<string> xapsDeployedOnServer)
{
numberOfXapsDeployedOnServer = xapsDeployedOnServer.Count();
deploymentCatalogs.Clear();
foreach (var deployedXap in xapsDeployedOnServer)
{
//string url = GetBaseUrl() + "ClientBin/" + deployedXap;
var xapUri = new Uri(deployedXap, UriKind.Relative);
Debug.WriteLine("Dwnloading: " + xapUri);
var deploymentCatalog = new DeploymentCatalog(xapUri);
deploymentCatalogs.Add(deploymentCatalog);
deploymentCatalog.Changed += (o, ee) => OnChanged(ee);
deploymentCatalog.Changing += (o, ee) => OnChanging(ee);
deploymentCatalog.DownloadCompleted += (o, ee) => OnDownloadCompleted(ee);
deploymentCatalog.DownloadAsync();
}
}
/// <summary>
/// An internal workflow to facilitate downloading the XAP file
/// </summary>
/// <param name="xapName">The name of the XAP</param>
/// <param name="xapLoaded">The action to call once it is loaded</param>
/// <param name="xapProgress">Action to call to report download progress</param>
/// <returns>A list of <see cref="IWorkflow"/> items to execute</returns>
private IEnumerable<IWorkflow> DownloadWorkflow(
string xapName,
Action<Exception> xapLoaded,
Action<long, int, long> xapProgress)
{
var xap = xapName.Trim().ToLower();
Logger.LogFormat(LogSeverity.Verbose, GetType().FullName, "{0}::{1}", MethodBase.GetCurrentMethod().Name, xapName);
var uri = new Uri(xap, UriKind.Relative);
if (_loaded.Contains(uri))
{
if (xapLoaded != null)
{
xapLoaded(null);
}
yield break;
}
var deploymentCatalog = new DeploymentCatalog(uri);
EventHandler<DownloadProgressChangedEventArgs> eventHandler = null;
if (xapProgress != null)
{
eventHandler = (o, args) => xapProgress(
args.BytesReceived,
args.ProgressPercentage,
args.TotalBytesToReceive);
deploymentCatalog.DownloadProgressChanged += eventHandler;
}
var downloadAction = new WorkflowEvent<AsyncCompletedEventArgs>(deploymentCatalog.DownloadAsync,
h => deploymentCatalog.DownloadCompleted += h,
h => deploymentCatalog.DownloadCompleted -= h);
Catalog.Catalogs.Add(deploymentCatalog);
EventAggregator.Publish(Constants.BEGIN_BUSY);
yield return downloadAction;
if (xapProgress != null)
{
deploymentCatalog.DownloadProgressChanged -= eventHandler;
}
InitModules();
EventAggregator.Publish(Constants.END_BUSY);
Logger.LogFormat(LogSeverity.Verbose, GetType().FullName, "{0}::{1}", MethodBase.GetCurrentMethod().Name, deploymentCatalog.Uri);
var e = downloadAction.Result;
if (e.Error != null)
{
var exception = new DeploymentCatalogDownloadException(e.Error);
Logger.Log(LogSeverity.Critical, string.Format("{0}::{1}", GetType().FullName,
MethodBase.GetCurrentMethod().Name), exception);
if (xapLoaded == null)
{
throw exception;
}
}
else
{
_loaded.Add(deploymentCatalog.Uri);
Logger.LogFormat(LogSeverity.Verbose, string.Format("{0}::{1}", GetType().FullName,
MethodBase.GetCurrentMethod().Name),
Resources.DeploymentService_DeploymentCatalogDownloadCompleted_Finished, deploymentCatalog.Uri);
if (xapLoaded != null)
{
xapLoaded(null);
}
}
}
private void HandleDownloadProgressChanged(DeploymentCatalog deploymentCatalog, DownloadProgressChangedEventArgs e)
{
ModuleInfo moduleInfo = this.GetDownloadingModule(deploymentCatalog.Uri);
this.RaiseModuleDownloadProgressChanged(moduleInfo, e.BytesReceived, e.TotalBytesToReceive);
}