3.2.36.11

Emby.Server.Implementations/Library/Resolvers/Audio/AudioResolver.cs

@@ -4,19 +4,26 @@ using MediaBrowser.Model.Entities;
 using System;
 using MediaBrowser.Controller.Entities;
 using System.IO;
+using System.Linq;
+using MediaBrowser.Controller.Providers;
+using System.Collections.Generic;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.Extensions;
+using Emby.Naming.Video;
+using Emby.Naming.AudioBook;
 
 namespace Emby.Server.Implementations.Library.Resolvers.Audio
 {
     /// <summary>
     /// Class AudioResolver
     /// </summary>
-    public class AudioResolver : ItemResolver<MediaBrowser.Controller.Entities.Audio.Audio>
+    public class AudioResolver : ItemResolver<MediaBrowser.Controller.Entities.Audio.Audio>, IMultiItemResolver
     {
-        private readonly ILibraryManager _libraryManager;
+        private readonly ILibraryManager LibraryManager;
 
         public AudioResolver(ILibraryManager libraryManager)
         {
-            _libraryManager = libraryManager;
+            LibraryManager = libraryManager;
         }
 
         /// <summary>
@@ -28,6 +35,37 @@ namespace Emby.Server.Implementations.Library.Resolvers.Audio
             get { return ResolverPriority.Last; }
         }
 
+        public MultiItemResolverResult ResolveMultiple(Folder parent,
+            List<FileSystemMetadata> files,
+            string collectionType,
+            IDirectoryService directoryService)
+        {
+            var result = ResolveMultipleInternal(parent, files, collectionType, directoryService);
+
+            if (result != null)
+            {
+                foreach (var item in result.Items)
+                {
+                    SetInitialItemValues((MediaBrowser.Controller.Entities.Audio.Audio)item, null);
+                }
+            }
+
+            return result;
+        }
+
+        private MultiItemResolverResult ResolveMultipleInternal(Folder parent,
+            List<FileSystemMetadata> files,
+            string collectionType,
+            IDirectoryService directoryService)
+        {
+            if (string.Equals(collectionType, CollectionType.Books, StringComparison.OrdinalIgnoreCase))
+            {
+                return ResolveMultipleAudio<AudioBook>(parent, files, directoryService, false, collectionType, true);
+            }
+
+            return null;
+        }
+
         /// <summary>
         /// Resolves the specified args.
         /// </summary>
@@ -37,46 +75,193 @@ namespace Emby.Server.Implementations.Library.Resolvers.Audio
         {
             // Return audio if the path is a file and has a matching extension
 
-            if (!args.IsDirectory)
-            {
             var libraryOptions = args.GetLibraryOptions();
+            var collectionType = args.GetCollectionType();
 
-                if (_libraryManager.IsAudioFile(args.Path, libraryOptions))
+            var isBooksCollectionType = string.Equals(collectionType, CollectionType.Books, StringComparison.OrdinalIgnoreCase);
+
+            if (args.IsDirectory)
+            {
+                if (!isBooksCollectionType)
+                {
+                    return null;
+                }
+
+                var files = args.FileSystemChildren
+                    .Where(i => !LibraryManager.IgnoreFile(i, args.Parent))
+                    .ToList();
+
+                if (isBooksCollectionType)
+                {
+                    return FindAudio<AudioBook>(args, args.Path, args.Parent, files, args.DirectoryService, collectionType, false);
+                }
+
+                return null;
+            }
+
+            if (LibraryManager.IsAudioFile(args.Path, libraryOptions))
             {
                 if (string.Equals(Path.GetExtension(args.Path), ".cue", StringComparison.OrdinalIgnoreCase))
                 {
                     // if audio file exists of same name, return null
-
                     return null;
                 }
 
-                    var collectionType = args.GetCollectionType();
+                var isMixedCollectionType = string.IsNullOrWhiteSpace(collectionType);
-
-                    var isMixed = string.IsNullOrWhiteSpace(collectionType);
 
                 // For conflicting extensions, give priority to videos
-                    if (isMixed && _libraryManager.IsVideoFile(args.Path, libraryOptions))
+                if (isMixedCollectionType && LibraryManager.IsVideoFile(args.Path, libraryOptions))
                 {
                     return null;
                 }
 
-                    var isStandalone = args.Parent == null;
+                MediaBrowser.Controller.Entities.Audio.Audio item = null;
 
-                    if (isStandalone ||
+                var isMusicCollectionType = string.Equals(collectionType, CollectionType.Music, StringComparison.OrdinalIgnoreCase);
-                        string.Equals(collectionType, CollectionType.Music, StringComparison.OrdinalIgnoreCase) ||
+
-                        isMixed)
+                // Use regular audio type for mixed libraries, owned items and music
+                if (isMixedCollectionType ||
+                    args.Parent == null ||
+                    isMusicCollectionType)
                 {
-                        return new MediaBrowser.Controller.Entities.Audio.Audio();
+                    item = new MediaBrowser.Controller.Entities.Audio.Audio();
                 }
 
-                    if (string.Equals(collectionType, CollectionType.Books, StringComparison.OrdinalIgnoreCase))
+                else if (isBooksCollectionType)
                 {
-                        return new AudioBook();
+                    item = new AudioBook();
                 }
+
+                if (item != null)
+                {
+                    item.IsInMixedFolder = true;
                 }
+
+                return item;
             }
 
             return null;
         }
+
+        private T FindAudio<T>(ItemResolveArgs args, string path, Folder parent, List<FileSystemMetadata> fileSystemEntries, IDirectoryService directoryService, string collectionType, bool parseName)
+            where T : MediaBrowser.Controller.Entities.Audio.Audio, new()
+        {
+            var multiDiscFolders = new List<FileSystemMetadata>();
+
+            var libraryOptions = args.GetLibraryOptions();
+            var filesFromOtherItems = new List<FileSystemMetadata>();
+
+            // TODO: Allow GetMultiDiscMovie in here
+            var supportsMultiVersion = false;
+
+            var result = ResolveMultipleAudio<T>(parent, fileSystemEntries, directoryService, supportsMultiVersion, collectionType, parseName) ??
+                new MultiItemResolverResult();
+
+            if (result.Items.Count == 1)
+            {
+                var videoPath = result.Items[0].Path;
+
+                // If we were supporting this we'd be checking filesFromOtherItems
+                var hasOtherItems = false;
+
+                if (!hasOtherItems)
+                {
+                    var item = (T)result.Items[0];
+                    item.IsInMixedFolder = false;
+                    item.Name = Path.GetFileName(item.ContainingFolderPath);
+                    return item;
+                }
+            }
+
+            if (result.Items.Count == 0 && multiDiscFolders.Count > 0)
+            {
+                //return GetMultiDiscAudio<T>(multiDiscFolders, directoryService);
+            }
+
+            return null;
+        }
+
+        private MultiItemResolverResult ResolveMultipleAudio<T>(Folder parent, IEnumerable<FileSystemMetadata> fileSystemEntries, IDirectoryService directoryService, bool suppportMultiEditions, string collectionType, bool parseName)
+            where T : MediaBrowser.Controller.Entities.Audio.Audio, new()
+        {
+            var files = new List<FileSystemMetadata>();
+            var items = new List<BaseItem>();
+            var leftOver = new List<FileSystemMetadata>();
+
+            // Loop through each child file/folder and see if we find a video
+            foreach (var child in fileSystemEntries)
+            {
+                if (child.IsDirectory)
+                {
+                    leftOver.Add(child);
+                }
+                else if (IsIgnored(child.Name))
+                {
+
+                }
+                else
+                {
+                    files.Add(child);
+                }
+            }
+
+            var namingOptions = ((LibraryManager)LibraryManager).GetNamingOptions();
+
+            var resolver = new AudioBookListResolver(namingOptions);
+            var resolverResult = resolver.Resolve(files).ToList();
+
+            var result = new MultiItemResolverResult
+            {
+                ExtraFiles = leftOver,
+                Items = items
+            };
+
+            var isInMixedFolder = resolverResult.Count > 1 || (parent != null && parent.IsTopParent);
+
+            foreach (var resolvedItem in resolverResult)
+            {
+                var firstMedia = resolvedItem.Files.First();
+                
+                var libraryItem = new T
+                {
+                    Path = firstMedia.Path,
+                    IsInMixedFolder = isInMixedFolder,
+                    //ProductionYear = resolvedItem.Year,
+                    Name = parseName ?
+                        resolvedItem.Name :
+                        Path.GetFileNameWithoutExtension(firstMedia.Path),
+                    //AdditionalParts = resolvedItem.Files.Skip(1).Select(i => i.Path).ToArray(),
+                    //LocalAlternateVersions = resolvedItem.AlternateVersions.Select(i => i.Path).ToArray()
+                };
+
+                result.Items.Add(libraryItem);
+            }
+
+            result.ExtraFiles.AddRange(files.Where(i => !ContainsFile(resolverResult, i)));
+
+            return result;
+        }
+
+        private bool ContainsFile(List<AudioBookInfo> result, FileSystemMetadata file)
+        {
+            return result.Any(i => ContainsFile(i, file));
+        }
+
+        private bool ContainsFile(AudioBookInfo result, FileSystemMetadata file)
+        {
+            return result.Files.Any(i => ContainsFile(i, file)) ||
+                result.AlternateVersions.Any(i => ContainsFile(i, file)) ||
+                result.Extras.Any(i => ContainsFile(i, file));
+        }
+
+        private bool ContainsFile(AudioBookFileInfo result, FileSystemMetadata file)
+        {
+            return string.Equals(result.Path, file.FullName, StringComparison.OrdinalIgnoreCase);
+        }
+
+        private bool IsIgnored(string filename)
+        {
+            return false;
+        }
     }
 }

