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 PlaylistManager(SpotifySession aSession, IConsoleReader aConsoleReader, Browser aBrowser)
{
iSession = aSession;
iConsoleReader = aConsoleReader;
iBrowser = aBrowser;
iCallbacks = new Callbacks(this);
}
public override int MusicDelivery(SpotifySession session, AudioFormat format, IntPtr frames, int num_frames)
{
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);
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 SpotifyDownloader()
{
tmpPath = Downtify.GUI.frmMain.configuration.GetConfiguration("cache", "cache/");
downloadPath = Downtify.GUI.frmMain.configuration.GetConfiguration("download", "download/");
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);
}
public static async Task <ApiClient> BuildApiClient([NotNull] SpotifySession session)
{
return(new ApiClient()
{
Home = await CreateAndRegister <IHome>(session),
Library = await CreateAndRegister <ILibrary>(session),
User = await CreateAndRegister <IUserService>(session),
Player = await CreateAndRegister <IPlayer>(session),
PathFinder = await CreateAndRegister <IPathFinder>(session),
Track = await CreateAndRegister <ITrack>(session),
Playlist = await CreateAndRegister <IPlaylist>(session),
PlaylistExtender = await CreateAndRegister <IPlaylistExtender>(session),
StorageResolve = await CreateAndRegister <IStorageResolveService>(session),
Metadata = await CreateAndRegister <IMetadata>(session),
ConnectState = await CreateAndRegister <IConnectState>(session),
Melody = await CreateAndRegister <IMelody>(session),
Follow = await CreateAndRegister <IFollow>(session),
Search = await CreateAndRegister <ISearch>(session),
Artist = await CreateAndRegister <IArtist>(session),
Album = await CreateAndRegister <IAlbum>(session),
OpenArtist = await CreateAndRegister <IOpenIArtist>(session),
SeekTableService = await CreateAndRegister <ISeektables>(session),
LicenseService = await CreateAndRegister <IPlaybackLicense>(session),
CanvazService = new CanvazService()
});
}
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);
}
private void Pause()
{
SpotifySession.PlayerPause();
isPaused = true;
player.Paused = true;
CF_setPlayPauseButton(true, _zone);
}
void PlaybackMonitor_Tick(object sender, EventArgs e)
{
if (currentTrack == null)
{
throw new Exception("Playback monitor started, but no track playing");
}
var position = player.Position + currentTrackPositionOffset;
var duration = currentTrack.Duration;
if (position >= duration)
{
this.ParentForm.BeginInvoke(new MethodInvoker(delegate()
{
if (!PlayNextTrack(false))
{
currentTrack = null;
SpotifySession.PlayerUnload();
PlaybackMonitor.Stop();
player.Stop();
isPaused = false;
currentTrackPositionOffset = new TimeSpan(0);
}
}));
}
}
public override int MusicDelivery(SpotifySession session, AudioFormat format, IntPtr frames, int num_frames)
{
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);
if (OnDownloadProgress != null)
{
counter++;
var duration = downloadingTrack.Duration();
// Todo: Find out how to calculate this correctly,
// so far 46.4 is used to calculate the process
// but there should be a way to calculate this
// with the given variables
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 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());
}
private void SeekCurrentTrack(int milliseconds)
{
player.Stop();
currentTrackPositionOffset = new TimeSpan(0, 0, 0, 0, milliseconds);
player.ReadyPlay();
SpotifySession.PlayerSeek(milliseconds);
}
public override async void LoggedIn(SpotifySession session, SpotifyError error)
{
base.LoggedIn(session, error);
await WaitForBool(session.User().IsLoaded);
session.PreferredBitrate(BitRate._320k);
}
public override void LogMessage(SpotifySession session, string data)
{
if (iLogToStderr)
{
Console.Error.WriteLine(data);
}
}
public Browser(SpotifySession aSession, IMetadataWaiter aMetadataWaiter, IConsoleReader aConsoleReader)
{
iSession = aSession;
iMetadataWaiter = aMetadataWaiter;
iConsoleReader = aConsoleReader;
iPlaylistListener = new BrowsingPlaylistListener(this);
}
private void Play()
{
player.ReadyPlay();
player.Paused = false;
SpotifySession.PlayerPlay();
isPaused = false;
CF_setPlayPauseButton(false, _zone);
}
private static async Task UpdateMelody([NotNull] SpotifySession _sess)
{
var time = await _sess.Api().Melody.GetTime();
var diff = time.timestamp - CurrentTimeMillisSystem();
Interlocked.Exchange(ref _offset, diff);
}
public void Dispose()
{
if (iSession != null)
{
iSession.Dispose();
}
iSession = null;
}
public void SetSpotifySession(string oneTimeCode, SpotifySession spotifySession)
{
memoryCache.Remove(oneTimeCode);
var cacheEntryOptions = new MemoryCacheEntryOptions()
.SetAbsoluteExpiration(tokenTimeout);
memoryCache.Set(oneTimeCode, spotifySession, cacheEntryOptions);
}
private void LoadImage(string imageId)
{
currentImageId = imageId;
CF_clearPictureImage("pictureBox");
if (currentImage != null)
{
currentImage.Dispose();
}
if (!string.IsNullOrEmpty(imageId))
{
ThreadPool.QueueUserWorkItem(delegate(object obj)
{
try
{
var image = SpotifySession.GetImageFromId(imageId);
image.WaitForLoaded(); //and it's not really loaded yet :(
if (imageId.Equals(currentImageId))
{
for (int i = 0; i < 60; i++)
{
if (image.Format == sp_imageformat.SP_IMAGE_FORMAT_UNKNOWN)
{
Thread.Sleep(1000);
}
else
{
break;
}
}
var imageObject = image.GetImage();
if (imageId.Equals(currentImageId))
{
imageObject = ResizeToFitBox(imageObject);
this.ParentForm.BeginInvoke(new MethodInvoker(delegate()
{
if (imageId.Equals(currentImageId))
{
currentImage = imageObject;
CF_setPictureImage("pictureBox", imageObject);
}
else
{
imageObject.Dispose();
}
}));
}
}
}
catch (Exception ex)
{
WriteError(ex);
}
});
}
}
public override void MetadataUpdated(SpotifySession session)
{
Action callbacks = iMetadataUpdatedCallbacks;
if (callbacks != null)
{
callbacks();
}
}
public void StopAllPlayback()
{
currentTrack = null;
SpotifySession.PlayerUnload();
isPaused = false;
currentTrackPositionOffset = new TimeSpan(0);
player.Stop();
PlaybackMonitor.Stop();
}
public static PagesLoader From([NotNull] SpotifySession session, [NotNull] String context)
{
var loader = new PagesLoader(session)
{
_resolveUrl = context
};
return(loader);
}
public override void ConnectionstateUpdated(SpotifySession session)
{
if (session.Connectionstate() == ConnectionState.LoggedIn)
{
OnLoginResult?.Invoke(true);
}
Console.WriteLine(session.Connectionstate().ToString());
base.ConnectionstateUpdated(session);
}
public override async void EndOfTrack(SpotifySession session)
{
session.PlayerPlay(false);
wr.Close();
// Move File
var dir = downloadPath + escape(downloadingTrack.Album().Name()) + "\\";
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
var fileName = dir + escape(GetTrackFullName(downloadingTrack)) + ".mp3";
if (GetDownloadType() == DownloadType.OVERWRITE && File.Exists(fileName))
{
File.Delete(fileName);
}
File.Move("downloading", fileName);
// Tag
var u = new UltraID3();
u.Read(fileName);
u.Artist = GetTrackArtistsNames(downloadingTrack);
u.Title = downloadingTrack.Name();
u.Album = downloadingTrack.Album().Name();
u.TrackNum = (short)downloadingTrack.Index();
u.Year = (short)downloadingTrack.Album().Year();
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);
if (OnDownloadProgress != null)
{
OnDownloadProgress(100);
}
if (OnDownloadComplete != null)
{
OnDownloadComplete(true);
}
}
public override int MusicDelivery(SpotifySession session, AudioFormat format, IntPtr frames, int num_frames)
{
if (MusicDataAvailable != null)
{
MusicDeliveryEventArgs args = new MusicDeliveryEventArgs(frames, num_frames, format.sample_rate, format.channels, 16);
MusicDataAvailable(this, args);
return(args.NumFramesRead);
}
return(0);
}
public override void PlayTokenLost(SpotifySession session)
{
if (_TrackDownloadService != null)
{
if (_TrackDownloadService.Active)
{
_TrackDownloadService.Cancel(TrackDownloadService.CancellationReason.PlayTokenLost);
}
}
}
public override async void LoggedIn(SpotifySession session, SpotifyError error)
{
if (error == SpotifyError.Ok)
{
await SpotifyObject.WaitForInitialization(session.User().IsLoaded);
_Session.PreferredBitrate(BitRate._320k);
}
_LoggedInCallback(error);
}
public SpotifyPlayer(SpotifySession session,
ISpotifyDevice device,
uint initialVolume,
int volumeSteps)
{
_session = session;
this.events = new EventsDispatcher(this);
Device = device;
InitState(initialVolume, volumeSteps);
Current = this;
}
public override void GetAudioBufferStats(SpotifySession session, out AudioBufferStats stats)
{
stats = new AudioBufferStats();
stats.samples = 0;
stats.stutter = 0;
if (CheckBuffer != null)
{
CheckBufferEventArgs args = new CheckBufferEventArgs();
CheckBuffer(this, args);
stats.samples = args.NumberOfSamples / 4;
}
}
public SpotifyPlayerSession([NotNull] SpotifySession session,
[NotNull] ISpotifyDevice sink,
[NotNull] String sessionId,
[NotNull] IPlayerSessionListener listener)
{
this.session = session;
this.sink = sink;
this.sessionId = sessionId;
this.listener = listener;
this.queue = new PlayerQueue();
Debug.WriteLine($"Created new session. id: {sessionId}");
//todo: clear sink
}