jellyfin/MediaBrowser.Controller/Kernel.cs

298 lines
9.3 KiB
C#
Raw Normal View History

2012-07-12 06:55:27 +00:00
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
2012-07-12 06:55:27 +00:00
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using MediaBrowser.Common.Kernel;
using MediaBrowser.Controller.Configuration;
2012-07-12 06:55:27 +00:00
using MediaBrowser.Controller.Events;
using MediaBrowser.Controller.IO;
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.Providers;
2012-07-12 06:55:27 +00:00
using MediaBrowser.Controller.Resolvers;
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.Progress;
2012-07-12 06:55:27 +00:00
namespace MediaBrowser.Controller
{
public class Kernel : BaseKernel<ServerConfiguration, ServerApplicationPaths>
2012-07-12 06:55:27 +00:00
{
public static Kernel Instance { get; private set; }
public ItemController ItemController { get; private set; }
public IEnumerable<User> Users { get; private set; }
public Folder RootFolder { get; private set; }
private DirectoryWatchers DirectoryWatchers { get; set; }
private string MediaRootFolderPath
{
get
{
2012-08-02 03:13:44 +00:00
return ApplicationPaths.RootFolderPath;
2012-07-12 06:55:27 +00:00
}
}
/// <summary>
/// Gets the list of currently registered metadata prvoiders
/// </summary>
[ImportMany(typeof(BaseMetadataProvider))]
public IEnumerable<BaseMetadataProvider> MetadataProviders { get; private set; }
/// <summary>
/// Gets the list of currently registered entity resolvers
/// </summary>
[ImportMany(typeof(IBaseItemResolver))]
public IEnumerable<IBaseItemResolver> EntityResolvers { get; private set; }
2012-07-12 06:55:27 +00:00
/// <summary>
/// Creates a kernel based on a Data path, which is akin to our current programdata path
2012-07-12 06:55:27 +00:00
/// </summary>
public Kernel()
: base()
2012-07-12 06:55:27 +00:00
{
Instance = this;
ItemController = new ItemController();
DirectoryWatchers = new DirectoryWatchers();
ItemController.PreBeginResolvePath += ItemController_PreBeginResolvePath;
ItemController.BeginResolvePath += ItemController_BeginResolvePath;
}
public async override Task Init(IProgress<TaskProgress> progress)
{
await Task.Run(async () =>
{
await base.Init(progress);
progress.Report(new TaskProgress() { Description = "Loading Users", PercentComplete = 15 });
ReloadUsers();
progress.Report(new TaskProgress() { Description = "Loading Media Library", PercentComplete = 20 });
await ReloadRoot();
progress.Report(new TaskProgress() { Description = "Loading Complete", PercentComplete = 100 });
});
}
protected override void OnComposablePartsLoaded()
2012-07-12 06:55:27 +00:00
{
AddCoreResolvers();
AddCoreProviders();
2012-07-26 13:51:26 +00:00
// The base class will start up all the plugins
base.OnComposablePartsLoaded();
2012-07-12 06:55:27 +00:00
}
private void AddCoreResolvers()
{
List<IBaseItemResolver> list = EntityResolvers.ToList();
// Add the core resolvers
list.AddRange(new IBaseItemResolver[]{
new AudioResolver(),
new VideoResolver(),
new VirtualFolderResolver(),
new FolderResolver()
});
EntityResolvers = list;
}
private void AddCoreProviders()
{
List<BaseMetadataProvider> list = MetadataProviders.ToList();
// Add the core resolvers
list.InsertRange(0, new BaseMetadataProvider[]{
new ImageFromMediaLocationProvider(),
new LocalTrailerProvider(),
new AudioInfoProvider(),
new FolderProviderFromXml()
});
MetadataProviders = list;
Parallel.ForEach(MetadataProviders, provider =>
{
provider.Init();
});
}
2012-07-12 06:55:27 +00:00
/// <summary>
/// Fires when a path is about to be resolved, but before child folders and files
/// have been collected from the file system.
/// This gives us a chance to cancel it if needed, resulting in the path being ignored
/// </summary>
void ItemController_PreBeginResolvePath(object sender, PreBeginResolveEventArgs e)
{
if (e.IsHidden || e.IsSystemFile)
{
// Ignore hidden files and folders
e.Cancel = true;
}
else if (Path.GetFileName(e.Path).Equals("trailers", StringComparison.OrdinalIgnoreCase))
{
// Ignore any folders named "trailers"
e.Cancel = true;
}
}
/// <summary>
/// Fires when a path is about to be resolved, but after child folders and files
/// This gives us a chance to cancel it if needed, resulting in the path being ignored
/// </summary>
void ItemController_BeginResolvePath(object sender, ItemResolveEventArgs e)
{
if (e.IsFolder)
{
if (e.ContainsFile(".ignore"))
{
// Ignore any folders containing a file called .ignore
e.Cancel = true;
}
}
}
private void ReloadUsers()
{
2012-07-31 13:28:12 +00:00
Users = GetAllUsers();
2012-07-12 06:55:27 +00:00
}
/// <summary>
/// Reloads the root media folder
/// </summary>
public async Task ReloadRoot()
2012-07-12 06:55:27 +00:00
{
if (!Directory.Exists(MediaRootFolderPath))
{
Directory.CreateDirectory(MediaRootFolderPath);
}
DirectoryWatchers.Stop();
RootFolder = await ItemController.GetItem(null, MediaRootFolderPath) as Folder;
2012-07-12 06:55:27 +00:00
DirectoryWatchers.Start();
}
private static MD5CryptoServiceProvider md5Provider = new MD5CryptoServiceProvider();
public static Guid GetMD5(string str)
{
lock (md5Provider)
{
return new Guid(md5Provider.ComputeHash(Encoding.Unicode.GetBytes(str)));
}
}
public async Task ReloadItem(BaseItem item)
2012-07-12 06:55:27 +00:00
{
Folder folder = item as Folder;
if (folder != null && folder.IsRoot)
{
await ReloadRoot();
2012-07-12 06:55:27 +00:00
}
else
{
if (!Directory.Exists(item.Path) && !File.Exists(item.Path))
{
await ReloadItem(item.Parent);
2012-07-12 06:55:27 +00:00
return;
}
BaseItem newItem = await ItemController.GetItem(item.Parent, item.Path);
2012-07-12 06:55:27 +00:00
List<BaseItem> children = item.Parent.Children.ToList();
int index = children.IndexOf(item);
children.RemoveAt(index);
children.Insert(index, newItem);
item.Parent.Children = children.ToArray();
}
}
/// <summary>
/// Finds a library item by Id
/// </summary>
public BaseItem GetItemById(Guid id)
{
if (id == Guid.Empty)
{
return RootFolder;
}
return RootFolder.FindItemById(id);
}
2012-07-31 13:28:12 +00:00
/// <summary>
/// Gets all users within the system
/// </summary>
private IEnumerable<User> GetAllUsers()
{
List<User> list = new List<User>();
// Return a dummy user for now since all calls to get items requre a userId
User user = new User();
2012-07-31 13:28:12 +00:00
user.Name = "Default User";
user.Id = Guid.Parse("5d1cf7fce25943b790d140095457a42b");
list.Add(user);
2012-07-31 13:28:12 +00:00
return list;
}
internal async Task ExecuteMetadataProviders(BaseEntity item, ItemResolveEventArgs args)
{
var supportedProviders = Kernel.Instance.MetadataProviders.Where(i => i.Supports(item));
// Start with non-internet providers. Run them sequentially
foreach (BaseMetadataProvider provider in supportedProviders.Where(i => !i.RequiresInternet))
{
await provider.Fetch(item, args);
}
var internetProviders = supportedProviders.Where(i => i.RequiresInternet);
if (internetProviders.Any())
{
// Now execute internet providers in parallel
await Task.WhenAll(
internetProviders.Select(i => i.Fetch(item, args))
);
}
}
protected override void DisposeComposableParts()
{
base.DisposeComposableParts();
DisposeProviders();
}
/// <summary>
/// Disposes all providers
/// </summary>
private void DisposeProviders()
{
if (MetadataProviders != null)
{
foreach (var provider in MetadataProviders)
{
provider.Dispose();
}
}
}
2012-07-12 06:55:27 +00:00
}
}