public static void PrintTrack(SpotifySession aSession, Track aTrack)
{
int duration = aTrack.Duration();
Console.Write(" {0} ", Track.IsStarred(aSession, aTrack) ? "*" : " ");
Console.Write("Track {0} [{1}:{2:D02}] has {3} artist(s), {4}% popularity",
aTrack.Name(),
duration / 60000,
(duration / 1000) % 60,
aTrack.NumArtists(),
aTrack.Popularity());
if (aTrack.Disc() != 0)
{
Console.Write(", {0} on disc {1}",
aTrack.Index(),
aTrack.Disc());
}
for (int i = 0; i < aTrack.NumArtists(); ++i)
{
var artist = aTrack.Artist(i);
Console.Write("\tArtist {0}: {1}", i + 1, artist.Name());
}
var link = Link.CreateFromTrack(aTrack, 0);
Console.WriteLine("\t\t{0}", link.AsString());
link.Release();
}
public static Image Create(SpotifySession session, ImageId image_id)
{
using (var id = image_id.Lock())
{
return(new Image(NativeMethods.sp_image_create(session._handle, id.Ptr)));
}
}
public static Image Create(SpotifySession session, ImageId image_id)
{
using (var id = image_id.Lock())
{
return new Image(NativeMethods.sp_image_create(session._handle, id.Ptr));
}
}
public static Inbox PostTracks(
SpotifySession session,
string username,
Track[] tracks,
string message,
InboxPostComplete callback,
object userdata)
{
using (var utf8_username = SpotifyMarshalling.StringToUtf8(username))
using (var utf8_message = SpotifyMarshalling.StringToUtf8(message))
using (var track_array = SpotifyMarshalling.ArrayToNativeArray(tracks.Select(x => x._handle).ToArray()))
{
IntPtr listenerToken = ListenerTable.PutUniqueObject(callback, userdata);
IntPtr ptr = NativeMethods.sp_inbox_post_tracks(
session._handle,
utf8_username.IntPtr,
track_array.IntPtr,
track_array.Length,
utf8_message.IntPtr,
InboxPostCompleteDelegate,
listenerToken);
Inbox search = InboxTable.GetUniqueObject(ptr);
search.ListenerToken = listenerToken;
return(search);
}
}
public static Inbox PostTracks(
SpotifySession session,
string username,
Track[] tracks,
string message,
InboxPostComplete callback,
object userdata)
{
using (var utf8_username = SpotifyMarshalling.StringToUtf8(username))
using (var utf8_message = SpotifyMarshalling.StringToUtf8(message))
using (var track_array = SpotifyMarshalling.ArrayToNativeArray(tracks.Select(x=>x._handle).ToArray()))
{
IntPtr listenerToken = ListenerTable.PutUniqueObject(callback, userdata);
IntPtr ptr = NativeMethods.sp_inbox_post_tracks(
session._handle,
utf8_username.IntPtr,
track_array.IntPtr,
track_array.Length,
utf8_message.IntPtr,
InboxPostCompleteDelegate,
listenerToken);
Inbox search = InboxTable.GetUniqueObject(ptr);
search.ListenerToken = listenerToken;
return search;
}
}
public Browser(SpotifySession aSession, IMetadataWaiter aMetadataWaiter, IConsoleReader aConsoleReader)
{
iSession = aSession;
iMetadataWaiter = aMetadataWaiter;
iConsoleReader = aConsoleReader;
iPlaylistListener = new BrowsingPlaylistListener(this);
}
public static AlbumBrowse Create(SpotifySession session, Album album, AlbumBrowseComplete callback, object userdata)
{
IntPtr listenerToken = ListenerTable.PutUniqueObject(callback, userdata);
IntPtr ptr = NativeMethods.sp_albumbrowse_create(session._handle, album._handle, AlbumBrowseCompleteDelegate, listenerToken);
AlbumBrowse browse = BrowseTable.GetUniqueObject(ptr);
browse.ListenerToken = listenerToken;
return browse;
}
public static ArtistBrowse Create(SpotifySession session, Artist artist, ArtistBrowseType type, ArtistBrowseComplete callback, object userdata)
{
IntPtr listenerToken = ListenerTable.PutUniqueObject(callback, userdata);
IntPtr ptr = NativeMethods.sp_artistbrowse_create(session._handle, artist._handle, type, ArtistBrowseCompleteDelegate, listenerToken);
ArtistBrowse browse = BrowseTable.GetUniqueObject(ptr);
browse.ListenerToken = listenerToken;
return(browse);
}
public static TopListBrowse Create(SpotifySession session, TopListType type, TopListRegion region, string username, TopListBrowseComplete callback, object userdata)
{
using (var utf8_username = SpotifyMarshalling.StringToUtf8(username))
{
IntPtr listenerToken = ListenerTable.PutUniqueObject(callback, userdata);
IntPtr ptr = NativeMethods.sp_toplistbrowse_create(session._handle, type, region, utf8_username.IntPtr, TopListBrowseCompleteDelegate, listenerToken);
TopListBrowse browse = BrowseTable.GetUniqueObject(ptr);
browse.ListenerToken = listenerToken;
return browse;
}
}
public static TopListBrowse Create(SpotifySession session, TopListType type, TopListRegion region, string username, TopListBrowseComplete callback, object userdata)
{
using (var utf8_username = SpotifyMarshalling.StringToUtf8(username))
{
IntPtr listenerToken = ListenerTable.PutUniqueObject(callback, userdata);
IntPtr ptr = NativeMethods.sp_toplistbrowse_create(session._handle, type, region, utf8_username.IntPtr, TopListBrowseCompleteDelegate, listenerToken);
TopListBrowse browse = BrowseTable.GetUniqueObject(ptr);
browse.ListenerToken = listenerToken;
return(browse);
}
}
//public static object GetSpotifyObject(IntPtr)
public static SpotifySession GetManagedSession(IntPtr aSessionPtr)
{
lock (iGlobalLock)
{
SpotifySession session;
if (iSpotifySessions.TryGetValue(aSessionPtr, out session))
{
return(session);
}
session = new SpotifySession(aSessionPtr);
iSpotifySessions[aSessionPtr] = session;
return(session);
}
}
public static void PrintAlbumBrowse(SpotifySession aSession, AlbumBrowse aResult)
{
Console.WriteLine("Album browse of \"{0}\" ({1})", aResult.Album().Name(), aResult.Album().Year());
for (int i = 0; i != aResult.NumCopyrights(); ++i)
{
Console.WriteLine(" Copyright: {0}", aResult.Copyright(i));
}
Console.WriteLine(" Tracks: {0}", aResult.NumTracks());
Console.WriteLine(" Review: {0}", Truncate(aResult.Review(), 60));
Console.WriteLine();
for (int i = 0; i != aResult.NumTracks(); ++i)
{
PrintTrack(aSession, aResult.Track(i));
}
Console.WriteLine();
}
public static void PrintArtistBrowse(SpotifySession aSession, ArtistBrowse aArtistBrowse)
{
Console.WriteLine("Artist browse of \"{0}\"", aArtistBrowse.Artist().Name());
for (int i = 0; i != aArtistBrowse.NumSimilarArtists(); ++i)
{
Console.WriteLine(" Similar artist: {0}", aArtistBrowse.SimilarArtist(i).Name());
}
Console.WriteLine(" Portraits: {0}", aArtistBrowse.NumPortraits());
Console.WriteLine(" Tracks: {0}", aArtistBrowse.NumTracks());
Console.WriteLine(" Biography: {0}", Truncate(aArtistBrowse.Biography(),60));
Console.WriteLine();
for (int i = 0; i != aArtistBrowse.NumTracks(); ++i)
{
PrintTrack(aSession, aArtistBrowse.Track(i));
}
Console.WriteLine();
}
public static Search Create(
SpotifySession session,
string query,
int trackOffset,
int trackCount,
int albumOffset,
int albumCount,
int artistOffset,
int artistCount,
int playlistOffset,
int playlistCount,
SearchType searchType,
SearchComplete callback,
object userdata)
{
using (var utf8_query = SpotifyMarshalling.StringToUtf8(query))
{
IntPtr listenerToken = ListenerTable.PutUniqueObject(callback, userdata);
IntPtr ptr = NativeMethods.sp_search_create(
session._handle,
utf8_query.IntPtr,
trackOffset,
trackCount,
albumOffset,
albumCount,
artistOffset,
artistCount,
playlistOffset,
playlistCount,
searchType,
SearchCompleteDelegate,
listenerToken);
Search search = SearchTable.GetUniqueObject(ptr);
search.ListenerToken = listenerToken;
return(search);
}
}
public static Search Create(
SpotifySession session,
string query,
int trackOffset,
int trackCount,
int albumOffset,
int albumCount,
int artistOffset,
int artistCount,
int playlistOffset,
int playlistCount,
SearchType searchType,
SearchComplete callback,
object userdata)
{
using (var utf8_query = SpotifyMarshalling.StringToUtf8(query))
{
IntPtr listenerToken = ListenerTable.PutUniqueObject(callback, userdata);
IntPtr ptr = NativeMethods.sp_search_create(
session._handle,
utf8_query.IntPtr,
trackOffset,
trackCount,
albumOffset,
albumCount,
artistOffset,
artistCount,
playlistOffset,
playlistCount,
searchType,
SearchCompleteDelegate,
listenerToken);
Search search = SearchTable.GetUniqueObject(ptr);
search.ListenerToken = listenerToken;
return search;
}
}
public virtual void PlayTokenLost(SpotifySession @session)
{
}
public virtual void NotifyMainThread(SpotifySession @session)
{
}
public virtual void ConnectionError(SpotifySession @session, SpotifyError @error)
{
}
public virtual void LoggedOut(SpotifySession @session)
{
}
/// <summary>
/// Create a SpotifySession, as per sp_session_create.
/// </summary>
/// <param name="config"></param>
/// <returns>
/// The SpotifySession. The caller is responsible for calling Dispose on
/// the session.
/// </returns>
public static SpotifySession Create(SpotifySessionConfig config)
{
IntPtr sessionPtr = IntPtr.Zero;
IntPtr listenerToken;
using (var cacheLocation = SpotifyMarshalling.StringToUtf8(config.CacheLocation))
using (var settingsLocation = SpotifyMarshalling.StringToUtf8(config.SettingsLocation))
using (var userAgent = SpotifyMarshalling.StringToUtf8(config.UserAgent))
using (var deviceId = SpotifyMarshalling.StringToUtf8(config.DeviceId))
using (var proxy = SpotifyMarshalling.StringToUtf8(config.Proxy))
using (var proxyUsername = SpotifyMarshalling.StringToUtf8(config.ProxyUsername))
using (var proxyPassword = SpotifyMarshalling.StringToUtf8(config.ProxyPassword))
#if SYSTEM_LINUX
// The field is Linux-only.
using (var caCertsFilename = SpotifyMarshalling.StringToUtf8(config.CACertsFilename))
#endif
using (var traceFile = SpotifyMarshalling.StringToUtf8(config.TraceFile))
{
IntPtr appKeyPtr = IntPtr.Zero;
listenerToken = ListenerTable.PutUniqueObject(config.Listener, config.UserData);
try
{
NativeCallbackAllocation.AddRef();
byte[] appkey = config.ApplicationKey;
appKeyPtr = Marshal.AllocHGlobal(appkey.Length);
Marshal.Copy(config.ApplicationKey, 0, appKeyPtr, appkey.Length);
sp_session_config nativeConfig = new sp_session_config {
api_version = config.ApiVersion,
cache_location = cacheLocation.IntPtr,
settings_location = settingsLocation.IntPtr,
application_key = appKeyPtr,
application_key_size = (UIntPtr)appkey.Length,
user_agent = userAgent.IntPtr,
callbacks = SessionDelegates.CallbacksPtr,
userdata = listenerToken,
compress_playlists = config.CompressPlaylists,
dont_save_metadata_for_playlists = config.DontSaveMetadataForPlaylists,
initially_unload_playlists = config.InitiallyUnloadPlaylists,
device_id = deviceId.IntPtr,
proxy = proxy.IntPtr,
proxy_username = proxyUsername.IntPtr,
proxy_password = proxyPassword.IntPtr,
#if SYSTEM_LINUX
// The ca_certs_filename field is Linux-only.
ca_certs_filename = caCertsFilename.IntPtr,
#endif
tracefile = traceFile.IntPtr,
};
// Note: sp_session_create will invoke a callback, so it's important that
// we have already done ListenerTable.PutUniqueObject before this point.
var error = NativeMethods.sp_session_create(ref nativeConfig, ref sessionPtr);
SpotifyMarshalling.CheckError(error);
}
catch
{
ListenerTable.ReleaseObject(listenerToken);
NativeCallbackAllocation.ReleaseRef();
throw;
}
finally
{
if (appKeyPtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(appKeyPtr);
}
}
}
SpotifySession session = SessionTable.GetUniqueObject(sessionPtr);
session.Listener = config.Listener;
session.UserData = config.UserData;
session.ListenerToken = listenerToken;
return(session);
}
public override void CredentialsBlobUpdated(SpotifySession session, string blob)
{
base.CredentialsBlobUpdated(session, blob);
}
public virtual void GetAudioBufferStats(SpotifySession @session, out AudioBufferStats @stats)
{
stats.samples = 0;
stats.stutter = 0;
}
public override void OfflineError(SpotifySession session, SpotifyError error)
{
base.OfflineError(session, error);
}
public override void MessageToUser(SpotifySession session, string message)
{
base.MessageToUser(session, message);
}
public override void LogMessage(SpotifySession session, string data)
{
Console.Write(data);
base.LogMessage(session, data);
}
public override void UserinfoUpdated(SpotifySession session)
{
base.UserinfoUpdated(session);
}
public override void MetadataUpdated(SpotifySession session)
{
base.MetadataUpdated(session);
}
public override void ConnectionstateUpdated(SpotifySession session)
{
if (session.Connectionstate() == ConnectionState.LoggedIn)
if (OnLoginResult != null)
OnLoginResult(true);
Console.WriteLine(session.Connectionstate().ToString());
base.ConnectionstateUpdated(session);
}
public virtual void EndOfTrack(SpotifySession @session)
{
}
public virtual void UserinfoUpdated(SpotifySession @session)
{
}
public override void LoggedOut(SpotifySession session)
{
base.LoggedOut(session);
}
public virtual void OfflineError(SpotifySession @session, SpotifyError @error)
{
}
public override void OfflineStatusUpdated(SpotifySession session)
{
base.OfflineStatusUpdated(session);
}
public override void NotifyMainThread(SpotifySession session)
{
InvokeProcessEvents();
base.NotifyMainThread(session);
}
public override void ScrobbleError(SpotifySession session, SpotifyError error)
{
base.ScrobbleError(session, error);
}
public virtual void LoggedIn(SpotifySession @session, SpotifyError @error)
{
}
public override void PrivateSessionModeChanged(SpotifySession session, bool is_private)
{
base.PrivateSessionModeChanged(session, is_private);
}
public virtual void MetadataUpdated(SpotifySession @session)
{
}
public override void GetAudioBufferStats(SpotifySession session, out AudioBufferStats stats)
{
base.GetAudioBufferStats(session, out stats);
}
public virtual void MessageToUser(SpotifySession @session, string @message)
{
}
public override int MusicDelivery(SpotifySession session, AudioFormat format, IntPtr frames, int num_frames)
{
try {
if (num_frames == 0)
return 0;
var size = num_frames * format.channels * 2;
var data = new byte[size];
Marshal.Copy(frames, data, 0, size);
wr.Write(data);
}
catch (Exception e) { }
if(OnDownloadProgress != null)
{
counter++;
var duration = downloadingTrack.Duration();
var process = (int)Math.Round((double)100 / duration * (46.4 * counter), 0);
OnDownloadProgress(process);
}
return num_frames;
// return base.MusicDelivery(session, format, frames, num_frames);
}
public virtual int MusicDelivery(SpotifySession @session, AudioFormat @format, IntPtr @frames, int @num_frames)
{
return(0);
}
public override void PlayTokenLost(SpotifySession session)
{
System.Windows.Forms.MessageBox.Show("Connection Lost");
base.PlayTokenLost(session);
}
public virtual void LogMessage(SpotifySession @session, string @data)
{
}
public override async void EndOfTrack(SpotifySession session)
{
session.PlayerPlay(false);
wr.Close();
// Move File
string album = downloadingTrack.Album().Name();
album = filterForFileName(album);
var dir = downloadPath + album + "\\";
if (!Directory.Exists(dir))
Directory.CreateDirectory(dir);
string song = GetTrackFullName(downloadingTrack);
song = filterForFileName(song);
var fileName = dir + song + ".mp3";
try
{
File.Move("downloading", fileName);
FileInfo fileInfo = new FileInfo(fileName);
String path = fileInfo.DirectoryName;
}
catch (Exception e) {
File.Delete("downloading");
LogString("Track deleted because the track already exists! Path: " + fileName + " Track Name:" + SpotifyDownloader.GetTrackFullName(downloadingTrack));
base.EndOfTrack(session);
if (OnDownloadProgress != null)
OnDownloadProgress(100);
if (OnDownloadComplete != null)
OnDownloadComplete();
return;
}
try
{
// Tag
var u = new UltraID3();
//u.GetMPEGTrackInfo();
u.Read(fileName);
u.Artist = GetTrackArtistsNames(downloadingTrack);
u.Title = downloadingTrack.Name();
u.Album = downloadingTrack.Album().Name();
var imageID = downloadingTrack.Album().Cover(ImageSize.Large);
var image = SpotifySharp.Image.Create(session, imageID);
await WaitForBool(image.IsLoaded);
var tc = TypeDescriptor.GetConverter(typeof(Bitmap));
var bmp = (Bitmap)tc.ConvertFrom(image.Data());
var pictureFrame = new ID3v23PictureFrame(bmp, PictureTypes.CoverFront, "image", TextEncodingTypes.ISO88591);
u.ID3v2Tag.Frames.Add(pictureFrame);
u.Write();
base.EndOfTrack(session);
}
catch (Exception e) { };
LogString("Track downloaded and saved! Path: " + fileName + " Track Name:" + SpotifyDownloader.GetTrackFullName(downloadingTrack));
if (OnDownloadProgress != null)
OnDownloadProgress(100);
if (OnDownloadComplete != null)
OnDownloadComplete();
}
public virtual void StreamingError(SpotifySession @session, SpotifyError @error)
{
}
public override async void LoggedIn(SpotifySession session, SpotifyError error)
{
base.LoggedIn(session, error);
await WaitForBool(session.User().IsLoaded);
session.PreferredBitrate(BitRate._320k);
}
public virtual void StopPlayback(SpotifySession @session)
{
}
public virtual void ConnectionstateUpdated(SpotifySession @session)
{
}
public virtual void OfflineStatusUpdated(SpotifySession @session)
{
}
public virtual void PrivateSessionModeChanged(SpotifySession @session, bool @is_private)
{
}
public virtual void CredentialsBlobUpdated(SpotifySession @session, string @blob)
{
}
public override void ConnectionError(SpotifySession session, SpotifyError error)
{
base.ConnectionError(session, error);
}
public virtual void ScrobbleError(SpotifySession @session, SpotifyError @error)
{
}
public Messaging(SpotifySession aSession, IConsoleReader aConsoleReader, Browser aBrowser)
{
iSession = aSession;
iConsoleReader = aConsoleReader;
iBrowser = aBrowser;
}
public override void StreamingError(SpotifySession session, SpotifyError error)
{
base.StreamingError(session, error);
}
public SpotifyDownloader()
{
if (!Directory.Exists(tmpPath))
Directory.CreateDirectory(tmpPath);
if (!Directory.Exists(downloadPath))
Directory.CreateDirectory(downloadPath);
var config = new SpotifySessionConfig()
{
ApiVersion = 12,
CacheLocation = tmpPath,
SettingsLocation = tmpPath,
ApplicationKey = File.ReadAllBytes("spotify_appkey.key"),
UserAgent = "downtify",
Listener = this
};
syncContext = SynchronizationContext.Current;
session = SpotifySession.Create(config);
Task.Factory.StartNew(() => InvokeProcessEvents());
}
