subsonic-csharp/SubsonicMono/SubsonicAPI/SubsonicAPI.cs

696 lines
27 KiB
C#
Raw Normal View History

2011-02-01 19:59:57 +00:00
/**************************************************************************
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
{
2011-02-26 02:43:38 +00:00
Folder, Song, Artist, Library, Playlist
2011-02-01 19:59:57 +00:00
}
2011-02-26 03:02:23 +00:00
2011-02-01 19:59:57 +00:00
public string name;
public string id;
2011-02-26 03:02:23 +00:00
public string lastModified;
public string lastAccessed;
2011-02-01 19:59:57 +00:00
public SubsonicItemType itemType;
2011-02-26 03:02:23 +00:00
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();
}
2011-02-01 19:59:57 +00:00
public override string ToString()
{
return name;
}
2011-02-26 03:02:23 +00:00
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;
}
2011-02-01 19:59:57 +00:00
}
#endregion Classes
/// <summary>
/// Open Source C# Implementation of the Subsonic API
/// http://www.subsonic.org/pages/api.jsp
/// </summary>
public static class Subsonic
{
2011-02-26 03:02:23 +00:00
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;
}
}
2011-02-01 19:59:57 +00:00
// 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;
2011-02-26 03:02:23 +00:00
// Used for generating direct URLS
static string encPass;
static string username;
2011-02-01 19:59:57 +00:00
/// <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));
2011-02-26 03:02:23 +00:00
// 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");
2011-02-01 19:59:57 +00:00
Stream theStream = MakeGenericRequest("ping", null);
StreamReader sr = new StreamReader(theStream);
result = sr.ReadToEnd();
/// TODO: Parse the result and determine if logged in or not
2011-02-26 03:02:23 +00:00
_MyLibrary = new SubsonicItem("LibraryRoot", "-1", SubsonicItem.SubsonicItemType.Library, null);
2011-02-01 19:59:57 +00:00
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;
}
2011-02-26 03:02:23 +00:00
/// <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;
2011-02-01 19:59:57 +00:00
if (parameters != null)
{
foreach (KeyValuePair<string, string> parameter in parameters)
{
callURL += "&" + parameter.Key + "=" + parameter.Value;
}
}
return callURL;
2011-02-26 03:02:23 +00:00
}
/// <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);
}
2011-02-01 19:59:57 +00:00
2011-02-26 03:02:23 +00:00
// Load the parameters if provided
2011-02-01 19:59:57 +00:00
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);
2011-02-26 03:02:23 +00:00
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;
}
2011-02-01 19:59:57 +00:00
/// <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)
{
2011-02-26 03:02:23 +00:00
// Load the parameters if provided
2011-02-01 19:59:57 +00:00
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>();
2011-02-26 03:02:23 +00:00
if (myXML.ChildNodes[1].Name == "subsonic-response")
2011-02-01 19:59:57 +00:00
{
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;
}
2011-02-26 03:02:23 +00:00
public static List<SubsonicItem> GetIndexes(string musicFolderId)
2011-02-01 19:59:57 +00:00
{
2011-02-26 03:02:23 +00:00
return GetIndexes(musicFolderId, "");
}
public static List<SubsonicItem> GetIndexes()
2011-02-01 19:59:57 +00:00
{
2011-02-26 03:02:23 +00:00
return GetIndexes("", "");
}
2011-02-01 19:59:57 +00:00
/// <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;
}
2011-02-26 03:02:23 +00:00
public static Stream StreamSong(string id)
2011-02-01 19:59:57 +00:00
{
2011-02-26 03:02:23 +00:00
return StreamSong(id, null);
}
2011-02-01 19:59:57 +00:00
/// <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")
{
2011-02-26 03:02:23 +00:00
SubsonicItem theParent = new SubsonicItem();
2011-02-01 19:59:57 +00:00
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;
2011-02-26 03:02:23 +00:00
SubsonicItem theItem = new SubsonicItem(title, theId, (isDir ? SubsonicItem.SubsonicItemType.Folder : SubsonicItem.SubsonicItemType.Song), theParent);
theContents.Add(theItem);
2011-02-01 19:59:57 +00:00
}
}
}
return theContents;
}
2011-02-26 03:02:23 +00:00
/// <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);
}
2011-02-01 19:59:57 +00:00
// 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);
2011-02-26 03:02:23 +00:00
List<SubsonicItem> searchResults = new List<SubsonicItem>();
// Parse the artist
if (myXML.ChildNodes[1].Name == "subsonic-response")
2011-02-01 19:59:57 +00:00
{
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;
2011-02-26 03:02:23 +00:00
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);
2011-02-01 19:59:57 +00:00
searchResults.Add(theItem);
}
}
}
2011-02-26 03:02:23 +00:00
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;
}
2011-02-01 19:59:57 +00:00
}
2011-02-26 03:02:23 +00:00
}