public static void Stop(iTunesAppClass itunes)
{
itunes.Stop();
itunes.Quit();
Directory.Delete(ApplicationSettings.TempPath, true);
}
public void Convert()
{
iTunesAppClass itunes = new iTunesAppClass();
IITEncoderCollection encoders = itunes.Encoders;
IITEncoder mp3Encoder = null;
foreach (IITEncoder encoder in encoders)
{
Console.WriteLine(String.Format(
"Encoder: [{0}] format=[{1}]", encoder.Name, encoder.Format));
if (encoder.Format.Equals("MP3"))
{
mp3Encoder = encoder;
}
}
if (mp3Encoder != null)
{
object track = itunes.LibraryPlaylist.Tracks.get_ItemByName("A Horse with No Name");
itunes.CurrentEncoder = mp3Encoder;
iTunesConvertOperationStatus status = itunes.ConvertTrack2(ref track);
status.OnConvertOperationCompleteEvent +=
new _IITConvertOperationStatusEvents_OnConvertOperationCompleteEventEventHandler(
status_OnConvertOperationCompleteEvent);
status.OnConvertOperationStatusChangedEvent +=
new _IITConvertOperationStatusEvents_OnConvertOperationStatusChangedEventEventHandler(
status_OnConvertOperationStatusChangedEvent);
reset = new ManualResetEvent(false);
reset.WaitOne();
}
}
public static void SetUp(iTunesAppClass itunes)
{
// Check for artwork folder
var artwork = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Artwork\\");
if (!Directory.Exists(artwork))
{
Directory.CreateDirectory(artwork);
}
ApplicationSettings.ArtworkFolder = artwork;
// Check for fanart folder
var fanart = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Fanart\\");
if (!Directory.Exists(fanart))
{
Directory.CreateDirectory(fanart);
}
ApplicationSettings.FanArtFolder = fanart;
// Check for temp folder
var temp = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Temp\\");
if (!Directory.Exists(temp))
{
Directory.CreateDirectory(temp);
}
ApplicationSettings.TempPath = temp;
// Automatically Add to Itunes folder
ApplicationSettings.iTunesAddFolder = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyMusic), "iTunes\\iTunes Media\\Automatically Add to iTunes");
// Set up track change
itunes.OnPlayerPlayEvent += itunes_OnPlayerPlayEvent;
}
private static IITPlaylist GetLibraryPlaylist()
{
IITPlaylist libraryPlaylist = null;
IiTunes iTunes = new iTunesAppClass();
IITSource librarySource = null;
foreach (IITSource source in iTunes.Sources)
{
if (source.Kind == ITSourceKind.ITSourceKindLibrary)
{
librarySource = source;
break;
}
}
if (librarySource != null)
{
foreach (IITPlaylist pl in librarySource.Playlists)
{
if (pl.Kind == ITPlaylistKind.ITPlaylistKindLibrary)
{
libraryPlaylist = pl;
break;
}
}
}
return libraryPlaylist;
}
static void iTunes_Mute(Options options)
{
try {
iTunesAppClass itunes = new iTunesAppClass();
itunes.Mute = !itunes.Mute;
} catch (Exception e) {
}
}
/// <summary>
/// Release our iTunes related resources
/// </summary>
public void Release()
{
if (this.iTunesApp != null)
{
//System.Runtime.InteropServices.Marshal.ReleaseComObject(this.iTunesApp);
this.iTunesApp = null;
}
}
public iTunesService()
{
iTunes = new iTunesAppClass();
Library = iTunes.LibraryPlaylist;
Tracks = Library.Tracks;
TrackIdFileMap = new Dictionary <int, string>();
iTunesFingerprints = new List <TrackFingerprint>();
iTunesTracks = new List <Track>();
}
public static void MyClassCleanup()
{
Console.WriteLine("**** Unit test shutdown");
if (itunes != null)
{
itunes = null;
}
}
private void KillITunes()
{
if (_itunes == null)
{
return;
}
_itunes = null;
GC.Collect();
}
private IITFileOrCDTrack GetITTFileOrCDTrackFromWorkingTrack(WorkingTrack wt)
{
iTunes = new iTunesAppClass();
mainLibrary = iTunes.LibraryPlaylist;
tracks = mainLibrary.Tracks;
IITFileOrCDTrack track = tracks[wt.Position.Value] as IITFileOrCDTrack;
return(track);
}
private void FindDeadTracks()
{
//create a reference to iTunes
iTunesAppClass iTunes = new iTunesAppClass();
//get a reference to the collection of all tracks
IITTrackCollection tracks = iTunes.LibraryPlaylist.Tracks;
int trackCount = tracks.Count;
int numberChecked = 0;
int numberDeadFound = 0;
//setup the progress control
this.SetupProgress(trackCount);
for (int i = trackCount; i > 0; i--)
{
if (!this._shouldStop)
{
IITTrack track = tracks[i];
numberChecked++;
this.IncrementProgress();
this.UpdateLabel("Checking track # " + numberChecked.ToString() + " - " + track.Name);
if (track.Kind == ITTrackKind.ITTrackKindFile)
{
IITFileOrCDTrack fileTrack = (IITFileOrCDTrack)track;
//if the file doesn't exist, we'll delete it from iTunes
if (fileTrack.Location == String.Empty)
{
numberDeadFound++;
this.AddTrackToList(fileTrack);
if (this.checkBoxRemove.Checked)
{
fileTrack.Delete();
}
}
else if (!System.IO.File.Exists(fileTrack.Location))
{
numberDeadFound++;
this.AddTrackToList(fileTrack);
if (this.checkBoxRemove.Checked)
{
fileTrack.Delete();
}
}
}
}
}
this.UpdateLabel("Checked " + numberChecked.ToString() + " tracks and " + numberDeadFound.ToString() + " dead tracks found.");
this.SetupProgress(1);
}
public void DumpPlaylists()
{
iTunesAppClass itunes = new iTunesAppClass();
IITPlaylistCollection playlists = itunes.LibrarySource.Playlists;
foreach (IITPlaylist playlist in playlists)
{
if (playlist.Kind == ITPlaylistKind.ITPlaylistKindUser)
{
IITUserPlaylist ulist = (IITUserPlaylist)playlist;
Console.WriteLine(String.Format(
"[{0}:{1}] {2} - Kind:{3}, Visible:{4}, Smart:{5}, {6}",
ulist.Index, ulist.playlistID,
ulist.Name, ulist.Kind.ToString(), ulist.Visible,
ulist.Smart, ulist.SpecialKind
));
}
else
{
Console.WriteLine(String.Format(
"[{0}:{1}] {2} - Kind:{3}, Visible:{4}",
playlist.Index, playlist.playlistID,
playlist.Name, playlist.Kind.ToString(), playlist.Visible
));
}
}
Console.WriteLine();
Console.WriteLine("Filtered:");
Console.WriteLine();
foreach (IITPlaylist playlist in playlists)
{
if ((playlist.Kind != ITPlaylistKind.ITPlaylistKindUser) ||
playlist.Name.Equals("Genius"))
{
continue;
}
IITUserPlaylist ulist = (IITUserPlaylist)playlist;
if ((ulist.SpecialKind == ITUserPlaylistSpecialKind.ITUserPlaylistSpecialKindNone) ||
(ulist.SpecialKind == ITUserPlaylistSpecialKind.ITUserPlaylistSpecialKindPurchases) ||
(ulist.SpecialKind == ITUserPlaylistSpecialKind.ITUserPlaylistSpecialKindFolder))
{
Console.WriteLine(ulist.Name);
}
}
itunes.Quit();
Marshal.ReleaseComObject(itunes);
itunes = null;
}
public iTunesPlayer()
{
#if DEBUG
Console.WriteLine("Registering iTunes...");
#endif
iTunes = new iTunesAppClass();
this.RegisterEvents();
#if DEBUG
Console.WriteLine("Done registering");
#endif
}
//========================================================================================
// Constructors
//========================================================================================
/// <summary>
/// Initialize class static fields.
/// </summary>
static Interaction()
{
enabledEvent = new _IiTunesEvents_OnCOMCallsEnabledEventEventHandler(DoEnabledEvent);
disabledEvent = new _IiTunesEvents_OnCOMCallsDisabledEventEventHandler(DoDisabledEvent);
itunes = new iTunesAppClass();
itunes.OnCOMCallsEnabledEvent += enabledEvent;
itunes.OnCOMCallsDisabledEvent += disabledEvent;
reset = new ManualResetEvent(true);
}
public void DumpPlaylists()
{
iTunesAppClass itunes = new iTunesAppClass();
IITPlaylistCollection playlists = itunes.LibrarySource.Playlists;
foreach (IITPlaylist playlist in playlists)
{
if (playlist.Kind == ITPlaylistKind.ITPlaylistKindUser)
{
IITUserPlaylist ulist = (IITUserPlaylist)playlist;
Console.WriteLine(String.Format(
"[{0}:{1}] {2} - Kind:{3}, Visible:{4}, Smart:{5}, {6}",
ulist.Index, ulist.playlistID,
ulist.Name, ulist.Kind.ToString(), ulist.Visible,
ulist.Smart, ulist.SpecialKind
));
}
else
{
Console.WriteLine(String.Format(
"[{0}:{1}] {2} - Kind:{3}, Visible:{4}",
playlist.Index, playlist.playlistID,
playlist.Name, playlist.Kind.ToString(), playlist.Visible
));
}
}
Console.WriteLine();
Console.WriteLine("Filtered:");
Console.WriteLine();
foreach (IITPlaylist playlist in playlists)
{
if ((playlist.Kind != ITPlaylistKind.ITPlaylistKindUser) ||
playlist.Name.Equals("Genius"))
{
continue;
}
IITUserPlaylist ulist = (IITUserPlaylist)playlist;
if ((ulist.SpecialKind == ITUserPlaylistSpecialKind.ITUserPlaylistSpecialKindNone) ||
(ulist.SpecialKind == ITUserPlaylistSpecialKind.ITUserPlaylistSpecialKindPurchases) ||
(ulist.SpecialKind == ITUserPlaylistSpecialKind.ITUserPlaylistSpecialKindFolder))
{
Console.WriteLine(ulist.Name);
}
}
itunes.Quit();
Marshal.ReleaseComObject(itunes);
itunes = null;
}
private void TryToSendToITunes()
{
progressLabel.Content = "Attempting to send to iTunes";
try {
iTunesApp iTunesApp = new iTunesAppClass();
iTunesApp.LibraryPlaylist.AddFile(this.converter.OutputFileName);
}
catch (Exception) {
MessageBox.Show("Sorry, could not send to iTunes.");
}
}
static void Main(string[] args)
{
// Only allow one instance
bool amITheFirstInstance;
Mutex m = new Mutex(true, "#iSongShow_Mutex#", out amITheFirstInstance);
if (!amITheFirstInstance)
{
MessageBox.Show("iSongShow is already running!", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
// Die painfully if iTunes isn't installed
iTunesApp app;
try
{
app = new iTunesAppClass();
}
catch (Exception)
{
MessageBox.Show("Unable to create instance of iTunesAppClass. Maybe iTunes isn't installed?", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
// Run!
try
{
SettingsForm settingsForm = new SettingsForm();
app.OnPlayerPlayEvent += new
iTunesLib._IiTunesEvents_OnPlayerPlayEventEventHandler(OnPlayEvent);
// Yes, the sole purpose of this code is to reduce the apparent memory usage as reported
// by task manager. Maybe this way I'll get fewer complaints about the supposedly large
// memory footprint of .NET apps. *Sigh*
SetProcessWorkingSetSize(System.Diagnostics.Process.GetCurrentProcess().Handle, -1, -1);
Application.Run();
}
catch (Exception e)
{
MessageBox.Show("Something that wasn't supposed to happen did: " + e.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
finally
{
app.OnPlayerPlayEvent -= new
iTunesLib._IiTunesEvents_OnPlayerPlayEventEventHandler(OnPlayEvent);
}
}
private void btnAddLyrics_Click(object sender, System.EventArgs e)
{
string sUrl = (string) lsvSearchResults.SelectedItems[0].Tag;
LyricsFairySearcher pSearcher = new LyricsFairySearcher();
string sLyrics = pSearcher.GetLyrics(sUrl);
IiTunes piTunesApp = new iTunesAppClass();
IITFileOrCDTrack pTrack = (IITFileOrCDTrack) piTunesApp.SelectedTracks[1];
pTrack.Lyrics = sLyrics;
}
public static IITTrack GetTrackById(this iTunesAppClass itunes, int id)
{
foreach (IITTrack t in itunes.LibraryPlaylist.Tracks)
{
if (t.TrackDatabaseID == id)
{
return(t);
}
}
return(null);
}
private void NewITunesAppClass()
{
_itunes = new iTunesAppClass();
_itunes.OnQuittingEvent += () => {
Close();
Application.Exit();
};
_itunes.OnAboutToPromptUserToQuitEvent += () => {
Close();
Application.Exit();
};
}
public static void iTunesExport(string FilePath)
{
iTunesAppClass iTunes = new iTunesAppClass();
//iTunesApp iTunes = new iTunesApp();
IITLibraryPlaylist Tracks = iTunes.LibraryPlaylist;
var AddVideo = Tracks.AddFile(FilePath);
do
{
} while (AddVideo.InProgress == true);
Marshal.FinalReleaseComObject(iTunes);
}
public Song GetCurrentPlayingSong()
{
try
{
iTunesApp app = new iTunesAppClass();
IITTrack track = app.CurrentTrack;
return new Song(track.Artist, track.Name);
}
catch (Exception e)
{
return new Song("Error Loading Track Infromation");
}
}
public static List <IITFileOrCDTrack> GetAlbumTracks(this iTunesAppClass itunes, string album)
{
var tracks = new List <IITFileOrCDTrack>();
foreach (IITTrack t in itunes.LibraryPlaylist.Tracks)
{
if (t.Album != null && t.Album.Equals(album, StringComparison.InvariantCultureIgnoreCase))
{
tracks.Add((IITFileOrCDTrack)t);
}
}
return(tracks);
}
public Song GetCurrentPlayingSong()
{
try
{
iTunesApp app = new iTunesAppClass();
IITTrack track = app.CurrentTrack;
return(new Song(track.Artist, track.Name));
}
catch (Exception e)
{
return(new Song("Error Loading Track Infromation"));
}
}
private void ChangeTrackLocation()
{
//create a reference to iTunes
var iTunes = new iTunesAppClass();
//get a reference to the collection of all tracks
IITTrackCollection tracks = iTunes.LibraryPlaylist.Tracks;
int trackCount = tracks.Count;
int numberChecked = 0;
int numberRelocateFound = 0;
//setup the progress control
SetupProgress(trackCount);
for (int i = trackCount; i > 0; i--)
{
if (!_shouldStop)
{
IITTrack track = tracks[i];
numberChecked++;
IncrementProgress();
UpdateLabel("Relocating track # " + numberChecked.ToString(CultureInfo.InvariantCulture) + " - " + track.Name);
if (track.Kind == ITTrackKind.ITTrackKindFile)
{
var fileTrack = (IITFileOrCDTrack)track;
//if the file matches our old location
if (fileTrack.Location != null && fileTrack.Location.StartsWith(txtLocationOld.Text))
{
//check if file exists in the new location
var newLocation = fileTrack.Location.Replace(txtLocationOld.Text, txtLocationNew.Text);
if (System.IO.File.Exists(newLocation))
{
numberRelocateFound++;
AddTrackToList(fileTrack);
if (checkBoxRelocate.Checked)
{
fileTrack.Location = newLocation;
}
}
}
}
}
}
this.UpdateLabel("Checked " + numberChecked.ToString() + " tracks and " + numberRelocateFound.ToString() + " relocate tracks found.");
this.SetupProgress(1);
}
public IEnumerable <string> Handle(string input, Match match, IListener listener)
{
var itunes = new iTunesAppClass();
switch (itunes.PlayerState)
{
case ITPlayerState.ITPlayerStatePlaying:
itunes.Stop();
yield return("Music paused.");
break;
case ITPlayerState.ITPlayerStateStopped:
yield return("Would you like me to play something specific or just continue?");
Brain.Pipe.ListenNext((s, match1, listener1) =>
{
if (s == "continue")
{
listener1.Output("Playing " + itunes.CurrentTrack.Name + " by " + itunes.CurrentTrack.Artist);
itunes.Play();
}
foreach (IITPlaylist playlist in itunes.LibrarySource.Playlists)
{
if (!playlist.Name.ToLower().Contains(s))
{
continue;
}
playlist.PlayFirstTrack();
listener1.Output("Playing playlist " + playlist.Name);
return;
}
foreach (IITTrack track in itunes.LibraryPlaylist.Tracks)
{
if (!track.Name.ToLower().Contains(s) && !track.Artist.ToLower().Contains(s))
{
continue;
}
track.Play();
listener1.Output("Playing " + track.Name + " by " + track.Artist);
return;
}
}, ".+");
break;
}
yield return("");
}
public SimilarArtistController(SimilarArtistView view)
{
model = new LastFMModel();
itunes = new iTunesAppClass();
libraryPlaylist = itunes.LibraryPlaylist;
similarArtists = new Queue<string>();
artistTrackCount = new Dictionary<string, int>();
artistTracks = new Dictionary<string, Queue<string>>();
missingTracks = new List<string>();
playlistSize = 0;
this.view = view;
}
public static void MyClassCleanup()
{
Console.WriteLine("**** Unit test shutdown");
if (itunes != null)
{
itunes = null;
}
if (controller != null)
{
controller.Dispose();
controller = null;
}
}
public static void Start(iTunesAppClass itunes)
{
SetUp(itunes);
if (itunes.CurrentPlaylist == null || itunes.CurrentPlaylist.Name != "iTunes DJ")
{
var playlist = itunes.LibrarySource.Playlists.get_ItemByName("iTunes DJ");
if (playlist != null)
{
playlist.PlayFirstTrack();
}
else
{
throw new Exception("iTunes DJ playlist not found.");
}
}
}
private void iTunesParse()
{
iTunes = new iTunesAppClass();
mainLibrary = iTunes.LibraryPlaylist;
tracks = mainLibrary.Tracks;
IITFileOrCDTrack track;
numTracks = tracks.Count;
totalTracks = tracks.Count;
OverallTotal += tracks.Count;
//files = new Dictionary<string, int>();
TreeNode root = new TreeNode("iTunes");
TreeNode node = root;
while (numTracks != 0)
{
OverallPosition++;
track = tracks[numTracks] as IITFileOrCDTrack;
//track.UpdateInfoFromFile();
if (track != null)
{
if (track.Location != null)
{
if (track.Location.StartsWith(FileRoot))
{
//files.Add(track.Location, numTracks);
if (!collection.ContainsKey(track.Location.ToLower()))
{
collection.Add(track.Location.ToLower(), WorkingTrackFromIITFileOrCDTrack(track, numTracks));
}
}
}
}
backgroundWorker1.ReportProgress((OverallPosition / OverallTotal) * 100);
numTracks--;
}
}
public override void MyTestCleanup()
{
Debug.WriteLine("**** Unit test shutdown");
// if iTunes is shutdown first then itunes will be null because of OnAboutToPrompt...
// otherwise if we terminate the unit test first then we want to force our
// cleanup here...
if (itunes != null)
{
itunes_OnAboutToPromptUserToQuitEvent();
Marshal.ReleaseComObject(itunes);
itunes = null;
}
base.MyTestCleanup();
}
private iTunesApp GetiTunesService()
{
iTunesApp app;
// only set app if iTunes is running
if (Process.GetProcessesByName("iTunes").Any())
{
app = new iTunesAppClass();
IsMute = app.Mute;
}
else
{
app = null;
}
return(app);
}
public static void Start(iTunesAppClass itunes)
{
SetUp(itunes);
itunes.InitializeTrackCache();
if (itunes.CurrentPlaylist == null || itunes.CurrentPlaylist.Name != "iTunes DJ")
{
var playlist = itunes.LibrarySource.Playlists.get_ItemByName("iTunes DJ");
if (playlist != null)
{
playlist.PlayFirstTrack();
}
else
{
throw new Exception("iTunes DJ playlist not found.");
}
}
}
public override void Stop()
{
if (_iTunesApplication == null)
{
return;
}
try
{
_iTunesApplication.Stop();
_playerIsPaused = false;
_started = false;
_notifyPlaying = false;
}
catch (Exception)
{
_iTunesApplication = null;
}
}
public override void Stop()
{
if (_iTunesApplication == null)
{
return;
}
try
{
_iTunesApplication.Stop();
_playerIsPaused = false;
_started = false;
_notifyPlaying = false;
}
catch (Exception ex)
{
Log.Error("ITunesPlugin:Stop: {0}", ex.Message);
_iTunesApplication = null;
}
}
static void iTunes_Start(Options options)
{
try {
iTunesAppClass itunes = new iTunesAppClass();
System.Threading.Thread.Sleep(1000);
//if ( !itunes.CurrentStreamURL.Contains ("http") )
if (options.Items.Count == 1)
{
itunes.OpenURL(options.Items [0]);
}
else
{
itunes.OpenURL("http:/65.49.77.146:9574"); // The Badlands
}
// http://badlandscountry.com -> http://www.audiorealm.com
itunes.Mute = false;
} catch (Exception e) {
}
}
public void RenameX()
{
iTunesAppClass itunes = new iTunesAppClass();
IITLibraryPlaylist playlist = itunes.LibraryPlaylist;
IITTrackCollection tracks = playlist.Tracks;
foreach (IITTrack track in tracks)
{
if ((track != null) &&
(track.Album != null) &&
track.Album.Equals("Sheer Heart Attack") &&
track.Artist.Equals("Queen"))
{
// 07 - Lenny Kravitz - Mr. Cab Driver (1989)
string[] parts = track.Name.Split('-');
if (parts.Length == 2)
{
Console.WriteLine("... " + track.Name);
int trackNumber = Int32.Parse(parts[0].Trim());
string name = parts[1].Trim();
track.Comment = track.Name;
if (trackNumber > 0)
{
track.TrackNumber = trackNumber;
}
if (!String.IsNullOrEmpty(name))
{
track.Name = name;
}
}
//int index = track.Name.IndexOf('(');
//if (index > 0)
//{
// track.Name = track.Name.Substring(0, index - 1).Trim();
//}
}
}
}
private void button12_Click(object sender, EventArgs e)
{
iTunes = new iTunesAppClass();
mainLibrary = iTunes.LibraryPlaylist;
tracks = mainLibrary.Tracks;
var count = tracks.Count;
var sb = new StringBuilder();
for (int i = 1; i < tracks.Count + 1; i++)
{
IITFileOrCDTrack track = tracks[i] as IITFileOrCDTrack;
if (track != null)
{
if (track.Location != null)
{
if (track.Location.StartsWith(FileRoot))
{
sb.AppendFormat("{0}\t{1}\t{2}\t{3}\t{4}", track.Artist, track.Album, track.Name, track.Location, track.Rating);
sb.Append(Environment.NewLine);
}
}
}
}
textBox1.Text = sb.ToString();
//foreach (WorkingTrack wt in collection.Values)
//{
// if (wt.isIniTunes)
// {
// sb.AppendFormat("{0}\t{1}\t{2}\t{3}\t{4}", wt.iTunesArtist, wt.iTunesAlbum, wt.iTunesName, wt.iTunesLocation, wt.iTunesRating);
// sb.Append(Environment.NewLine);
// }
//}
File.WriteAllText("ratings.txt", sb.ToString());
System.Diagnostics.Process.Start("ratings.txt");
}
public void RenameTop500()
{
iTunesAppClass itunes = new iTunesAppClass();
IITLibraryPlaylist playlist = itunes.LibraryPlaylist;
IITTrackCollection tracks = playlist.Tracks;
foreach (IITTrack track in tracks)
{
if ((track != null) &&
(track.Album != null) &&
track.Album.Equals("Top 500 Rock"))
{
// 003 - Derek and the Dominos - Layla
string[] parts = track.Name.Split('-');
if (parts.Length == 3)
{
Console.WriteLine("... " + track.Name);
int trackNumber = Int32.Parse(parts[0].Trim());
string artist = parts[1].Trim();
string name = parts[2].Trim();
track.Comment = track.Name;
if (trackNumber > 0)
{
track.TrackNumber = trackNumber;
}
if (!String.IsNullOrEmpty(artist))
{
track.Artist = artist;
}
if (!String.IsNullOrEmpty(name))
{
track.Name = name;
}
}
}
}
}
/// <summary>
/// Dispose of this instance; do not override.
/// </summary>
public void Dispose()
{
if (!isDisposed)
{
// invoke Cleanup on behalf of the derived class
Cleanup();
if (isPrimaryController)
{
isConnected = false;
if (itunes != null)
{
itunes.OnCOMCallsDisabledEvent -= disabledEvent;
itunes.OnCOMCallsEnabledEvent -= enabledEvent;
disabledEvent = null;
enabledEvent = null;
try
{
itunes.Quit();
}
catch
{
// no-op
}
finally
{
Release(itunes);
itunes = null;
}
reset.Set();
reset.Close();
reset = null;
}
}
isDisposed = true;
GC.SuppressFinalize(this);
}
}
protected override void WndProc(ref Message m)
{
const int WM_HOTKEY = 0x0312;
switch (m.Msg)
{
case WM_HOTKEY:
if ((int)m.WParam == (int)Keys.MediaNextTrack)
{
iTunesAppClass iTunes = new iTunesAppClass();
iTunes.NextTrack();
System.Runtime.InteropServices.Marshal.ReleaseComObject(iTunes);
}
else if ((int)m.WParam == (int)Keys.MediaPreviousTrack)
{
iTunesAppClass iTunes = new iTunesAppClass();
iTunes.PreviousTrack();
System.Runtime.InteropServices.Marshal.ReleaseComObject(iTunes);
}
else if ((int)m.WParam == (int)Keys.MediaPlayPause)
{
iTunesAppClass iTunes = new iTunesAppClass();
iTunes.PlayPause();
System.Runtime.InteropServices.Marshal.ReleaseComObject(iTunes);
}
else if ((int)m.WParam == (int)Keys.MediaStop)
{
iTunesAppClass iTunes = new iTunesAppClass();
iTunes.Stop();
System.Runtime.InteropServices.Marshal.ReleaseComObject(iTunes);
}
else
{
MessageBox.Show("Something seems to be wrong. The ID was: " + m.WParam.ToString());
}
break;
}
base.WndProc(ref m);
}
public void RenameX()
{
iTunesAppClass itunes = new iTunesAppClass();
IITLibraryPlaylist playlist = itunes.LibraryPlaylist;
IITTrackCollection tracks = playlist.Tracks;
foreach (IITTrack track in tracks)
{
if ((track != null) &&
(track.Album != null) &&
track.Album.Equals("Sheer Heart Attack") &&
track.Artist.Equals("Queen"))
{
// 07 - Lenny Kravitz - Mr. Cab Driver (1989)
string[] parts = track.Name.Split('-');
if (parts.Length == 2)
{
Console.WriteLine("... " + track.Name);
int trackNumber = Int32.Parse(parts[0].Trim());
string name = parts[1].Trim();
track.Comment = track.Name;
if (trackNumber > 0)
track.TrackNumber = trackNumber;
if (!String.IsNullOrEmpty(name))
track.Name = name;
}
//int index = track.Name.IndexOf('(');
//if (index > 0)
//{
// track.Name = track.Name.Substring(0, index - 1).Trim();
//}
}
}
}
public IEnumerable<string> Handle(string input, Match match, IListener listener)
{
var itunes = new iTunesAppClass();
switch (itunes.PlayerState)
{
case ITPlayerState.ITPlayerStatePlaying:
itunes.Stop();
yield return "Music paused.";
break;
case ITPlayerState.ITPlayerStateStopped:
yield return "Would you like me to play something specific or just continue?";
Brain.Pipe.ListenNext((s, match1, listener1) =>
{
if (s == "continue")
{
listener1.Output("Playing " + itunes.CurrentTrack.Name + " by " + itunes.CurrentTrack.Artist);
itunes.Play();
}
foreach (IITPlaylist playlist in itunes.LibrarySource.Playlists)
{
if (!playlist.Name.ToLower().Contains(s)) continue;
playlist.PlayFirstTrack();
listener1.Output("Playing playlist " + playlist.Name);
return;
}
foreach (IITTrack track in itunes.LibraryPlaylist.Tracks)
{
if (!track.Name.ToLower().Contains(s) && !track.Artist.ToLower().Contains(s)) continue;
track.Play();
listener1.Output("Playing " + track.Name + " by " + track.Artist);
return;
}
}, ".+");
break;
}
yield return "";
}
static void Main(string[] args)
{
IiTunes iTunesApp;
iTunesApp = new iTunesAppClass();
IITLibraryPlaylist library = iTunesApp.LibraryPlaylist;
long i = 0;
foreach (IITFileOrCDTrack track in library.Tracks) {
try {
if (++i % 100 == 0) {
Console.Error.WriteLine("Working on track " + i);
}
String result = updateTrack(track);
if (null != result) {
Console.WriteLine(i + ": " + result);
}
} catch (System.Runtime.InteropServices.COMException e) {
Console.Error.WriteLine("Caught exception: " + e);
}
}
}
public void RenameTop500()
{
iTunesAppClass itunes = new iTunesAppClass();
IITLibraryPlaylist playlist = itunes.LibraryPlaylist;
IITTrackCollection tracks = playlist.Tracks;
foreach (IITTrack track in tracks)
{
if ((track != null) &&
(track.Album != null) &&
track.Album.Equals("Top 500 Rock"))
{
// 003 - Derek and the Dominos - Layla
string[] parts = track.Name.Split('-');
if (parts.Length == 3)
{
Console.WriteLine("... " + track.Name);
int trackNumber = Int32.Parse(parts[0].Trim());
string artist = parts[1].Trim();
string name = parts[2].Trim();
track.Comment = track.Name;
if (trackNumber > 0)
track.TrackNumber = trackNumber;
if (!String.IsNullOrEmpty(artist))
track.Artist = artist;
if (!String.IsNullOrEmpty(name))
track.Name = name;
}
}
}
}
public void iTunes()
{
itunes = new iTunesAppClass();
aboutToPromptUserToQuitEvent = new _IiTunesEvents_OnAboutToPromptUserToQuitEventEventHandler(itunes_OnAboutToPromptUserToQuitEvent);
cOMCallsDisabledEvent = new _IiTunesEvents_OnCOMCallsDisabledEventEventHandler(itunes_OnCOMCallsDisabledEvent);
cOMCallsEnabledEvent = new _IiTunesEvents_OnCOMCallsEnabledEventEventHandler(itunes_OnCOMCallsEnabledEvent);
databaseChangedEvent = new _IiTunesEvents_OnDatabaseChangedEventEventHandler(itunes_OnDatabaseChangedEvent);
playerPlayEvent = new _IiTunesEvents_OnPlayerPlayEventEventHandler(itunes_OnPlayerPlayEvent);
playerPlayingTrackChangedEvent = new _IiTunesEvents_OnPlayerPlayingTrackChangedEventEventHandler(itunes_OnPlayerPlayingTrackChangedEvent);
playerStopEvent = new _IiTunesEvents_OnPlayerStopEventEventHandler(itunes_OnPlayerStopEvent);
quittingEvent = new _IiTunesEvents_OnQuittingEventEventHandler(itunes_OnQuittingEvent);
soundVolumeChangedEvent = new _IiTunesEvents_OnSoundVolumeChangedEventEventHandler(itunes_OnSoundVolumeChangedEvent);
userInterfaceEnabledEvent = new _IiTunesEvents_OnUserInterfaceEnabledEventEventHandler(itunes_OnUserInterfaceEnabledEvent);
// NOTE: did not see any difference in maintaining these individual handler variables
// as opposed to unregistering -= new handlers in the OnAboutToPromptToQuit handler
itunes.OnAboutToPromptUserToQuitEvent += aboutToPromptUserToQuitEvent;
itunes.OnCOMCallsDisabledEvent += cOMCallsDisabledEvent;
itunes.OnCOMCallsEnabledEvent += cOMCallsEnabledEvent;
itunes.OnDatabaseChangedEvent += databaseChangedEvent;
itunes.OnPlayerPlayEvent += playerPlayEvent;
itunes.OnPlayerPlayingTrackChangedEvent += playerPlayingTrackChangedEvent;
itunes.OnPlayerStopEvent += playerStopEvent;
itunes.OnQuittingEvent += quittingEvent;
itunes.OnSoundVolumeChangedEvent += soundVolumeChangedEvent;
itunes.OnUserInterfaceEnabledEvent += userInterfaceEnabledEvent;
AllProps(itunes);
reset = new ManualResetEvent(false);
// waiting for iTunes to quit
reset.WaitOne();
}
private void KillITunes()
{
if (_itunes == null)
return;
_itunes = null;
GC.Collect();
}
private string ReplaceKeyWords(string originalString)
{
if (_isLoggedIn)
{
try
{
iTunesApp app = new iTunesAppClass();
string artist = app.CurrentTrack.Artist;
string name = app.CurrentTrack.Name;
string playlist = app.CurrentTrack.Playlist.Name;
string album = app.CurrentTrack.Album;
string genre = app.CurrentTrack.Genre;
int count = app.CurrentTrack.PlayedCount;
originalString = originalString.Replace("{name}", name);
originalString = originalString.Replace("{artist}", artist);
originalString = originalString.Replace("{playlist}", playlist);
originalString = originalString.Replace("{count}", count.ToString());
originalString = originalString.Replace("{album}", album);
originalString = originalString.Replace("{genre}", genre);
}
catch (Exception e)
{
AddLineToConsole(e.Message);
}
}
return originalString;
}
private void SaveAlbumArt()
{
try
{
iTunesApp app = new iTunesAppClass();
var curTrack = app.CurrentTrack;
if (curTrack.Artwork[1] != null)
{
curTrack.Artwork[1].SetArtworkFromFile(String.Concat(Environment.CurrentDirectory,
@"\ArtistCover.jpg"));
}
else
{
curTrack.AddArtworkFromFile(String.Concat(Environment.CurrentDirectory,
@"\ArtistCover.jpg"));
}
lastFMBtn.Text = "Сохранено";
lastFMBtn.Enabled = false;
}
catch (Exception ex)
{
AddLineToConsole(ex.Message);
}
}
/// <summary>
/// </summary>
/// <param name="channel"> </param>
protected override void Play(IChannel channel)
{
// REALLY NEED TO CHANGE THIS IOC/TEMPLATE METHOD IN BASE CLASS
// http://blogs.msdn.com/danielfe/archive/2004/06/08/151212.aspx
// _channel = channel;
//if (channel == null) throw new ArgumentNullException("channel", "Must specify a channel to play. ");
var url = channel.CurrentTrack.TrackUrl;
if (!IsInstalled) return;
//Trace.WriteLine(string.Format("{0} will attempt to stream {1}", this.PlayerType.ToString(), url));
var thread = new Thread
(() =>
{
iTunesApp player = new iTunesAppClass();
player.OpenURL(ParseStreamUri(url).AbsoluteUri);
player.Play();
});
thread.Start();
//Parallel.Invoke(
// () => startPlayer(url));
}
public WorkflowRunner()
{
_app = new iTunesAppClass();
}
private void FindDeadTracks()
{
//create a reference to iTunes
var iTunes = new iTunesAppClass();
//get a reference to the collection of all tracks
IITTrackCollection tracks = iTunes.LibraryPlaylist.Tracks;
int trackCount = tracks.Count;
int numberChecked = 0;
int numberDeadFound = 0;
//setup the progress control
SetupProgress(trackCount);
for (int i = trackCount; i > 0; i--)
{
if (!_shouldStop)
{
IITTrack track = tracks[i];
numberChecked++;
IncrementProgress();
UpdateLabel("Checking track # " + numberChecked.ToString() + " - " + track.Name);
if (track.Kind == ITTrackKind.ITTrackKindFile)
{
IITFileOrCDTrack fileTrack = (IITFileOrCDTrack)track;
//if the file doesn't exist, we'll delete it from iTunes
if (fileTrack.Location == String.Empty)
{
numberDeadFound++;
AddTrackToList(fileTrack);
if (checkBoxRemove.Checked)
{
fileTrack.Delete();
}
}
else if (!System.IO.File.Exists(fileTrack.Location))
{
numberDeadFound++;
AddTrackToList(fileTrack);
if (checkBoxRemove.Checked)
{
fileTrack.Delete();
}
}
}
}
}
UpdateLabel("Checked " + numberChecked.ToString() + " tracks and " + numberDeadFound.ToString() + " dead tracks found.");
SetupProgress(1);
}
private void RemoveDuplicates()
{
var iTunes = new iTunesAppClass();
//get a reference to the collection of all tracks
IITTrackCollection tracks = iTunes.LibraryPlaylist.Tracks;
int trackCount = tracks.Count;
int numberChecked = 0;
int numberDuplicateFound = 0;
Dictionary<string, IITTrack> trackCollection = new Dictionary<string, IITTrack>();
var tracksToRemove = new ArrayList();
//setup the progress control
SetupProgress(trackCount);
for (int i = trackCount; i > 0; i--)
{
if (tracks[i].Kind == ITTrackKind.ITTrackKindFile)
{
if (!_shouldStop)
{
numberChecked++;
IncrementProgress();
UpdateLabel("Checking track # " + numberChecked.ToString() + " - " + tracks[i].Name);
string trackKey = tracks[i].Name + tracks[i].Artist + tracks[i].Album;
if (!trackCollection.ContainsKey(trackKey))
trackCollection.Add(trackKey, tracks[i]);
else
{
if (trackCollection[trackKey].Album != tracks[i].Album || trackCollection[trackKey].Artist != tracks[i].Artist)
trackCollection.Add(trackKey, tracks[i]);
else if (trackCollection[trackKey].BitRate > tracks[i].BitRate)
{
IITFileOrCDTrack fileTrack = (IITFileOrCDTrack)tracks[i];
numberDuplicateFound++;
tracksToRemove.Add(tracks[i]);
}
else
{
IITFileOrCDTrack fileTrack = (IITFileOrCDTrack)tracks[i];
trackCollection[trackKey] = fileTrack;
numberDuplicateFound++;
tracksToRemove.Add(tracks[i]);
}
}
}
}
}
SetupProgress(tracksToRemove.Count);
for (int i = 0; i < tracksToRemove.Count; i++)
{
IITFileOrCDTrack track = (IITFileOrCDTrack)tracksToRemove[i];
UpdateLabel("Removing " + track.Name);
IncrementProgress();
AddTrackToList((IITFileOrCDTrack)tracksToRemove[i]);
if (checkBoxRemove.Checked)
track.Delete();
}
UpdateLabel("Checked " + numberChecked.ToString() + " tracks and " + numberDuplicateFound.ToString() + " duplicate tracks found.");
SetupProgress(1);
}
private void InitializeiTunes()
{
_itunes = new iTunesAppClass();
_itunes.OnQuittingEvent += KillITunes;
_itunes.OnAboutToPromptUserToQuitEvent += KillITunes;
}
public static Song toSong(this IITTrack t, iTunesAppClass itunes)
{
_lookup.GetOrAdd(t.TrackDatabaseID, _ =>
new Tuple<int, int>(
itunes.ITObjectPersistentIDHigh[t],
itunes.ITObjectPersistentIDLow[t]
)
);
return new Song
{
Id = t.TrackDatabaseID,
Album = t.Album,
Artist = t.Artist,
Rating = t.Rating,
Title = t.Name,
ArtworkUrl = String.Format(_artworkUrlFormatString, t.TrackDatabaseID),
DownloadUrl = String.Format(_downloadUrlFormatString, t.TrackDatabaseID),
AlbumDownloadUrl = String.Format(_albumDownloadUrlFormatString, t.TrackDatabaseID),
Duration = t.Duration
};
}
private void Button_Click(object sender, RoutedEventArgs e)
{
var items =
this.dataGrid.Items.Cast<ViewModel>()
.Where(x => x.IsChecked == true).ToArray();
var tracks= new iTunesAppClass().LibraryPlaylist.Tracks.Cast<IITTrack>();
foreach (var item in items)
{
var targets = tracks.Where(x => x.Album == item.AlbumName).ToArray();
var comment = string.Join("@", new string[]{
Convert.ToString(item.ArtistName),
Convert.ToString(item.ReleaseYear),
Convert.ToString(item.ReleaseOrder)
}.Where(x => string.IsNullOrWhiteSpace(x) == false).ToArray());
foreach (var t in targets)
{
t.Comment = comment;
}
var stop = "";
}
MessageBox.Show("completed");
}
public static void MyClassInitialize(TestContext testContext)
{
itunes = new iTunesAppClass();
controller = new Controller();
libraryXMLPath = controller.LibraryXMLPath;
}
/// <summary>
/// Parse the iTunes XML and then upload the stats to the user account
///
/// </summary>
public void ParseiTunesXML()
{
startstop.AccessPoint oAccessPoint = new startstop.AccessPoint();
// Validate the user
ValidatedUserInfo = oAccessPoint.LoginUser(APIKey, txbUserName.Text, txbPassword.Text);
// Check to see if the user is validated
if (ValidatedUserInfo.Validated) // User details invalid
{
// We should really access the iTunes XML file, but for now this will.
//iTunes classes
iTunesAppClass itunes = new iTunesAppClass();
IITLibraryPlaylist mainLibrary = itunes.LibraryPlaylist;
IITTrackCollection tracks = mainLibrary.Tracks;
IITFileOrCDTrack currTrack;
int _numberOfTracks = tracks.Count;
startstop.UserStatLog oStat = new startstop.UserStatLog();
// Total number of tracks (This is done here, because, well, we decrement the number of tracks)
oStat = new startstop.UserStatLog();
oStat.Count = _numberOfTracks;
oStat.DetailedStatGuid = cNumberOfTunesInLibraryStatID;
oStat.DetailedStatOverviewGUID = cStatOverview;
oStat.UserGuid = ValidatedUserInfo.UserGUID;
if (!DebugMode)
{
oAccessPoint.AddUserStat(APIKey, oStat);
}
// oReturnMessage = oDevAPI.ExactStatUpdateForUserWithDayHistory(APIKey, _UserID, cNumberOfTunesInLibraryStatID, tracks.Count, 0,"");
AddLine("Updated your startstop.me stats with the number of tracks in your iTunes library");
// Total number of plays
int _TotalNumberOfPlays = 0;
// The highest played track
int _MostPlayedCount = 0;
string _MostPlayedTrack = "";
// Number of unplayed tracks
int _UnplayedTracks = 0;
// Total time played
TimeSpan oTimeTimePlayed = new TimeSpan(0, 0, 0);
TimeSpan oTimeUnplayed = new TimeSpan(0, 0, 0);
// Here we can go through all the files and update some more stats
while (_numberOfTracks != 1)
{
// Iterate throught the tracks.
_numberOfTracks--;
currTrack = tracks[_numberOfTracks] as IITFileOrCDTrack;
// Check this is a song
if (currTrack.KindAsString.Contains("audio"))
{
_TotalNumberOfPlays += currTrack.PlayedCount;
string[] _timeSplit = currTrack.Time.Split(':');
TimeSpan _tracktime = new TimeSpan();
// Minutes and Seconds
if (_timeSplit.Length == 2)
{
_tracktime = new TimeSpan(0, int.Parse(_timeSplit[0]), int.Parse(_timeSplit[1]));
}
// Hours Minutes and seconds
if (_timeSplit.Length == 3)
{
_tracktime = new TimeSpan(int.Parse(_timeSplit[0]), int.Parse(_timeSplit[1]), int.Parse(_timeSplit[2]));
}
if (currTrack.PlayedCount > _MostPlayedCount)
{
_MostPlayedCount = currTrack.PlayedCount;
_MostPlayedTrack = currTrack.Name;
oMostPlayedSong.SongTitle = currTrack.Name;
oMostPlayedSong.AlbumnTitle = currTrack.Album;
oMostPlayedSong.Genre = currTrack.Genre;
oMostPlayedSong.Notes = "";
oMostPlayedSong.ReportingUserID = ValidatedUserInfo.UserID;
// Catch if there is an invalid date.
if (currTrack.Year != 0)
{
oMostPlayedSong.Year = new DateTime(currTrack.Year, 1, 1, 0, 0, 0);
}
}
if (currTrack.Unplayed)
{
_UnplayedTracks++;
oTimeUnplayed = oTimeUnplayed.Add(_tracktime);
}
else
{
// Repeat through these to give us the total time
for (int i = 0; i < currTrack.PlayedCount; i++)
{
oTimeTimePlayed = oTimeTimePlayed.Add(_tracktime);
}
}
} // end track kind check.
}
#region update the stats with startstop
AddLine("Added total number of plays");
// we should swap all this rhubarb for a dictionary, it doesn't need to be this complex. That way we can iterate through the dictionary.
// Anyway, for now, this will work.
// Total number of plays
oStat = new startstop.UserStatLog();
oStat.Count = _TotalNumberOfPlays;
oStat.DetailedStatGuid = cTotalNumberOfPlays;
oStat.DetailedStatOverviewGUID = cStatOverview;
oStat.UserGuid = ValidatedUserInfo.UserGUID;
if (!DebugMode)
{
oAccessPoint.AddUserStat(APIKey, oStat);
}
// Unplayed tracks
oStat = new startstop.UserStatLog();
oStat.Count = _UnplayedTracks;
oStat.DetailedStatGuid = cUnplayedTunes;
oStat.DetailedStatOverviewGUID = cStatOverview;
oStat.UserGuid = ValidatedUserInfo.UserGUID;
if (!DebugMode)
{
oAccessPoint.AddUserStat(APIKey, oStat);
}
// Most played tracks
oStat = new startstop.UserStatLog();
oStat.Count = _MostPlayedCount;
oStat.DetailedStatGuid = cMostPlayesOnaSong;
oStat.DetailedStatOverviewGUID = cStatOverview;
oStat.UserGuid = ValidatedUserInfo.UserGUID;
if (!DebugMode)
{
oAccessPoint.AddUserStat(APIKey, oStat);
}
// Amount of time played
oStat = new startstop.UserStatLog();
oStat.Count = 0;
oStat.Note = oTimeTimePlayed.Days + "d " + oTimeTimePlayed.Hours + "h " + oTimeTimePlayed.Minutes + "m";
oStat.DetailedStatGuid = cTimePlayed;
oStat.DetailedStatOverviewGUID = cStatOverview;
oStat.UserGuid = ValidatedUserInfo.UserGUID;
if (!DebugMode)
{
oAccessPoint.AddUserStat(APIKey, oStat);
}
// Amount of time played
oStat = new startstop.UserStatLog();
oStat.Count = 0;
oStat.Note = oTimeUnplayed.Days + "d " + oTimeUnplayed.Hours + "h " + oTimeUnplayed.Minutes + "m";
oStat.DetailedStatGuid = cTimeUnPlayed;
oStat.DetailedStatOverviewGUID = cStatOverview;
oStat.UserGuid = ValidatedUserInfo.UserGUID;
if (!DebugMode)
{
oAccessPoint.AddUserStat(APIKey, oStat);
}
// Amount of time played
oStat = new startstop.UserStatLog();
oStat.Count = 0;
oStat.Note = _MostPlayedTrack;
oStat.DetailedStatGuid = cMostPlayedSong;
oStat.DetailedStatOverviewGUID = cStatOverview;
oStat.UserGuid = ValidatedUserInfo.UserGUID;
if (!DebugMode)
{
oAccessPoint.AddUserStatMusic(APIKey, oStat, oMostPlayedSong);
}
oStat = new startstop.UserStatLog();
oStat.Count = 0;
oStat.Note = DateTime.Now.ToString();
oStat.DetailedStatGuid = cLastUpdate;
oStat.DetailedStatOverviewGUID = cStatOverview;
oStat.UserGuid = ValidatedUserInfo.UserGUID;
if (!DebugMode)
{
oAccessPoint.AddUserStat(APIKey, oStat);
}
AddLine("All done folks! Visit www.startstop.me to see your stats");
#endregion
}
else
{
AddLine("User cannot be logged in");
MessageBox.Show("Sorry your login details aren't correct");
}
}
public static Song toSong(this IITTrack t, int position, User u, iTunesAppClass itunes)
{
var song = Helpers.toSong(t, u, itunes);
song.Poisition = position;
return song;
}
public static Song toSong(this IITTrack t, User u, iTunesAppClass itunes)
{
var isFavorite = u != null && u.Favorites.Where(s => s.Id == t.TrackDatabaseID).Any();
var song = Helpers.toSong(t, itunes);
song.IsFavorite = isFavorite;
return song;
}