Emby.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs

@@ -202,14 +202,14 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
         {
             var collectionType = args.GetCollectionType();
 
+            // Find movies with their own folders
+            if (args.IsDirectory)
+            {
                 if (IsInvalid(args.Parent, collectionType))
                 {
                     return null;
                 }
 
-            // Find movies with their own folders
-            if (args.IsDirectory)
-            {
                 var files = args.FileSystemChildren
                     .Where(i => !LibraryManager.IgnoreFile(i, args.Parent))
                     .ToList();
@@ -251,8 +251,13 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
                 return null;
             }
 
-            // Owned items will be caught by the plain video resolver
+            // Handle owned items
             if (args.Parent == null)
+            {
+                return base.Resolve(args);
+            }
+
+            if (IsInvalid(args.Parent, collectionType))
             {
                 return null;
             }
@@ -528,6 +533,15 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
             return returnVideo;
         }
 
+        private string[] ValidCollectionTypes = new[]
+        {
+                CollectionType.Movies,
+                CollectionType.HomeVideos,
+                CollectionType.MusicVideos,
+                CollectionType.Movies,
+                CollectionType.Photos
+            };
+
         private bool IsInvalid(Folder parent, string collectionType)
         {
             if (parent != null)
@@ -538,21 +552,12 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
                 }
             }
 
