protected async Task <ICollection <MediaItem> > Browse(Guid parentDirectoryId, IEnumerable <Guid> necessaryRequestedMiaTypeIds, IEnumerable <Guid> optionalRequestedMiaTypeIds)
{
while (true)
{
try
{
await Activated.WaitAsync().ConfigureAwait(false);
// ReSharper disable PossibleMultipleEnumeration
return(await _mediaBrowsingCallback.BrowseAsync(parentDirectoryId, necessaryRequestedMiaTypeIds, optionalRequestedMiaTypeIds, null, false).ConfigureAwait(false));
// ReSharper restore PossibleMultipleEnumeration
}
catch (DisconnectedException)
{
await MedialibraryDisconnectedSuspend();
}
}
}
/// <summary>
/// Imports or refreshes the directory with the specified <paramref name="directoryAccessor"/>. Sub directories will not
/// be processed in this method.
/// </summary>
/// <param name="importJob">The import job being processed.</param>
/// <param name="parentDirectoryId">Media item id of the parent directory, if present, else <see cref="Guid.Empty"/>.</param>
/// <param name="directoryAccessor">Resource accessor for the directory to import.</param>
/// <param name="metadataExtractors">Metadata extractors to apply on the resources.</param>
/// <param name="mediaBrowsing">Callback interface to the media library for the refresh import type.</param>
/// <param name="resultHandler">Callback to notify the import result.</param>
/// <param name="mediaAccessor">Convenience reference to the media accessor.</param>
/// <returns>Id of the directory's media item or <c>null</c>, if the given <paramref name="directoryAccessor"/>
/// was imported as a media item or if an error occured. If <c>null</c> is returned, the directory import should be
/// considered to be finished.</returns>
protected Guid?ImportDirectory(ImportJob importJob, Guid parentDirectoryId, IFileSystemResourceAccessor directoryAccessor,
ICollection <IMetadataExtractor> metadataExtractors, IMediaBrowsing mediaBrowsing,
IImportResultHandler resultHandler, IMediaAccessor mediaAccessor)
{
ResourcePath currentDirectoryPath = directoryAccessor.CanonicalLocalResourcePath;
try
{
ImporterWorkerMessaging.SendImportMessage(ImporterWorkerMessaging.MessageType.ImportStatus, currentDirectoryPath);
if (ImportResource(importJob, directoryAccessor, parentDirectoryId, metadataExtractors, resultHandler, mediaAccessor))
{
// The directory could be imported as a media item.
// If the directory itself was identified as a normal media item, don't import its children.
// Necessary for DVD directories, for example.
return(null);
}
Guid directoryId = GetOrAddDirectory(importJob, directoryAccessor, parentDirectoryId, mediaBrowsing, resultHandler);
IDictionary <string, MediaItem> path2Item = new Dictionary <string, MediaItem>();
if (importJob.JobType == ImportJobType.Refresh)
{
foreach (MediaItem mediaItem in mediaBrowsing.BrowseAsync(directoryId,
IMPORTER_PROVIDER_MIA_ID_ENUMERATION, EMPTY_MIA_ID_ENUMERATION, null, false).Result)
{
IList <MultipleMediaItemAspect> providerResourceAspects;
if (MediaItemAspect.TryGetAspects(mediaItem.Aspects, ProviderResourceAspect.Metadata, out providerResourceAspects))
{
path2Item[providerResourceAspects[0].GetAttributeValue <string>(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH)] = mediaItem;
}
}
}
CheckImportStillRunning(importJob.State);
ICollection <IFileSystemResourceAccessor> files = FileSystemResourceNavigator.GetFiles(directoryAccessor, false);
if (files != null)
{
foreach (IFileSystemResourceAccessor fileAccessor in files)
{
using (fileAccessor)
{ // Add & update files
ResourcePath currentFilePath = fileAccessor.CanonicalLocalResourcePath;
string serializedFilePath = currentFilePath.Serialize();
try
{
SingleMediaItemAspect importerAspect;
MediaItem mediaItem;
if (importJob.JobType == ImportJobType.Refresh &&
path2Item.TryGetValue(serializedFilePath, out mediaItem) &&
MediaItemAspect.TryGetAspect(mediaItem.Aspects, ImporterAspect.Metadata, out importerAspect) &&
importerAspect.GetAttributeValue <DateTime>(ImporterAspect.ATTR_LAST_IMPORT_DATE) > fileAccessor.LastChanged)
{ // We can skip this file; it was imported after the last change time of the item
path2Item.Remove(serializedFilePath);
continue;
}
if (ImportResource(importJob, fileAccessor, directoryId, metadataExtractors, resultHandler, mediaAccessor))
{
path2Item.Remove(serializedFilePath);
}
}
catch (Exception e)
{
CheckSuspended(e); // Throw ImportAbortException if suspended - will skip warning and tagging job as erroneous
ServiceRegistration.Get <ILogger>().Warn("ImporterWorker: Problem while importing resource '{0}'", e, serializedFilePath);
importJob.State = ImportJobState.Erroneous;
}
CheckImportStillRunning(importJob.State);
}
}
}
if (importJob.JobType == ImportJobType.Refresh)
{ // Remove remaining (= non-present) files
foreach (string pathStr in path2Item.Keys)
{
ResourcePath path = ResourcePath.Deserialize(pathStr);
try
{
IResourceAccessor ra;
if (!path.TryCreateLocalResourceAccessor(out ra))
{
throw new IllegalCallException("Unable to access resource path '{0}'", importJob.BasePath);
}
using (ra)
{
IFileSystemResourceAccessor fsra = ra as IFileSystemResourceAccessor;
if (fsra == null || !fsra.IsFile)
{
// Don't touch directories because they will be imported in a different call of ImportDirectory
continue;
}
}
}
catch (IllegalCallException)
{
// This happens if the resource doesn't exist any more - we also catch missing directories here
}
// Delete all remaining items
resultHandler.DeleteMediaItemAsync(path);
CheckImportStillRunning(importJob.State);
}
}
return(directoryId);
}
catch (ImportSuspendedException)
{
throw;
}
catch (ImportAbortException)
{
throw;
}
catch (UnauthorizedAccessException e)
{
// If the access to the file or folder was denied, simply continue with the others
ServiceRegistration.Get <ILogger>().Warn("ImporterWorker: Problem accessing resource '{0}', continueing with one", e, currentDirectoryPath);
}
catch (Exception e)
{
CheckSuspended(e); // Throw ImportAbortException if suspended - will skip warning and tagging job as erroneous
ServiceRegistration.Get <ILogger>().Warn("ImporterWorker: Problem while importing directory '{0}'", e, currentDirectoryPath);
importJob.State = ImportJobState.Erroneous;
}
return(null);
}