private int BrowseFolder_AddItems(IRequest request, XmlDocument result, IMediaFolder root, int start, int requested)
{
var provided = 0;
foreach (var i in root.ChildFolders)
{
if (start > 0)
{
start--;
continue;
}
Browse_AddFolder(result, i);
if (++provided == requested)
{
break;
}
}
if (provided != requested)
{
foreach (var i in root.ChildItems)
{
if (start > 0)
{
start--;
continue;
}
Browse_AddItem(request, result, i);
if (++provided == requested)
{
break;
}
}
}
return(provided);
}
protected override void SortFolder(IMediaFolder folder,
SimpleKeyedVirtualFolder series)
{
foreach (var f in folder.ChildFolders.ToList())
{
SortFolder(f, series);
}
foreach (var i in folder.ChildItems.ToList())
{
var title = i.Title;
if (string.IsNullOrWhiteSpace(title))
{
continue;
}
var m = regSeries.Match(title);
if (!m.Success)
{
continue;
}
var ser = m.Groups[1].Value;
if (string.IsNullOrEmpty(ser))
{
continue;
}
series.GetFolder(ser.StemNameBase()).AddResource(i);
folder.RemoveResource(i);
}
}
public bool MoveTo(IMediaFolder destination)
{
try
{
if (_device.IsReadOnly == true)
{
return(false);
}
if (destination.Device.IsReadOnly == true)
{
return(false);
}
this.Refresh();
_parent.RemoveItemInternal(this);
_info.MoveTo(Path.Combine(destination.AbsolutePath, _info.Name));
MediaFolder folder = destination as MediaFolder;
Debug.Assert(folder != null, "Do not support inter-device moves yet");
folder.AddItemInternal(this);
_parent = folder;
}
catch
{
return(false);
}
return(true);
}
/// <summary>
/// Release the resources used by the current <see cref="GameInformation"/> instance.
/// </summary>
public void Dispose()
{
if (IgnoreDispose == true)
{
return;
}
if (this.DataPsp != null)
{
this.DataPsp.Dispose();
}
this.DataPsp = null;
if (this.Icon != null)
{
this.Icon.Dispose();
}
if (this.Background != null)
{
this.Background.Dispose();
}
this.Folder = null;
}
protected override void SortFolder(IMediaFolder folder,
SimpleKeyedVirtualFolder series)
{
foreach (var f in folder.ChildFolders.ToList()) {
SortFolder(f, series);
}
foreach (var i in folder.ChildItems.ToList()) {
try {
var title = i.Title;
if (string.IsNullOrWhiteSpace(title)) {
throw new Exception("No title");
}
var m = regSites.Match(title);
if (!m.Success) {
throw new Exception("No match");
}
var site = m.Groups["site"].Value;
if (string.IsNullOrEmpty(site)) {
throw new Exception("No site");
}
site = site.Replace(" ", "").Replace("\t", "").Replace("-", "");
site = regNumberStrip.Replace(site, string.Empty).TrimEnd();
if (!regWord.IsMatch(site)) {
throw new Exception("Not a site");
}
folder.RemoveResource(i);
series.GetFolder(site.StemNameBase()).AddResource(i);
}
catch (Exception ex) {
DebugFormat("{0} - {1}", ex.Message, i.Title);
folder.RemoveResource(i);
series.AddResource(i);
}
}
}
private void RegisterNewMaster(IMediaFolder newMaster)
{
lock (ids)
{
ids.RegisterFolder(Identifiers.GENERAL_ROOT, newMaster);
ids.RegisterFolder(
Identifiers.SAMSUNG_IMAGES,
new VirtualClonedFolder(
newMaster,
Identifiers.SAMSUNG_IMAGES,
types & DlnaMediaTypes.Image
)
);
ids.RegisterFolder(
Identifiers.SAMSUNG_AUDIO,
new VirtualClonedFolder(
newMaster,
Identifiers.SAMSUNG_AUDIO,
types & DlnaMediaTypes.Audio
)
);
ids.RegisterFolder(
Identifiers.SAMSUNG_VIDEO,
new VirtualClonedFolder(
newMaster,
Identifiers.SAMSUNG_VIDEO,
types & DlnaMediaTypes.Video
)
);
}
}
public override IMediaFolder Transform(IMediaFolder Root)
{
var rv = new VirtualFolder(null, Root.Title, Root.Id);
EatAll(rv, Root);
return(rv);
}
public override IMediaFolder Transform(IMediaFolder oldRoot)
{
var root = new VirtualClonedFolder(oldRoot);
var titles = new SimpleKeyedVirtualFolder(root, "titles");
SortFolder(root, titles);
foreach (var i in root.ChildFolders.ToList())
{
root.ReleaseFolder(i);
}
foreach (var i in titles.ChildFolders.ToList())
{
if (i.ChildCount > 100)
{
DebugFormat("Partioning folder {0}", i.Title);
using (var prefixer = new Prefixer())
{
PartitionChildren(i as VirtualFolder, prefixer);
}
}
root.AdoptFolder(i);
}
return(root);
}
public void Merge(IMediaFolder folder)
{
if (folder == null)
{
throw new ArgumentNullException(nameof(folder));
}
merged.Add(folder);
foreach (var item in folder.ChildItems)
{
AddResource(item);
}
foreach (var cf in folder.ChildFolders)
{
var ownFolder = (from f in Folders
where f is VirtualFolder && f.Title == cf.Title
select f as VirtualFolder
).FirstOrDefault();
if (ownFolder == null)
{
ownFolder = new VirtualFolder(this, cf.Title, cf.Id);
AdoptFolder(ownFolder);
}
ownFolder.Merge(cf);
}
}
private static void Browse_AddFolder(XmlDocument result, IMediaFolder f)
{
var meta = f as IMetaInfo;
var container = result.CreateElement(string.Empty, "container", NS_DIDL);
container.SetAttribute("restricted", "0");
container.SetAttribute("childCount", f.ChildCount.ToString());
container.SetAttribute("id", f.Id);
var parent = f.Parent;
container.SetAttribute("parentID", parent == null ? Identifiers.GENERAL_ROOT : parent.Id);
var title = result.CreateElement("dc", "title", NS_DC);
title.InnerText = f.Title;
container.AppendChild(title);
if (meta != null)
{
var date = result.CreateElement("dc", "date", NS_DC);
date.InnerText = meta.InfoDate.ToString("o");
container.AppendChild(date);
}
var objectClass = result.CreateElement("upnp", "class", NS_UPNP);
objectClass.InnerText = "object.container";
container.AppendChild(objectClass);
result.DocumentElement?.AppendChild(container);
}
private bool HandleFileDeleted(string fullPath, IMediaFolder master)
{
var info = new FileInfo(fullPath);
if (store != null)
{
store.MaybeRemoveFile(info);
}
lock (ids)
{
var item = ids.GetItemByPath(info.FullName) as IMediaResource;
var folder = ids.GetItemByPath(info.Directory?.FullName) as VirtualFolder;
if (item != null || folder != null)
{
ids.RemoveItemByPath(fullPath);
}
foreach (var childFolder in master.ChildFolders)
{
childFolder.RemoveResource(item);
}
if (folder != null)
{
return(folder.RemoveResource(item));
}
return(true);
}
}
private void CheckSampleExists(IMediaFolder master)
{
if (store == null)
{
return;
}
// Check a random sample of files still exists, we don't really handle deletions well
// Ideally we would check the this file is valid for this mast folder
// But we don't know if the filetypes or paths have been changed
int cleanedFile = 0;
int sampleSize = 0;
foreach (var path in store.RandomSample())
{
sampleSize++;
if (!File.Exists(path))
{
cleanedFile++;
HandleFileDeleted(path, master);
}
}
if (cleanedFile > 0)
{
NoticeFormat("Removed {0} out of sample of {1}", cleanedFile, sampleSize);
}
}
public override IMediaFolder Transform(IMediaFolder root)
{
if (filter == null) {
return root;
}
return base.Transform(root);
}
public override IMediaFolder Transform(IMediaFolder Root)
{
var root = new VirtualClonedFolder(Root);
var series = new SimpleKeyedVirtualFolder(root, "Series");
SortFolder(root, series);
foreach (var f in series.ChildFolders.ToList()) {
if (f.ChildCount < 2) {
foreach (var file in f.ChildItems) {
root.AddResource(file);
}
continue;
}
var fsmi = f as VirtualFolder;
root.AdoptFolder(fsmi);
}
if (!cascade || root.ChildFolders.LongCount() <= 50) {
return root;
}
var cascaded = new DoubleKeyedVirtualFolder(root, "Series");
foreach (var i in root.ChildFolders.ToList()) {
var folder = cascaded.GetFolder(i.Title.StemCompareBase().Substring(0, 1).ToUpper());
folder.AdoptFolder(i);
}
foreach (var i in root.ChildItems.ToList()) {
var folder = cascaded.GetFolder(i.Title.StemCompareBase().Substring(0, 1).ToUpper());
folder.AddResource(i);
}
return cascaded;
}
public void StartGameDirect(string path, bool debugging)
{
if (path == null)
{
return;
}
if (debugging == true)
{
_host.AttachDebugger();
}
this.StartInstance(false, debugging);
// If the path contains 'iso', we assume it's an iso and load it via the UMD driver
Games.GameInformation game = null;
if (path.Contains("iso") == true)
{
if (File.Exists(path) == false)
{
Log.WriteLine(Verbosity.Critical, Feature.General, "Unable to direct start UMD {0} - path not found", path);
return;
}
_host.CurrentInstance.Umd.Load(path, false);
game = Games.GameLoader.FindGame(_host.CurrentInstance.Umd);
if (game == null)
{
Log.WriteLine(Verbosity.Critical, Feature.General, "Unable to find game in UMD ISO {0}", path);
return;
}
Log.WriteLine(Verbosity.Critical, Feature.General, "Direct starting UMD '{0}' from {1}", game.Parameters.Title, path);
}
else
{
// We need to get the folder on the memory stick device of this path
IMediaFolder folder = _host.CurrentInstance.MemoryStick.Root.FindFolder(path);
if (folder == null)
{
Log.WriteLine(Verbosity.Critical, Feature.General, "Unable to find path {0}", path);
return;
}
game = Games.GameLoader.GetEbootGameInformation(folder);
if (game == null)
{
Log.WriteLine(Verbosity.Critical, Feature.General, "Unable to find eboot at path {0}", path);
return;
}
Log.WriteLine(Verbosity.Critical, Feature.General, "Direct starting eboot '{0}' from {1}", game.Parameters.Title, path);
}
Debug.Assert(game != null);
if (game == null)
{
return;
}
(_host.CurrentInstance as Instance).SwitchToGame(game);
}
private FolderHierarchy GetFolderHierarchy(IMediaFolder root)
{
Argument.ThrowIfNull(root, "root");
return(new FolderHierarchy(root)
{
Children = _mediaLibraryService.GetMediaFolders(root.MediaPath).Select(GetFolderHierarchy)
});
}
public override IMediaFolder Transform(IMediaFolder root)
{
if (filter == null)
{
return(root);
}
return(base.Transform(root));
}
public override IMediaFolder Transform(IMediaFolder oldRoot)
{
if (!min.HasValue && !max.HasValue && !minWidth.HasValue &&
!maxWidth.HasValue && !minHeight.HasValue && !maxHeight.HasValue) {
return oldRoot;
}
return base.Transform(oldRoot);
}
protected VirtualClonedFolder(IMediaFolder parent, string name, string id, DlnaMediaTypes types)
: base(parent, name, id)
{
this.types = types;
Id = id;
clone = parent;
CloneFolder(this, parent);
Cleanup();
}
protected VirtualClonedFolder(IMediaFolder parent, string name, string id, DlnaMediaTypes types)
: base(parent, name, id)
{
this.types = types;
Id = id;
clone = parent;
CloneFolder(this, parent);
Cleanup();
}
public override IMediaFolder Transform(IMediaFolder root)
{
if (filter == null) {
return root;
}
root = new VirtualClonedFolder(root);
ProcessFolder(root);
return root;
}
public override IMediaFolder Transform(IMediaFolder Root)
{
if (Root == null) {
throw new ArgumentNullException("Root");
}
var rv = new VirtualFolder(null, Root.Title, Root.Id);
EatAll(rv, Root);
return rv;
}
private static void EatAll(IMediaFolder root, IMediaFolder folder)
{
foreach (var f in folder.ChildFolders.ToList()) {
EatAll(root, f);
}
foreach (var c in folder.ChildItems.ToList()) {
root.AddResource(c);
}
}
public override IMediaFolder Transform(IMediaFolder oldRoot)
{
if (!min.HasValue && !max.HasValue && !minWidth.HasValue &&
!maxWidth.HasValue && !minHeight.HasValue && !maxHeight.HasValue)
{
return(oldRoot);
}
return(base.Transform(oldRoot));
}
public bool CopyItem(string name, IMediaFolder destination)
{
IMediaItem item = this[name];
if (item == null)
{
return(false);
}
return(item.CopyTo(destination));
}
public bool CopyTo(IMediaFolder destination)
{
if (destination.Device.IsReadOnly == true)
{
return(false);
}
// TODO: Folder copy
throw new NotImplementedException();
}
internal GameInformation(GameType gameType, IMediaFolder folder, GameParameters parameters, Stream icon, Stream background, string uniqueId)
{
this.GameType = gameType;
this.UniqueID = uniqueId;
this.Parameters = parameters;
this.Icon = icon;
this.Background = background;
this.Folder = folder;
}
private void RegisterFolderTree(IMediaFolder folder)
{
foreach (var f in folder.ChildFolders) {
RegisterPath(f);
RegisterFolderTree(f);
}
foreach (var i in folder.ChildItems) {
RegisterPath(i);
}
}
public override IMediaFolder Transform(IMediaFolder root)
{
if (filter == null)
{
return(root);
}
root = new VirtualClonedFolder(root);
ProcessFolder(root);
return(root);
}
private static void EatAll(IMediaFolder root, IMediaFolder folder)
{
foreach (var f in folder.ChildFolders.ToList())
{
EatAll(root, f);
}
foreach (var c in folder.ChildItems.ToList())
{
root.AddResource(c);
}
}
public override IMediaFolder Transform(IMediaFolder Root)
{
if (Root == null)
{
throw new ArgumentNullException("Root");
}
var rv = new VirtualFolder(null, Root.Title, Root.Id);
EatAll(rv, Root);
return(rv);
}
public IMediaItem Find(string path)
{
if (path.Length == 0)
{
return(this);
}
int slashIndex = path.IndexOfAny(new char[] { '/', '\\' });
if (slashIndex < 0)
{
if (path == ".")
{
return(this);
}
else if (path == "..")
{
return(_parent);
}
else
{
return(this[path]);
}
}
string localPath = path.Substring(0, slashIndex);
string subPath = path.Substring(slashIndex + 1);
if (localPath.Length == 0)
{
return(this.Find(subPath));
}
if (localPath == ".")
{
return(this.Find(subPath));
}
if (localPath == "..")
{
return(_parent.Find(subPath));
}
IMediaFolder local = this[localPath] as IMediaFolder;
if (local == null)
{
return(null);
}
if (subPath.Length == 0)
{
return(local);
}
return(local.Find(subPath));
}
private void ProcessFolder(IMediaFolder root)
{
foreach (var f in root.ChildFolders) {
ProcessFolder(f);
}
foreach (var f in root.ChildItems.ToList()) {
if (Allowed(f)) {
continue;
}
root.RemoveResource(f);
}
}
private void RegisterFolderTree(IMediaFolder folder)
{
foreach (var f in folder.ChildFolders)
{
RegisterPath(f);
RegisterFolderTree(f);
}
foreach (var i in folder.ChildItems)
{
RegisterPath(i);
}
}
private void ProcessFolder(IMediaFolder root)
{
foreach (var f in root.ChildFolders) {
ProcessFolder(f);
}
foreach (var f in root.ChildItems.ToList()) {
if (filter.IsMatch(f.Title)) {
continue;
}
root.RemoveResource(f);
}
}
private void CloneFolder(VirtualFolder parent, IMediaFolder folder)
{
foreach (var f in folder.ChildFolders) {
var vf = new VirtualFolder(parent, f.Title, f.Id);
parent.AdoptFolder(vf);
CloneFolder(vf, f);
}
foreach (var i in folder.ChildItems) {
if ((types & i.MediaType) == i.MediaType) {
parent.AddResource(i);
}
}
}
public override IMediaFolder Transform(IMediaFolder oldRoot)
{
var root = new VirtualClonedFolder(oldRoot);
var sorted = new SimpleKeyedVirtualFolder(root, Name);
SortFolder(root, sorted);
DebugFormat("sort {0} - {1}", sorted.ChildFolders.Count(), sorted.ChildItems.Count());
DebugFormat("root {0} - {1}", root.ChildFolders.Count(), root.ChildItems.Count());
foreach (var f in sorted.ChildFolders.ToList())
{
if (f.ChildCount < 2)
{
foreach (var file in f.ChildItems)
{
root.AddResource(file);
}
continue;
}
var fsmi = f as VirtualFolder;
root.AdoptFolder(fsmi);
}
foreach (var f in sorted.ChildItems.ToList())
{
root.AddResource(f);
}
DebugFormat("merg {0} - {1}", root.ChildFolders.Count(), root.ChildItems.Count());
MergeFolders(root, root);
DebugFormat("done {0} - {1}", root.ChildFolders.Count(), root.ChildItems.Count());
if (!cascade || root.ChildFolders.LongCount() <= 50)
{
return(root);
}
var cascaded = new DoubleKeyedVirtualFolder(root, "Series");
foreach (var i in root.ChildFolders.ToList())
{
var folder = cascaded.GetFolder(i.Title.StemCompareBase().Substring(0, 1).ToUpper());
folder.AdoptFolder(i);
}
foreach (var i in root.ChildItems.ToList())
{
var folder = cascaded.GetFolder(i.Title.StemCompareBase().Substring(0, 1).ToUpper());
folder.AddResource(i);
}
return(cascaded);
}
public bool CopyItem(string name, IMediaFolder destination)
{
if (destination.Device.IsReadOnly == true)
{
return(false);
}
IMediaItem item = this[name];
if (item == null)
{
return(false);
}
return(item.CopyTo(destination));
}
// SDK location: /user/pspiofilemgr.h:243
// SDK declaration: int sceIoChdir(const char *path);
public int sceIoChdir(int pathName)
{
string path = _kernel.ReadString(( uint )pathName);
IMediaFolder folder = ( IMediaFolder )_kernel.FindPath(path);
if (folder == null)
{
Log.WriteLine(Verbosity.Normal, Feature.Bios, "sceIoChdir: could not find path {0}", path);
return(-1);
}
_kernel.CurrentPath = folder;
return(0);
}
public static bool RecursiveSearchItem(this IMediaFolder master, string itemID)
{
if (master.ChildItems.Any(c => c.Id == itemID))
{
return(true);
}
foreach (var folder in master.ChildFolders)
{
if (folder.RecursiveSearchItem(itemID))
{
return(true);
}
}
return(false);
}
public void AdoptFolder(IMediaFolder folder)
{
if (folder == null)
{
throw new ArgumentNullException(nameof(folder));
}
var vf = folder.Parent as VirtualFolder;
vf?.ReleaseFolder(folder);
folder.Parent = this;
if (!Folders.Contains(folder))
{
Folders.Add(folder);
}
}
private void ProcessFolder(IMediaFolder root)
{
foreach (var f in root.ChildFolders)
{
ProcessFolder(f);
}
foreach (var f in root.ChildItems.ToList())
{
if (DoFilter(f))
{
continue;
}
root.RemoveResource(f);
}
}
private void ProcessFolder(IMediaFolder root)
{
foreach (var f in root.ChildFolders) {
ProcessFolder(f);
}
foreach (var f in root.ChildItems.ToList()) {
var i = f as IMetaInfo;
if (i == null) {
continue;
}
if (i.InfoSize.HasValue && i.InfoSize.Value >= minSize) {
continue;
}
root.RemoveResource(f);
}
}
public override IMediaFolder Transform(IMediaFolder Root)
{
var r = new VirtualClonedFolder(Root);
var cross = from f in r.ChildFolders
from t in r.ChildFolders
where f != t
orderby f.Title, t.Title
select new { f = f as VirtualFolder, t = t as VirtualFolder };
foreach (var c in cross) {
MergeFolders(c.f, c.t);
}
TransformInternal(r, r);
MergeFolders(r, r);
return r;
}
public override IMediaFolder Transform(IMediaFolder Root)
{
var root = new VirtualClonedFolder(Root);
var titles = new SimpleKeyedVirtualFolder(root, "titles");
SortFolder(root, titles);
foreach (var i in root.ChildFolders.ToList()) {
root.ReleaseFolder(i);
}
foreach (var i in titles.ChildFolders.ToList()) {
if (i.ChildCount > 100) {
ErrorFormat("Partioning folder {0}", i.Title);
PartitionChildren(i as VirtualFolder, new Prefixer());
}
root.AdoptFolder(i);
}
return root;
}
public override IMediaFolder Transform(IMediaFolder oldRoot)
{
var root = new VirtualClonedFolder(oldRoot);
var sorted = new SimpleKeyedVirtualFolder(root, Name);
SortFolder(root, sorted);
DebugFormat("sort {0} - {1}", sorted.ChildFolders.Count(), sorted.ChildItems.Count());
DebugFormat("root {0} - {1}", root.ChildFolders.Count(), root.ChildItems.Count());
foreach (var f in sorted.ChildFolders.ToList()) {
if (f.ChildCount < 2) {
foreach (var file in f.ChildItems) {
root.AddResource(file);
}
continue;
}
var fsmi = f as VirtualFolder;
root.AdoptFolder(fsmi);
}
foreach (var f in sorted.ChildItems.ToList()) {
root.AddResource(f);
}
DebugFormat("merg {0} - {1}", root.ChildFolders.Count(), root.ChildItems.Count());
MergeFolders(root, root);
DebugFormat("done {0} - {1}", root.ChildFolders.Count(), root.ChildItems.Count());
if (!cascade || root.ChildFolders.LongCount() <= 50) {
return root;
}
var cascaded = new DoubleKeyedVirtualFolder(root, "Series");
foreach (var i in root.ChildFolders.ToList()) {
var folder = cascaded.GetFolder(i.Title.StemCompareBase().Substring(0, 1).ToUpper());
folder.AdoptFolder(i);
}
foreach (var i in root.ChildItems.ToList()) {
var folder = cascaded.GetFolder(i.Title.StemCompareBase().Substring(0, 1).ToUpper());
folder.AddResource(i);
}
return cascaded;
}
private static void SortFolder(IMediaFolder folder,
SimpleKeyedVirtualFolder series)
{
foreach (var f in folder.ChildFolders.ToList()) {
SortFolder(f, series);
}
foreach (var i in folder.ChildItems.ToList()) {
var title = i.Title;
if (string.IsNullOrWhiteSpace(title)) {
continue;
}
var m = re_series.Match(title);
if (!m.Success) {
continue;
}
var ser = m.Groups[1].Value;
if (string.IsNullOrEmpty(ser)) {
continue;
}
series.GetFolder(ser.StemNameBase()).AddResource(i);
folder.RemoveResource(i);
}
}
public VirtualClonedFolder(IMediaFolder parent, string name, DlnaMediaTypes types)
: this(parent, name, name, types)
{
}
/// <summary>
/// Get <see cref="GameInformation"/> from the given EBOOT folder.
/// </summary>
/// <param name="folder">The folder containing the EBOOT.</param>
/// <returns>A <see cref="GameInformation"/> instance representing the game, or <c>null</c> if an error occurred.</returns>
public static GameInformation GetEbootGameInformation( IMediaFolder folder )
{
Debug.Assert( folder != null );
if( folder == null )
return null;
IMediaFile file = folder[ "EBOOT.PBP" ] as IMediaFile;
if( file == null )
return null;
using( Stream stream = file.OpenRead() )
{
PbpReader reader = new PbpReader( stream );
GameParameters gameParams;
using( Stream pdbStream = reader.Read( stream, PbpReader.PbpEntryType.Param ) )
gameParams = ReadSfo( pdbStream );
// Only accept games
if( ( gameParams.Category != GameCategory.MemoryStickGame ) &&
( gameParams.Category != GameCategory.UmdGame ) )
return null;
Stream icon = null;
Stream background = null;
if( reader.ContainsEntry( PbpReader.PbpEntryType.Icon0 ) == true )
icon = reader.Read( stream, PbpReader.PbpEntryType.Icon0 );
//if( reader.ContainsEntry( PbpReader.PbpEntryType.Pic1 ) == true )
// background = reader.Read( stream, PbpReader.PbpEntryType.Pic1 );
return new GameInformation( GameType.Eboot, folder, gameParams, icon, background, null );
}
}
internal GameInformation( GameType gameType, IMediaFolder folder, GameParameters parameters, Stream icon, Stream background, string uniqueId )
{
this.GameType = gameType;
this.UniqueID = uniqueId;
this.Parameters = parameters;
this.Icon = icon;
this.Background = background;
this.Folder = folder;
}
/// <summary>
/// Release the resources used by the current <see cref="GameInformation"/> instance.
/// </summary>
public void Dispose()
{
if( IgnoreDispose == true )
return;
if( this.DataPsp != null )
this.DataPsp.Dispose();
this.DataPsp = null;
if( this.Icon != null )
this.Icon.Dispose();
if( this.Background != null )
this.Background.Dispose();
this.Folder = null;
}
public VirtualFolder(IMediaFolder parent, string name, string id)
{
Parent = parent;
Id = id;
Name = name;
}
private FolderHierarchy GetFolderHierarchy(IMediaFolder root) {
Argument.ThrowIfNull(root, "root");
return new FolderHierarchy(root) {Children = _mediaLibraryService.GetMediaFolders(root.MediaPath).Select(GetFolderHierarchy)};
}
public void ReleaseFolder(IMediaFolder folder)
{
folders.Remove(folder);
}
public VirtualFolder(IMediaFolder parent, string name)
: this(parent, name, name)
{
}
public void Merge(IMediaFolder folder)
{
if (folder == null) {
throw new ArgumentNullException("folder");
}
merged.Add(folder);
foreach (var item in folder.ChildItems) {
AddResource(item);
}
foreach (var cf in folder.ChildFolders) {
var ownFolder = (from f in folders
where f is VirtualFolder && f.Title == cf.Title
select f as VirtualFolder
).FirstOrDefault();
if (ownFolder == null) {
ownFolder = new VirtualFolder(this, cf.Title, cf.Id);
AdoptFolder(ownFolder);
}
ownFolder.Merge(cf);
}
}
public void AdoptFolder(IMediaFolder folder)
{
if (folder == null) {
throw new ArgumentNullException("folder");
}
var vf = folder.Parent as VirtualFolder;
if (vf != null) {
vf.ReleaseFolder(folder);
}
folder.Parent = this;
if (!folders.Contains(folder)) {
folders.Add(folder);
}
}
private static void Browse_AddFolder(XmlDocument result, IMediaFolder f)
{
var meta = f as IMetaInfo;
var container = result.CreateElement(string.Empty, "container", NS_DIDL);
container.SetAttribute("restricted", "0");
container.SetAttribute("childCount", f.ChildCount.ToString());
container.SetAttribute("id", f.Id);
var parent = f.Parent;
container.SetAttribute("parentID", parent == null ? Identifiers.GENERAL_ROOT : parent.Id);
var title = result.CreateElement("dc", "title", NS_DC);
title.InnerText = f.Title;
container.AppendChild(title);
if (meta != null) {
var date = result.CreateElement("dc", "date", NS_DC);
date.InnerText = meta.InfoDate.ToString("o");
container.AppendChild(date);
}
var objectClass = result.CreateElement("upnp", "class", NS_UPNP);
objectClass.InnerText = "object.container";
container.AppendChild(objectClass);
result.DocumentElement?.AppendChild(container);
}
private int BrowseFolder_AddItems(IRequest request, XmlDocument result,
IMediaFolder root, int start,
int requested)
{
var provided = 0;
foreach (var i in root.ChildFolders) {
if (start > 0) {
start--;
continue;
}
Browse_AddFolder(result, i);
if (++provided == requested) {
break;
}
}
if (provided != requested) {
foreach (var i in root.ChildItems) {
if (start > 0) {
start--;
continue;
}
Browse_AddItem(request, result, i);
if (++provided == requested) {
break;
}
}
}
return provided;
}
public abstract IMediaFolder Transform(IMediaFolder root);
