mirror of
https://github.com/ViViDboarder/subsonic-csharp.git
synced 2024-11-15 01:46:28 +00:00
696 lines
27 KiB
C#
696 lines
27 KiB
C#
/**************************************************************************
|
|
Subsonic Csharp
|
|
Copyright (C) 2010 Ian Fijolek
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
**************************************************************************/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.Net;
|
|
using System.IO;
|
|
using System.Xml;
|
|
|
|
namespace SubsonicAPI
|
|
{
|
|
#region Classes
|
|
|
|
public class SubsonicItem
|
|
{
|
|
public enum SubsonicItemType
|
|
{
|
|
Folder, Song, Artist, Library, Playlist
|
|
}
|
|
|
|
public string name;
|
|
public string id;
|
|
public string lastModified;
|
|
public string lastAccessed;
|
|
public SubsonicItemType itemType;
|
|
public SubsonicItem parent;
|
|
private List<SubsonicItem> _children;
|
|
|
|
public List<SubsonicItem> children
|
|
{
|
|
get
|
|
{
|
|
if (_children == null)
|
|
{
|
|
if (this.itemType == SubsonicItemType.Song)
|
|
_children = null;
|
|
else
|
|
_children = Subsonic.GetItemChildren(this, "");
|
|
}
|
|
return _children;
|
|
}
|
|
set
|
|
{
|
|
_children = value;
|
|
}
|
|
}
|
|
|
|
public SubsonicItem()
|
|
{
|
|
this.name = "";
|
|
this.id = "";
|
|
this.lastAccessed = DateTime.Now.ToString();
|
|
}
|
|
|
|
public SubsonicItem(string name, string id)
|
|
{
|
|
this.name = name;
|
|
this.id = name;
|
|
this.lastAccessed = DateTime.Now.ToString();
|
|
}
|
|
|
|
public SubsonicItem(string name, string id, SubsonicItemType itemType, SubsonicItem parent)
|
|
{
|
|
this.name = name;
|
|
this.id = id;
|
|
this.itemType = itemType;
|
|
this.parent = parent;
|
|
this.lastAccessed = DateTime.Now.ToString();
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return name;
|
|
}
|
|
|
|
public SubsonicItem FindItemById(string id)
|
|
{
|
|
SubsonicItem foundItem = null;
|
|
|
|
// If the current item is the item we are looking for, return it
|
|
if (this.id == id)
|
|
foundItem = this;
|
|
// Otherwise, we check the children if they exist
|
|
else if (_children != null)
|
|
{
|
|
foreach(SubsonicItem child in _children)
|
|
{
|
|
// If this child is the item we are looking for, return it
|
|
if (child.id == id)
|
|
{
|
|
foundItem = child;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
foundItem = child.FindItemById(id);
|
|
if (foundItem != null)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return foundItem;
|
|
}
|
|
|
|
public SubsonicItem GetChildByName(string childName)
|
|
{
|
|
SubsonicItem theItem = null;
|
|
|
|
if (_children != null)
|
|
{
|
|
theItem = _children.Find(
|
|
delegate(SubsonicItem itm)
|
|
{
|
|
return itm.name == childName ;
|
|
}
|
|
);
|
|
}
|
|
|
|
return theItem;
|
|
}
|
|
}
|
|
|
|
public class Song : SubsonicItem
|
|
{
|
|
public string artist;
|
|
public string album;
|
|
public string title;
|
|
|
|
public Song()
|
|
{
|
|
this.artist = "";
|
|
this.title = "";
|
|
this.album = "";
|
|
this.name = "";
|
|
this.id = "";
|
|
this.itemType = SubsonicItem.SubsonicItemType.Song;
|
|
this.parent = null;
|
|
this.lastAccessed = DateTime.Now.ToString();
|
|
}
|
|
|
|
public Song(string title,string artist, string album, string id)
|
|
{
|
|
this.artist = artist;
|
|
this.title = title;
|
|
this.album = album;
|
|
this.name = title;
|
|
this.id = id;
|
|
this.itemType = SubsonicItem.SubsonicItemType.Song;
|
|
this.parent = null;
|
|
this.lastAccessed = DateTime.Now.ToString();
|
|
}
|
|
|
|
public Song(string title, string artist, string album, string id, SubsonicItem parent)
|
|
{
|
|
this.artist = artist;
|
|
this.title = title;
|
|
this.album = album;
|
|
this.name = title;
|
|
this.id = id;
|
|
this.itemType = SubsonicItem.SubsonicItemType.Song;
|
|
this.parent = parent;
|
|
this.lastAccessed = DateTime.Now.ToString();
|
|
}
|
|
|
|
public Stream getStream()
|
|
{
|
|
return Subsonic.StreamSong(this.id);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return artist + " - " + title;
|
|
}
|
|
}
|
|
|
|
#endregion Classes
|
|
|
|
/// <summary>
|
|
/// Open Source C# Implementation of the Subsonic API
|
|
/// http://www.subsonic.org/pages/api.jsp
|
|
/// </summary>
|
|
public static class Subsonic
|
|
{
|
|
private static SubsonicItem _MyLibrary;
|
|
|
|
/// <summary>
|
|
/// Public Property that can be used for auto-retrieving children
|
|
/// </summary>
|
|
public static SubsonicItem MyLibrary
|
|
{
|
|
get
|
|
{
|
|
return _MyLibrary;
|
|
}
|
|
set
|
|
{
|
|
_MyLibrary = value;
|
|
}
|
|
}
|
|
|
|
// Should be set from application layer when the application is loaded
|
|
public static string appName;
|
|
|
|
// Min version of the REST API implemented
|
|
private static string apiVersion = "1.3.0";
|
|
|
|
// Set with the login method
|
|
static string server;
|
|
static string authHeader;
|
|
|
|
// Used for generating direct URLS
|
|
static string encPass;
|
|
static string username;
|
|
|
|
/// <summary>
|
|
/// Takes parameters for server, username and password to generate an auth header
|
|
/// and Pings the server
|
|
/// </summary>
|
|
/// <param name="theServer"></param>
|
|
/// <param name="user"></param>
|
|
/// <param name="password"></param>
|
|
/// <returns>Resulting XML (Future boolean)</returns>
|
|
public static string LogIn(string theServer, string user, string password)
|
|
{
|
|
string result = "Nothing Happened";
|
|
|
|
server = theServer;
|
|
authHeader = user + ":" + password;
|
|
authHeader = Convert.ToBase64String(Encoding.Default.GetBytes(authHeader));
|
|
|
|
// Store user and encoded password for alternate authentication
|
|
username = user;
|
|
Byte[] passwordBytes = Encoding.Default.GetBytes(password);
|
|
for (int i = 0; i < passwordBytes.Length; i++)
|
|
encPass += passwordBytes[i].ToString("x2");
|
|
|
|
Stream theStream = MakeGenericRequest("ping", null);
|
|
|
|
StreamReader sr = new StreamReader(theStream);
|
|
|
|
result = sr.ReadToEnd();
|
|
|
|
/// TODO: Parse the result and determine if logged in or not
|
|
|
|
_MyLibrary = new SubsonicItem("LibraryRoot", "-1", SubsonicItem.SubsonicItemType.Library, null);
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Uses the Auth Header for logged in user to make an HTTP request to the server
|
|
/// with the given Subsonic API method and parameters
|
|
/// </summary>
|
|
/// <param name="method"></param>
|
|
/// <param name="parameters"></param>
|
|
/// <returns>Datastream of the server response</returns>
|
|
public static Stream MakeGenericRequest(string method, Dictionary<string, string> parameters)
|
|
{
|
|
// Check to see if Logged In yet
|
|
if (string.IsNullOrEmpty(authHeader))
|
|
{
|
|
// Throw a Not Logged In exception
|
|
Exception e = new Exception("No Authorization header. Must Log In first");
|
|
return null;
|
|
}
|
|
else
|
|
{
|
|
if (!method.EndsWith(".view"))
|
|
method += ".view";
|
|
|
|
string requestURL = BuildRequestURL(method, parameters);
|
|
|
|
WebRequest theRequest = WebRequest.Create(requestURL);
|
|
theRequest.Method = "GET";
|
|
|
|
theRequest.Headers["Authorization"] = "Basic " + authHeader;
|
|
|
|
WebResponse response = theRequest.GetResponse();
|
|
|
|
Stream dataStream = response.GetResponseStream();
|
|
|
|
return dataStream;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a URL for a request but does not make the actual request using set login credentials an dmethod and parameters
|
|
/// </summary>
|
|
/// <param name="method"></param>
|
|
/// <param name="parameters"></param>
|
|
/// <returns>Proper Subsonic API URL for a request</returns>
|
|
public static string BuildRequestURL(string method, Dictionary<string, string> parameters)
|
|
{
|
|
string requestURL = "http://" + server + "/rest/" + method + "?v=" + apiVersion + "&c=" + appName;
|
|
if (parameters != null)
|
|
{
|
|
foreach (KeyValuePair<string, string> parameter in parameters)
|
|
{
|
|
requestURL += "&" + parameter.Key + "=" + parameter.Value;
|
|
}
|
|
}
|
|
return requestURL;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a URL for a command with username and encoded pass in the URL
|
|
/// </summary>
|
|
/// <param name="method"></param>
|
|
/// <param name="parameters"></param>
|
|
/// <returns>URL for streaming a song or retrieving the results of a call</returns>
|
|
public static string BuildDirectURL(string method, Dictionary<string, string> parameters)
|
|
{
|
|
string callURL = "http://" + server + "/rest/" + method + "?v=" + apiVersion + "&c=" + appName
|
|
+ "&u=" + username + "&p=enc:" + encPass;
|
|
if (parameters != null)
|
|
{
|
|
foreach (KeyValuePair<string, string> parameter in parameters)
|
|
{
|
|
callURL += "&" + parameter.Key + "=" + parameter.Value;
|
|
}
|
|
}
|
|
return callURL;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a list of SubsonicItems that fall inside the parent object
|
|
/// </summary>
|
|
/// <param name="parent">
|
|
/// A <see cref="SubsonicItem"/>
|
|
/// </param>
|
|
/// <param name="ifModifiedSince">
|
|
/// A <see cref="System.String"/>
|
|
/// </param>
|
|
/// <returns>
|
|
/// A <see cref="List<SubsonicItem>"/>
|
|
/// </returns>
|
|
public static List<SubsonicItem> GetItemChildren(SubsonicItem parent, string ifModifiedSince)
|
|
{
|
|
Dictionary<string, string> parameters = new Dictionary<string, string>();
|
|
|
|
// Generate the proper request for the parent type
|
|
string requestType, musicFolderId;
|
|
if (parent.itemType == SubsonicItem.SubsonicItemType.Library)
|
|
{
|
|
requestType = "getIndexes";
|
|
if (parent.id != "-1")
|
|
parameters.Add("musicFolderId", parent.id);
|
|
}
|
|
else
|
|
{
|
|
requestType = "getMusicDirectory";
|
|
parameters.Add("id", parent.id);
|
|
}
|
|
|
|
// Load the parameters if provided
|
|
if (!string.IsNullOrEmpty(ifModifiedSince))
|
|
parameters.Add("ifModifiedSince", ifModifiedSince);
|
|
|
|
// Make the request
|
|
Stream theStream = MakeGenericRequest(requestType, parameters);
|
|
// Read the response as a string
|
|
StreamReader sr = new StreamReader(theStream);
|
|
string result = sr.ReadToEnd();
|
|
|
|
// Parse the resulting XML string into an XmlDocument
|
|
XmlDocument myXML = new XmlDocument();
|
|
myXML.LoadXml(result);
|
|
|
|
List<SubsonicItem> children = new List<SubsonicItem>();
|
|
|
|
// Parse the artist
|
|
if (parent.itemType == SubsonicItem.SubsonicItemType.Library)
|
|
{
|
|
if (myXML.ChildNodes[1].Name == "subsonic-response")
|
|
{
|
|
if (myXML.ChildNodes[1].FirstChild.Name == "indexes")
|
|
{
|
|
for (int i = 0; i < myXML.ChildNodes[1].FirstChild.ChildNodes.Count; i++)
|
|
{
|
|
for (int j = 0; j < myXML.ChildNodes[1].FirstChild.ChildNodes[i].ChildNodes.Count; j++)
|
|
{
|
|
string artist = myXML.ChildNodes[1].FirstChild.ChildNodes[i].ChildNodes[j].Attributes["name"].Value;
|
|
string id = myXML.ChildNodes[1].FirstChild.ChildNodes[i].ChildNodes[j].Attributes["id"].Value;
|
|
|
|
children.Add(new SubsonicItem(artist, id, SubsonicItem.SubsonicItemType.Folder, parent));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Parse the directory
|
|
else if (parent.itemType == SubsonicItem.SubsonicItemType.Folder)
|
|
{
|
|
if (myXML.ChildNodes[1].Name == "subsonic-response")
|
|
{
|
|
if (myXML.ChildNodes[1].FirstChild.Name == "directory")
|
|
{
|
|
for (int i = 0; i < myXML.ChildNodes[1].FirstChild.ChildNodes.Count; i++)
|
|
{
|
|
bool isDir = bool.Parse(myXML.ChildNodes[1].FirstChild.ChildNodes[i].Attributes["isDir"].Value);
|
|
string title = myXML.ChildNodes[1].FirstChild.ChildNodes[i].Attributes["title"].Value;
|
|
string id = myXML.ChildNodes[1].FirstChild.ChildNodes[i].Attributes["id"].Value;
|
|
|
|
SubsonicItem theItem = new SubsonicItem(title, id, (isDir ? SubsonicItem.SubsonicItemType.Folder : SubsonicItem.SubsonicItemType.Song), parent);
|
|
children.Add(theItem);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return children;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns an indexed structure of all artists.
|
|
/// </summary>
|
|
/// <param name="parent">Required: No; If specified, only return artists in the music folder with the given ID.</param>
|
|
/// <param name="ifModifiedSince">Required: No; If specified, only return a result if the artist collection has changed since the given time.</param>
|
|
/// <returns>Dictionary, Key = Artist and Value = id</returns>
|
|
public static List<SubsonicItem> GetIndexes(string musicFolderId, string ifModifiedSince)
|
|
{
|
|
// Load the parameters if provided
|
|
Dictionary<string, string> parameters = new Dictionary<string, string>();
|
|
if (!string.IsNullOrEmpty(musicFolderId))
|
|
parameters.Add("musicFolderId", musicFolderId);
|
|
|
|
if (!string.IsNullOrEmpty(ifModifiedSince))
|
|
parameters.Add("ifModifiedSince", ifModifiedSince);
|
|
|
|
// Make the request
|
|
Stream theStream = MakeGenericRequest("getIndexes", parameters);
|
|
// Read the response as a string
|
|
StreamReader sr = new StreamReader(theStream);
|
|
string result = sr.ReadToEnd();
|
|
|
|
// Parse the resulting XML string into an XmlDocument
|
|
XmlDocument myXML = new XmlDocument();
|
|
myXML.LoadXml(result);
|
|
|
|
// Parse the XML document into a List
|
|
List<SubsonicItem> artists = new List<SubsonicItem>();
|
|
if (myXML.ChildNodes[1].Name == "subsonic-response")
|
|
{
|
|
if (myXML.ChildNodes[1].FirstChild.Name == "indexes")
|
|
{
|
|
int i = 0;
|
|
for (i = 0; i < myXML.ChildNodes[1].FirstChild.ChildNodes.Count; i++)
|
|
{
|
|
int j = 0;
|
|
for (j = 0; j < myXML.ChildNodes[1].FirstChild.ChildNodes[i].ChildNodes.Count; j++)
|
|
{
|
|
string artist = myXML.ChildNodes[1].FirstChild.ChildNodes[i].ChildNodes[j].Attributes["name"].Value;
|
|
string id = myXML.ChildNodes[1].FirstChild.ChildNodes[i].ChildNodes[j].Attributes["id"].Value;
|
|
|
|
artists.Add(new SubsonicItem(artist, id));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return artists;
|
|
}
|
|
|
|
public static List<SubsonicItem> GetIndexes(string musicFolderId)
|
|
{
|
|
return GetIndexes(musicFolderId, "");
|
|
}
|
|
|
|
public static List<SubsonicItem> GetIndexes()
|
|
{
|
|
return GetIndexes("", "");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Streams a given music file. (Renamed from request name "stream")
|
|
/// </summary>
|
|
/// <param name="id">Required: Yes; A string which uniquely identifies the file to stream.
|
|
/// Obtained by calls to getMusicDirectory.</param>
|
|
/// <param name="maxBitRate">Required: No; If specified, the server will attempt to
|
|
/// limit the bitrate to this value, in kilobits per second. If set to zero, no limit
|
|
/// is imposed. Legal values are: 0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256 and 320. </param>
|
|
/// <returns></returns>
|
|
public static Stream StreamSong(string id, int? maxBitRate)
|
|
{
|
|
// Reades the id of the song and sets it as a parameter
|
|
Dictionary<string, string> theParameters = new Dictionary<string,string>();
|
|
theParameters.Add("id", id);
|
|
if (maxBitRate.HasValue)
|
|
theParameters.Add("maxBitRate", maxBitRate.ToString());
|
|
|
|
// Makes the request
|
|
Stream theStream = MakeGenericRequest("stream", theParameters);
|
|
|
|
return theStream;
|
|
}
|
|
|
|
public static Stream StreamSong(string id)
|
|
{
|
|
return StreamSong(id, null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a listing of all files in a music directory. Typically used to get list of albums for an artist, or list of songs for an album.
|
|
/// </summary>
|
|
/// <param name="id">A string which uniquely identifies the music folder. Obtained by calls to getIndexes or getMusicDirectory.</param>
|
|
/// <returns>MusicFolder object containing info for the specified directory</returns>
|
|
public static List<SubsonicItem> GetMusicDirectory(string id)
|
|
{
|
|
Dictionary<string, string> theParameters = new Dictionary<string, string>();
|
|
theParameters.Add("id", id);
|
|
Stream theStream = MakeGenericRequest("getMusicDirectory", theParameters);
|
|
|
|
StreamReader sr = new StreamReader(theStream);
|
|
|
|
string result = sr.ReadToEnd();
|
|
|
|
XmlDocument myXML = new XmlDocument();
|
|
myXML.LoadXml(result);
|
|
|
|
List<SubsonicItem> theContents = new List<SubsonicItem>();
|
|
|
|
if (myXML.ChildNodes[1].Name == "subsonic-response")
|
|
{
|
|
if (myXML.ChildNodes[1].FirstChild.Name == "directory")
|
|
{
|
|
SubsonicItem theParent = new SubsonicItem();
|
|
theParent.name = myXML.ChildNodes[1].FirstChild.Attributes["name"].Value;
|
|
theParent.id = myXML.ChildNodes[1].FirstChild.Attributes["id"].Value;
|
|
|
|
int i = 0;
|
|
for (i = 0; i < myXML.ChildNodes[1].FirstChild.ChildNodes.Count; i++)
|
|
{
|
|
bool isDir = bool.Parse(myXML.ChildNodes[1].FirstChild.ChildNodes[i].Attributes["isDir"].Value);
|
|
string title = myXML.ChildNodes[1].FirstChild.ChildNodes[i].Attributes["title"].Value;
|
|
string theId = myXML.ChildNodes[1].FirstChild.ChildNodes[i].Attributes["id"].Value;
|
|
|
|
SubsonicItem theItem = new SubsonicItem(title, theId, (isDir ? SubsonicItem.SubsonicItemType.Folder : SubsonicItem.SubsonicItemType.Song), theParent);
|
|
theContents.Add(theItem);
|
|
}
|
|
}
|
|
}
|
|
|
|
return theContents;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns what is currently being played by all users. Takes no extra parameters.
|
|
/// </summary>
|
|
public static List<SubsonicItem> GetNowPlaying()
|
|
{
|
|
List<SubsonicItem> nowPlaying = new List<SubsonicItem>();
|
|
|
|
Dictionary<string, string> theParameters = new Dictionary<string, string>();
|
|
Stream theStream = MakeGenericRequest("getNowPlaying", theParameters);
|
|
StreamReader sr = new StreamReader(theStream);
|
|
string result = sr.ReadToEnd();
|
|
|
|
/// TODO: Parse result to list
|
|
|
|
return nowPlaying;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Performs a search valid for the current version of the subsonic server
|
|
/// If version is >= 1.4.0 search2
|
|
/// Else search
|
|
/// </summary>
|
|
/// <param name="query">The Term you want to search for</param>
|
|
/// <returns>A List of SubsonicItem objects</returns>
|
|
public static List<SubsonicItem> Search(string query)
|
|
{
|
|
Dictionary<string, string> parameters = new Dictionary<string, string>();
|
|
Version apiV = new Version(apiVersion);
|
|
Version Search2Min = new Version("1.4.0");
|
|
string request = "";
|
|
// Use search for the server version
|
|
if (apiV >= Search2Min)
|
|
{
|
|
request = "search2";
|
|
parameters.Add("query", query);
|
|
}
|
|
else
|
|
{
|
|
request = "search";
|
|
parameters.Add("any", query);
|
|
}
|
|
|
|
// Make the request
|
|
Stream theStream = MakeGenericRequest(request, parameters);
|
|
// Read the response as a string
|
|
StreamReader sr = new StreamReader(theStream);
|
|
string result = sr.ReadToEnd();
|
|
|
|
// Parse the resulting XML string into an XmlDocument
|
|
XmlDocument myXML = new XmlDocument();
|
|
myXML.LoadXml(result);
|
|
|
|
List<SubsonicItem> searchResults = new List<SubsonicItem>();
|
|
|
|
// Parse the artist
|
|
if (myXML.ChildNodes[1].Name == "subsonic-response")
|
|
{
|
|
if (myXML.ChildNodes[1].FirstChild.Name == "searchResult")
|
|
{
|
|
for (int i = 0; i < myXML.ChildNodes[1].FirstChild.ChildNodes.Count; i++)
|
|
{
|
|
bool isDir = bool.Parse(myXML.ChildNodes[1].FirstChild.ChildNodes[i].Attributes["isDir"].Value);
|
|
string title = myXML.ChildNodes[1].FirstChild.ChildNodes[i].Attributes["title"].Value;
|
|
string theId = myXML.ChildNodes[1].FirstChild.ChildNodes[i].Attributes["id"].Value;
|
|
string artist = "";
|
|
string album = "";
|
|
|
|
if (!isDir)
|
|
{
|
|
artist = myXML.ChildNodes[1].FirstChild.ChildNodes[i].Attributes["artist"].Value;
|
|
album = myXML.ChildNodes[1].FirstChild.ChildNodes[i].Attributes["album"].Value;
|
|
}
|
|
|
|
SubsonicItem theItem;
|
|
if (isDir)
|
|
theItem = new SubsonicItem(title, theId, SubsonicItem.SubsonicItemType.Folder, null);
|
|
else
|
|
theItem = new Song(title, artist, album, theId);
|
|
|
|
searchResults.Add(theItem);
|
|
}
|
|
}
|
|
}
|
|
|
|
return searchResults;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a list of all playlists on server
|
|
/// </summary>
|
|
public static List<SubsonicItem> GetPlaylists()
|
|
{
|
|
List<SubsonicItem> playlists = new List<SubsonicItem>();
|
|
|
|
Dictionary<string, string> theParameters = new Dictionary<string, string>();
|
|
Stream theStream = MakeGenericRequest("getPlaylists", theParameters);
|
|
StreamReader sr = new StreamReader(theStream);
|
|
string result = sr.ReadToEnd();
|
|
|
|
/// TODO: Parse result into list
|
|
|
|
return playlists;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a list of all SubsonicItems in playlist of given ID
|
|
/// </summary>
|
|
/// <param name="playlistId">
|
|
/// ID of playlist to be fetched [retreive from GetPlaylists()]
|
|
/// </param>
|
|
/// <returns>
|
|
/// Returns list of SubsonicItems
|
|
/// </returns>
|
|
public static List<SubsonicItem> GetPlaylist(string playlistId)
|
|
{
|
|
List<SubsonicItem> playlist = new List<SubsonicItem>();
|
|
|
|
Dictionary<string, string> theParameters = new Dictionary<string, string>();
|
|
theParameters.Add("id", playlistId);
|
|
Stream theStream = MakeGenericRequest("getPlaylist", theParameters);
|
|
StreamReader sr = new StreamReader(theStream);
|
|
string result = sr.ReadToEnd();
|
|
|
|
/// TODO: Parse result into list
|
|
|
|
return playlist;
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|