internal AlbumBrowse(IntPtr albumBrowsePtr)
{
if(albumBrowsePtr == IntPtr.Zero)
throw new ArgumentException("albumBrowsePtr can not be zero");
lock(libspotify.Mutex)
{
IntPtr strPtr = IntPtr.Zero;
error = libspotify.sp_albumbrowse_error(albumBrowsePtr);
album = new Album(libspotify.sp_albumbrowse_album(albumBrowsePtr));
artist = new Artist(libspotify.sp_albumbrowse_artist(albumBrowsePtr));
copyrights = new string[libspotify.sp_albumbrowse_num_copyrights(albumBrowsePtr)];
for(int i = 0; i < copyrights.Length; i++)
{
strPtr = libspotify.sp_albumbrowse_copyright(albumBrowsePtr, i);
copyrights[i] = libspotify.GetString(strPtr, string.Empty);
}
tracks = new Track[libspotify.sp_albumbrowse_num_tracks(albumBrowsePtr)];
for(int i = 0; i < tracks.Length; i++)
{
IntPtr trackPtr = libspotify.sp_albumbrowse_track(albumBrowsePtr, i);
tracks[i] = new Track(trackPtr);
}
strPtr = libspotify.sp_albumbrowse_review(albumBrowsePtr);
review = libspotify.GetString(strPtr, string.Empty);
libspotify.sp_albumbrowse_release(albumBrowsePtr);
}
}
public void LoginResponseRetrieved(sp_error error)
{
Debug.WriteLine("Publishing login result.");
bool success = error == sp_error.SP_ERROR_OK;
_eventAggregator.Publish(new LoginResultMessage(success, error));
}
private static void StreamingErrorCallback(IntPtr sessionPtr, sp_error error)
{
Session s = GetSession(sessionPtr);
if (s == null)
{
return;
}
s.EnqueueEventWorkItem(new EventWorkItem(s.OnStreamingError, new object[] { s, new SessionEventArgs(error) }));
}
private Session(byte[] applicationKey, string cacheLocation, string settingsLocation, string userAgent)
{
libspotify.sp_session_config config = new libspotify.sp_session_config();
config.api_version = libspotify.SPOTIFY_API_VERSION;
config.cache_location = cacheLocation;
config.settings_location = settingsLocation;
config.user_agent = userAgent;
int size = Marshal.SizeOf(callbacks);
config.callbacks = Marshal.AllocHGlobal(size);
Marshal.StructureToPtr(callbacks, config.callbacks, true);
config.application_key = IntPtr.Zero;
try
{
config.application_key = Marshal.AllocHGlobal(applicationKey.Length);
Marshal.Copy(applicationKey, 0, config.application_key, applicationKey.Length);
lock (libspotify.Mutex)
config.application_key_size = applicationKey.Length;
sessionPtr = IntPtr.Zero;
sp_error res = libspotify.sp_session_init(ref config, out sessionPtr);
if (res != sp_error.OK)
{
throw new SpotifyException(res);
}
albumbrowse_complete_cb = new albumbrowse_complete_cb_delegate(AlbumBrowseCompleteCallback);
artistbrowse_complete_cb = new artistbrowse_complete_cb_delegate(ArtistBrowseCompleteCallback);
search_complete_cb = new search_complete_cb_delegate(SearchCompleteCallback);
image_loaded_cb = new image_loaded_cb_delegate(ImageLoadedCallback);
mainThread = new Thread(new ThreadStart(MainThread));
mainThread.IsBackground = true;
mainThread.Start();
eventThread = new Thread(new ThreadStart(EventThread));
eventThread.IsBackground = true;
eventThread.Start();
}
finally
{
if (config.application_key != IntPtr.Zero)
{
Marshal.FreeHGlobal(config.application_key);
}
}
}
private static void StreamingErrorCallback(IntPtr sessionPtr, sp_error error)
{
Session s = GetSession(sessionPtr);
if (s == null)
{
return;
}
s.EnqueueEventWorkItem(new EventWorkItem(CreateDelegate <SessionEventArgs>(se => se.OnStreamingError, s), new SessionEventArgs(error)));
}
internal void LogIn(string username, string password)
{
lock (libspotify.Mutex)
{
sp_error res = libspotify.sp_session_login(sessionPtr, username, password);
if (res != sp_error.OK)
{
throw new SpotifyException(res);
}
}
}
internal ArtistBrowse(IntPtr artistBrowsePtr)
{
if (artistBrowsePtr == IntPtr.Zero)
{
throw new ArgumentException("artistBrowsePtr can not be zero");
}
lock (libspotify.Mutex)
{
IntPtr strPtr = IntPtr.Zero;
error = libspotify.sp_artistbrowse_error(artistBrowsePtr);
artist = new Artist(libspotify.sp_artistbrowse_artist(artistBrowsePtr));
portraitIds = new List <string>(libspotify.sp_artistbrowse_num_portraits(artistBrowsePtr));
for (int i = 0; i < portraitIds.Count; i++)
{
IntPtr portraitIdPtr = libspotify.sp_artistbrowse_portrait(artistBrowsePtr, i);
byte[] portraitId = new byte[20];
Marshal.Copy(portraitIdPtr, portraitId, 0, portraitId.Length);
portraitIds.Add(libspotify.ImageIdToString(portraitId));
}
tracks = new Track[libspotify.sp_artistbrowse_num_tracks(artistBrowsePtr)];
for (int i = 0; i < tracks.Length; i++)
{
IntPtr trackPtr = libspotify.sp_artistbrowse_track(artistBrowsePtr, i);
tracks[i] = new Track(trackPtr);
}
albums = new Album[libspotify.sp_artistbrowse_num_albums(artistBrowsePtr)];
for (int i = 0; i < albums.Length; i++)
{
IntPtr albumPtr = libspotify.sp_artistbrowse_album(artistBrowsePtr, i);
albums[i] = new Album(albumPtr);
}
similarArtists = new Artist[libspotify.sp_artistbrowse_num_similar_artists(artistBrowsePtr)];
for (int i = 0; i < similarArtists.Length; i++)
{
IntPtr artistPtr = libspotify.sp_artistbrowse_similar_artist(artistBrowsePtr, i);
similarArtists[i] = new Artist(artistPtr);
}
strPtr = libspotify.sp_albumbrowse_review(artistBrowsePtr);
biography = libspotify.GetString(strPtr, string.Empty);
libspotify.sp_artistbrowse_release(artistBrowsePtr);
}
}
public sp_error RemoveTracks(int[] indices)
{
sp_error result = sp_error.INVALID_INDATA;
if (indices != null && indices.Length > 0)
{
lock (libspotify.Mutex)
{
result = libspotify.sp_playlist_remove_tracks(playlistPtr, indices, indices.Length);
}
}
return(result);
}
internal sp_error PlayerLoad(Track track)
{
PlayerUnload();
lock (libspotify.Mutex)
{
sp_error err = libspotify.sp_session_player_load(sessionPtr, track.trackPtr);
if (err == sp_error.OK)
{
track.CheckLoaded();
}
return(err);
}
}
internal void CheckLoaded()
{
CheckDisposed(true);
if (isLoaded)
{
return;
}
lock (libspotify.Mutex)
isLoaded = libspotify.sp_track_is_loaded(trackPtr);
if (!isLoaded)
{
return;
}
lock (libspotify.Mutex)
{
isAvailable = libspotify.sp_track_is_available(trackPtr);
error = libspotify.sp_track_error(trackPtr);
IntPtr albumPtr = libspotify.sp_track_album(trackPtr);
if (albumPtr != IntPtr.Zero)
{
album = new Album(albumPtr);
}
artists = new Artist[libspotify.sp_track_num_artists(trackPtr)];
for (int i = 0; i < artists.Length; i++)
{
artists[i] = new Artist(libspotify.sp_track_artist(trackPtr, i));
}
name = libspotify.GetString(libspotify.sp_track_name(trackPtr), string.Empty);
duration = libspotify.sp_track_duration(trackPtr);
popularity = libspotify.sp_track_popularity(trackPtr);
disc = libspotify.sp_track_disc(trackPtr);
index = libspotify.sp_track_index(trackPtr);
using (Link l = CreateLink(0))
{
linkString = l.ToString();
}
}
}
internal ArtistBrowse(IntPtr artistBrowsePtr)
{
if(artistBrowsePtr == IntPtr.Zero)
throw new ArgumentException("artistBrowsePtr can not be zero");
lock(libspotify.Mutex)
{
IntPtr strPtr = IntPtr.Zero;
error = libspotify.sp_artistbrowse_error(artistBrowsePtr);
artist = new Artist(libspotify.sp_artistbrowse_artist(artistBrowsePtr));
portraitIds = new List<string>(libspotify.sp_artistbrowse_num_portraits(artistBrowsePtr));
for(int i = 0; i < portraitIds.Count; i++)
{
IntPtr portraitIdPtr = libspotify.sp_artistbrowse_portrait(artistBrowsePtr, i);
byte[] portraitId = new byte[20];
Marshal.Copy(portraitIdPtr, portraitId, 0, portraitId.Length);
portraitIds.Add(libspotify.ImageIdToString(portraitId));
}
tracks = new Track[libspotify.sp_artistbrowse_num_tracks(artistBrowsePtr)];
for(int i = 0; i < tracks.Length; i++)
{
IntPtr trackPtr = libspotify.sp_artistbrowse_track(artistBrowsePtr, i);
tracks[i] = new Track(trackPtr);
}
albums = new Album[libspotify.sp_artistbrowse_num_albums(artistBrowsePtr)];
for(int i = 0; i < albums.Length; i++)
{
IntPtr albumPtr = libspotify.sp_artistbrowse_album(artistBrowsePtr, i);
albums[i] = new Album(albumPtr);
}
similarArtists = new Artist[libspotify.sp_artistbrowse_num_similar_artists(artistBrowsePtr)];
for(int i = 0; i < similarArtists.Length; i++)
{
IntPtr artistPtr = libspotify.sp_artistbrowse_similar_artist(artistBrowsePtr, i);
similarArtists[i] = new Artist(artistPtr);
}
strPtr = libspotify.sp_albumbrowse_review(artistBrowsePtr);
biography = libspotify.GetString(strPtr, string.Empty);
libspotify.sp_artistbrowse_release(artistBrowsePtr);
}
}
private static void LoggedInCallback(IntPtr sessionPtr, sp_error error)
{
Session s = GetSession(sessionPtr);
if (s == null)
{
return;
}
if ((s.ConnectionState == sp_connectionstate.LOGGED_IN || s.ConnectionState == sp_connectionstate.OFFLINE) && error == sp_error.OK)
{
s.playlistContainer = SpotifyLib.PlaylistContainer.Get(s, libspotify.sp_session_playlistcontainer(sessionPtr));
}
s.EnqueueEventWorkItem(new EventWorkItem(CreateDelegate <SessionEventArgs>(se => se.OnLoginComplete, s), new SessionEventArgs(error)));
}
public sp_error AddTracks(Track[] tracks, int position)
{
sp_error result = sp_error.INVALID_INDATA;
if (tracks != null && tracks.Length > 0)
{
lock (libspotify.Mutex)
{
IntPtr arrayPtr = IntPtr.Zero;
try
{
if (position < 0)
{
position = 0;
}
if (position > TrackCount)
{
position = TrackCount;
}
int[] array = new int[tracks.Length];
for (int i = 0; i < tracks.Length; i++)
{
array[i] = tracks[i].trackPtr.ToInt32();
}
int size = Marshal.SizeOf(arrayPtr) * array.Length;
arrayPtr = Marshal.AllocHGlobal(size);
Marshal.Copy(array, 0, arrayPtr, array.Length);
result = libspotify.sp_playlist_add_tracks(playlistPtr, arrayPtr, array.Length, position, owningSession.sessionPtr);
}
finally
{
if (arrayPtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(arrayPtr);
}
}
}
}
return(result);
}
internal Search(IntPtr searchPtr)
{
if (searchPtr == IntPtr.Zero)
{
throw new ArgumentException("searchPtr can not be zero");
}
this.searchPtr = searchPtr;
lock (libspotify.Mutex)
{
IntPtr strPtr = IntPtr.Zero;
error = libspotify.sp_search_error(searchPtr);
tracks = new Track[libspotify.sp_search_num_tracks(searchPtr)];
for (int i = 0; i < tracks.Length; i++)
{
IntPtr trackPtr = libspotify.sp_search_track(searchPtr, i);
tracks[i] = new Track(trackPtr);
}
albums = new Album[libspotify.sp_search_num_albums(searchPtr)];
for (int i = 0; i < albums.Length; i++)
{
IntPtr albumPtr = libspotify.sp_search_album(searchPtr, i);
albums[i] = new Album(albumPtr);
}
artists = new Artist[libspotify.sp_search_num_artists(searchPtr)];
for (int i = 0; i < artists.Length; i++)
{
IntPtr artistPtr = libspotify.sp_search_artist(searchPtr, i);
artists[i] = new Artist(artistPtr);
}
strPtr = libspotify.sp_search_query(searchPtr);
query = libspotify.GetString(strPtr, string.Empty);
strPtr = libspotify.sp_search_did_you_mean(searchPtr);
didYouMean = libspotify.GetString(strPtr, string.Empty);
totalTracks = libspotify.sp_search_total_tracks(searchPtr);
}
}
internal Search(IntPtr searchPtr)
{
if (searchPtr == IntPtr.Zero)
throw new ArgumentException("searchPtr can not be zero");
this.searchPtr = searchPtr;
lock (libspotify.Mutex)
{
IntPtr strPtr = IntPtr.Zero;
error = libspotify.sp_search_error(searchPtr);
tracks = new Track[libspotify.sp_search_num_tracks(searchPtr)];
for (int i = 0; i < tracks.Length; i++)
{
IntPtr trackPtr = libspotify.sp_search_track(searchPtr, i);
tracks[i] = new Track(trackPtr);
}
albums = new Album[libspotify.sp_search_num_albums(searchPtr)];
for (int i = 0; i < albums.Length; i++)
{
IntPtr albumPtr = libspotify.sp_search_album(searchPtr, i);
albums[i] = new Album(albumPtr);
}
artists = new Artist[libspotify.sp_search_num_artists(searchPtr)];
for (int i = 0; i < artists.Length; i++)
{
IntPtr artistPtr = libspotify.sp_search_artist(searchPtr, i);
artists[i] = new Artist(artistPtr);
}
strPtr = libspotify.sp_search_query(searchPtr);
query = libspotify.GetString(strPtr, string.Empty);
strPtr = libspotify.sp_search_did_you_mean(searchPtr);
didYouMean = libspotify.GetString(strPtr, string.Empty);
totalTracks = libspotify.sp_search_total_tracks(searchPtr);
}
}
internal void LogOut()
{
lock (libspotify.Mutex)
{
if (ConnectionState == sp_connectionstate.LOGGED_IN)
{
sp_error res = libspotify.sp_session_logout(sessionPtr);
if (res != sp_error.OK)
{
throw new SpotifyException(res);
}
}
else
{
EnqueueEventWorkItem(new EventWorkItem(OnLoggedOut, new object[] { this, new SessionEventArgs() }));
}
}
}
internal sp_error LogInSync(string username, string password, TimeSpan timeout)
{
lock (libspotify.Mutex)
{
if (loginHandle != null)
{
return(sp_error.IS_LOADING);
}
else
{
sp_error res = libspotify.sp_session_login(sessionPtr, username, password);
if (res != sp_error.OK)
{
return(res);
}
else
{
loginHandle = new ManualResetEvent(false);
}
}
}
bool signal = loginHandle.WaitOne(timeout, false);
if (loginHandle != null)
{
lock (libspotify.Mutex)
{
loginHandle.Close();
loginHandle = null;
}
}
if (signal)
{
return(loginResult);
}
else
{
return(sp_error.OTHER_TRANSIENT);
}
}
internal void StreamTrackAsync(Track track)
{
#if DEBUG
if (Log.IsDebugEnabled)
{
Log.Debug("StreamTrackAsync");
}
#endif
// Prepare to play the track.
#if DEBUG
if (Log.IsDebugEnabled)
{
Log.Debug("Playing track: " + track.Name);
}
#endif
// Configure the LAME MP3 encoder.
LameEncoder = new LameProgram(track);
// Reset the variable used to block until playback done.
_playbackDone.Reset();
// Load the track.
sp_error loadResult = Session.PlayerLoad(track);
#if DEBUG
if (Log.IsDebugEnabled)
{
Log.Debug("Load: " + loadResult);
}
#endif
// Play the track.
sp_error playResult = Session.PlayerPlay(true);
#if DEBUG
if (Log.IsDebugEnabled)
{
Log.Debug("Play: " + playResult);
}
#endif
}
internal sp_error MovePlaylist(Playlist playlist, int newPosition)
{
CheckDisposed(true);
sp_error result = sp_error.INVALID_INDATA;
int index = -1;
lock (libspotify.Mutex)
{
if (playlistIndexByPtr.TryGetValue(playlist.playlistPtr, out index))
{
if (!playlist.playlistPtr.Equals(playlists[index].playlistPtr))
{
throw new Exception("libspotify-sharp internal error, playlist position and pointer is inconsistent on move");
}
result = libspotify.sp_playlistcontainer_move_playlist(containerPtr, index, newPosition);
}
}
return(result);
}
public sp_error ReorderTracks(int[] indices, int newPosition)
{
sp_error result = sp_error.INVALID_INDATA;
if (indices != null && indices.Length > 0)
{
lock (libspotify.Mutex)
{
if (newPosition < 0)
{
newPosition = 0;
}
if (newPosition > TrackCount)
{
newPosition = TrackCount;
}
result = libspotify.sp_playlist_reorder_tracks(playlistPtr, indices, indices.Length, newPosition);
}
}
return(result);
}
private static void StreamingErrorCallback(IntPtr sessionPtr, sp_error error)
{
Session s = GetSession(sessionPtr);
if (s == null)
return;
s.EnqueueEventWorkItem(new EventWorkItem(s.OnStreamingError, new object[] { s, new SessionEventArgs(error) }));
}
private static void LoggedInCallback(IntPtr sessionPtr, sp_error error)
{
Session s = GetSession(sessionPtr);
if (s == null)
return;
if(s.ConnectionState == sp_connectionstate.LOGGED_IN && error == sp_error.OK)
s.playlistContainer = new PlaylistContainer(libspotify.sp_session_playlistcontainer(sessionPtr), s);
if (s.loginHandle == null)
s.EnqueueEventWorkItem(new EventWorkItem(s.OnLoginComplete, new object[] { s, new SessionEventArgs(error) }));
else
{
try
{
s.loginResult = error;
s.loginHandle.Set();
}
catch
{
}
}
}
internal static extern string sp_error_message(sp_error error);
void connection_error(sp_session *session, sp_error error);
private static void OfflineErrorCallback(IntPtr sessionPtr, sp_error error)
{
Session s = GetSession(sessionPtr);
// TODO: Implement
}
void logged_in(sp_session *session, sp_error error);
public SpotifyException(sp_error res)
{
// TODO: Complete member initialization
this.res = res;
}
public static extern IntPtr sp_error_message(sp_error error);
public SpotifyException(sp_error error)
{
this.error = error;
}
private void ConnectionErrorCallback(IntPtr sessionhandle, sp_error error)
{
Debug.WriteLine("There is an issue with the connection to Spotify servers.");
}
private void LoginCallback(IntPtr sessionHandle, sp_error error)
{
Debug.WriteLine("Login callback called.");
LoginResponseRetrieved(error);
}
public SpotifyException(sp_error res)
{
// TODO: Complete member initialization
this.res = res;
}
internal SpotifyException(sp_error error)
{
this.error = error;
}
public static extern string sp_error_message(sp_error error);
public static extern IntPtr sp_error_message(sp_error error);
public static extern string sp_error_message(sp_error error);
public LoginResultMessage(bool success, sp_error error)
{
Success = success;
Message = error;
}
void logged_in(sp_session* session, sp_error error);
internal SessionEventArgs(sp_error error)
{
this.error = error;
}
internal SpotifyException(sp_error error)
{
this.error = error;
}
void streaming_error(sp_session* session, sp_error error);
internal static extern string sp_error_message(sp_error error);
internal void CheckLoaded()
{
CheckDisposed(true);
if(isLoaded)
return;
lock(libspotify.Mutex)
isLoaded = libspotify.sp_track_is_loaded(trackPtr);
if(!isLoaded)
return;
lock(libspotify.Mutex)
{
isAvailable = libspotify.sp_track_is_available(trackPtr);
error = libspotify.sp_track_error(trackPtr);
IntPtr albumPtr = libspotify.sp_track_album(trackPtr);
if (albumPtr != IntPtr.Zero)
album = new Album(albumPtr);
artists = new Artist[libspotify.sp_track_num_artists(trackPtr)];
for(int i = 0; i < artists.Length; i++)
artists[i] = new Artist(libspotify.sp_track_artist(trackPtr, i));
name = libspotify.GetString(libspotify.sp_track_name(trackPtr), string.Empty);
duration = libspotify.sp_track_duration(trackPtr);
popularity = libspotify.sp_track_popularity(trackPtr);
disc = libspotify.sp_track_disc(trackPtr);
index = libspotify.sp_track_index(trackPtr);
using(Link l = CreateLink(0))
{
linkString = l.ToString();
}
}
}
public SpotifyException(sp_error error)
{
this.error = error;
}
internal SessionEventArgs(sp_error error)
{
this.error = error;
}
void connection_error(sp_session* session, sp_error error);
void streaming_error(sp_session *session, sp_error error);