-            var validCollectionTypes = new[]
-            {
-                CollectionType.Movies,
-                CollectionType.HomeVideos,
-                CollectionType.MusicVideos,
-                CollectionType.Movies,
-                CollectionType.Photos
-            };
-
             if (string.IsNullOrWhiteSpace(collectionType))
             {
                 return false;
             }
 
-            return !validCollectionTypes.Contains(collectionType, StringComparer.OrdinalIgnoreCase);
+            return !ValidCollectionTypes.Contains(collectionType, StringComparer.OrdinalIgnoreCase);
         }
 
         private IImageProcessor _imageProcessor;

Emby.Server.Implementations/Library/Resolvers/VideoResolver.cs

@@ -5,36 +5,6 @@ using MediaBrowser.Model.IO;
 
 namespace Emby.Server.Implementations.Library.Resolvers
 {
-    /// <summary>
-    /// Resolves a Path into a Video
-    /// </summary>
-    public class VideoResolver : BaseVideoResolver<Video>
-    {
-        protected override Video Resolve(ItemResolveArgs args)
-        {
-            if (args.Parent != null)
-            {
-                // The movie resolver will handle this
-                return null;
-            }
-
-            return base.Resolve(args);
-        }
-
-        /// <summary>
-        /// Gets the priority.
-        /// </summary>
-        /// <value>The priority.</value>
-        public override ResolverPriority Priority
-        {
-            get { return ResolverPriority.Last; }
-        }
-
-        public VideoResolver(ILibraryManager libraryManager, IFileSystem fileSystem) : base(libraryManager, fileSystem)
-        {
-        }
-    }
-
     public class GenericVideoResolver<T> : BaseVideoResolver<T>
         where T : Video, new ()
     {

Emby.Server.Implementations/Localization/Core/es-MX.json

@@ -27,7 +27,7 @@
     "Artists": "Artistas",
     "Folders": "Carpetas",
     "Songs": "Canciones",
-    "TvShows": "TV Shows",
+    "TvShows": "Programas de TV",
     "Shows": "Programas",
     "Genres": "G\u00e9neros",
     "NameSeasonNumber": "Temporada {0}",

MediaBrowser.Providers/Manager/MetadataService.cs

@@ -126,7 +126,7 @@ namespace MediaBrowser.Providers.Manager
                 var providers = GetProviders(item, refreshOptions, isFirstRefresh, requiresRefresh)
                     .ToList();
 
-                if (providers.Count > 0 || isFirstRefresh)
+                if (providers.Count > 0 || isFirstRefresh || requiresRefresh)
                 {
                     if (item.BeforeMetadataRefresh())
                     {

MediaBrowser.Server.Mono/ImageEncoderHelper.cs

@@ -32,7 +32,7 @@ namespace MediaBrowser.Server.Startup.Common
                 }
                 catch (Exception ex)
                 {
-                    logger.Error("Skia not available. Will try next image processor. {0}", ex.Message);
+                    logger.Info("Skia not available. Will try next image processor. {0}", ex.Message);
                 }
 
                 try
@@ -41,7 +41,7 @@ namespace MediaBrowser.Server.Startup.Common
                 }
                 catch
                 {
-                    logger.Error("ImageMagick not available. Will try next image processor.");
+                    logger.Info("ImageMagick not available. Will try next image processor.");
                 }
             }
 

SharedVersion.cs

@@ -1,3 +1,3 @@
 using System.Reflection;
 
-[assembly: AssemblyVersion("3.2.36.10")]
+[assembly: AssemblyVersion("3.2.36.11")]