internal DACPRequest GetPlayQueueEditRequest(string command, DACPQueryElement query, PlayQueueMode mode, string sort = null)
{
DACPRequest request = new DACPRequest("/ctrl-int/1/playqueue-edit");
request.QueryParameters["command"] = command;
if (query != null)
{
request.QueryParameters["query"] = query.ToString();
}
request.QueryParameters["mode"] = ((int)mode).ToString();
if (sort != null)
{
request.QueryParameters["sort"] = sort;
}
if (this != Server.MainDatabase)
{
request.QueryParameters["srcdatabase"] = "0x" + PersistentID.ToString("x16");
}
// TODO: Handle this separately
if (mode == PlayQueueMode.Replace)
{
request.QueryParameters["clear-previous"] = "1";
}
return(request);
}
private PersistentID GetPlaylistPersistentID(string name)
{
IITPlaylist playlist = itunes.LibrarySource.Playlists.get_ItemByName(name);
PersistentID pid = GetPersistentID(playlist);
return(pid);
}
// Use this for initialization
protected virtual void Start()
{
//tarkista ja päivitä vihollisen tiedot pelin tallennuksessa
baseHealthSystem = GetComponent <HealthSystem>();
id = GetComponent <PersistentID>();
gameData = GameDataManager.Instance.GameData;
if (!gameData.enemies.ContainsKey(id.id))
{
gameData.enemies[id.id] = new GameData.Enemy();
enemyData = gameData.enemies[id.id];
enemyData.isAlive = true;
if (baseHealthSystem != null)
{
enemyData.health = baseHealthSystem.currentHealth;
}
}
else
{
enemyData = gameData.enemies[id.id];
if (!enemyData.isAlive)
{
//Debug.Log("EnemyBase - "+id.id+" Not Alive");
Destroy(gameObject);
}
else
{
if (baseHealthSystem != null)
{
baseHealthSystem.currentHealth = enemyData.health;
}
}
}
}
public void DuplicateScannerInAlbum()
{
// for this test, create new 'ituner' playlist and add duplicate entries..
DuplicateScanner scanner = new DuplicateScanner(controller, catalog);
scanner.PlaylistFilter = PersistentID.Parse("612F0BCDC4E08C4E");
scanner.Execute();
}
private DACPRequest GetCueRequest(DACPQueryElement query, string sort)
{
DACPRequest request = new DACPRequest("/ctrl-int/1/cue");
request.QueryParameters["command"] = "play";
if (query != null)
{
request.QueryParameters["query"] = query.ToString();
}
request.QueryParameters["sort"] = sort;
request.QueryParameters["srcdatabase"] = "0x" + PersistentID.ToString("x16");
request.QueryParameters["clear-first"] = "1";
return(request);
}
public void FindCatalogedTracksByPlaylist()
{
// FlatCatalog
ICatalog catalog = new FlatCatalog();
catalog.Initialize(libraryXMLPath);
Console.WriteLine(String.Format("new FlatCatalog() -> {0} ms", watch.GetSplitMilliseconds()));
var tracks = new List <IITTrack>();
PersistentID pid = GetPlaylistPersistentID("ituner");
PersistentIDCollection persistentIDs = catalog.FindTracksByPlaylist(pid);
foreach (PersistentID persistentID in persistentIDs)
{
IITTrack itrack = itunes.LibraryPlaylist.Tracks.get_ItemByPersistentID(
persistentID.HighBits, persistentID.LowBits);
tracks.Add(itrack);
}
Console.WriteLine(String.Format("FindTracksByPlaylist -> {0} ms", watch.GetSplitMilliseconds()));
Assert.IsNotNull(persistentIDs);
Assert.AreNotEqual(0, persistentIDs.Count);
Console.WriteLine(String.Format("Found {0} tracks", persistentIDs.Count));
watch.Stop();
Console.WriteLine(String.Format("Completed in {0} ms", watch.GetElapsedMilliseconds()));
// iTunes
watch.Reset();
watch.Start();
IITTrackCollection itracks =
itunes.LibrarySource.Playlists.get_ItemByName("ituner").Tracks;
Console.WriteLine(String.Format("get_ItemByName -> {0} ms", watch.GetSplitMilliseconds()));
watch.Stop();
Console.WriteLine(String.Format("Completed in {0} ms", watch.GetElapsedMilliseconds()));
}
// Use this for initialization
void Start()
{
anim = flag.GetComponent <Animator>();
id = GetComponent <PersistentID>();
activationSound = GetComponent <AudioSource>();
spawnPoint = transform.Find("SpawnPoint").gameObject;
activated = false;
//tarkista ja päivitä checkpointin tiedot pelin tallennuksessa
GameData data = GameDataManager.Instance.GameData;
if (!data.checkPoints.ContainsKey(id.id))
{
data.checkPoints[id.id] = new GameData.CheckPoint();
}
else
{
if (data.checkPoints[id.id].activated)
{
Debug.Log("CheckPoint - " + id.id + " already activated");
activated = true;
anim.SetBool("Raised", true);
}
}
}
private DacpRequest GetPlaySpecRequest()
{
DacpRequest request = new DacpRequest("/ctrl-int/1/playspec");
request.QueryParameters["database-spec"] = DacpQueryPredicate.Is("dmap.persistentid", "0x" + Database.PersistentID.ToString("x16")).ToString();
request.QueryParameters["container-spec"] = DacpQueryPredicate.Is("dmap.persistentid", "0x" + PersistentID.ToString("x16")).ToString();
return(request);
}
//----------------------------------------------------------------------------------------
/// <summary>
/// Invoked when the Sync button is pressed, starts the synchronization process.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void DoSync(object sender, RoutedEventArgs e)
{
string text = String.Format(Resx.SyncWarningText, selector.Location);
MessageBoxResult result = MessageWindow.Show(
null, text, Resx.SyncWarningCaption,
MessageBoxButton.OKCancel, MessageWindowImage.Warning, MessageBoxResult.Cancel);
if (result != MessageBoxResult.OK)
{
e.Handled = true;
return;
}
countBox.Visibility = Visibility.Hidden;
playlistBox.IsEnabled = false;
selector.IsEnabled = false;
syncButton.Visibility = Visibility.Collapsed;
progressPanel.Visibility = Visibility.Visible;
string format = PathHelper.GetPathFormat(selector.FormatTag);
bool withPlaylist = format.Contains("playlist");
var list = new PersistentIDCollection();
using (var selectedPlaylists = new PlaylistCollection())
{
selectedPlaylists.AddRange(playlists.FindAll(p => p.IsSelected == true));
foreach (Playlist playlist in selectedPlaylists.Values)
{
if (playlist != null)
{
PersistentID pid = playlist.PersistentID;
PersistentIDCollection tracks =
controller.Librarian.Catalog.FindTracksByPlaylist(pid);
if (withPlaylist)
{
// Cannot modify a value type (PersistentID) from within a foreach loop
// or the .ForEach extension method, so we need to recreate each pid
// to set the playlist name. Unfortunate design consequence...
foreach (PersistentID track in tracks)
{
PersistentID tid = track;
tid.PlaylistName = playlist.Name;
list.Add(tid);
}
}
else
{
list.AddRange(tracks);
}
}
}
}
// show iTunes incase a protection fault occurs; otherwise you cannot see the
// dialog if iTunes is minimized as a Taskbar toolbar
controller.ShowiTunes();
controller.Librarian.ProgressChanged += new ProgressChangedEventHandler(DoProgressChanged);
controller.Librarian.Export(list, selector.Location, format);
}
public void FlatTerseComparisons()
{
// create two playlists, both name "Ben" and use this to test that we can
// find the extensions in the first one
ICatalog flat = new FlatCatalog();
flat.Initialize(libraryXMLPath);
ICatalog terse = new TerseCatalog();
terse.Initialize(libraryXMLPath);
PersistentID pid = GetPlaylistPersistentID("Ben");
// FindExtensionsByPlaylist()
StringCollection flatExtensions = flat.FindExtensionsByPlaylist(pid);
Assert.IsNotNull(flatExtensions);
Assert.AreNotEqual(0, flatExtensions.Count);
StringCollection terseExtensions = terse.FindExtensionsByPlaylist(pid);
Assert.IsNotNull(terseExtensions);
Assert.AreNotEqual(0, terseExtensions.Count);
Assert.AreEqual(flatExtensions.Count, terseExtensions.Count);
foreach (string ext in terseExtensions)
{
Assert.IsTrue(flatExtensions.Contains(ext));
}
Console.WriteLine("FindExtensionsByPlaylist() OK");
// FindPlaylistName()
string name = flat.FindPlaylistName(pid);
Assert.AreEqual("Ben", name);
name = terse.FindPlaylistName(pid);
Assert.AreEqual("Ben", name);
Console.WriteLine("FindPlaylistName() OK");
// FindTracksByAlbum()
PersistentIDCollection flatTracks =
flat.FindTracksByAlbum("Greatest Hits", "Alice Cooper");
Assert.IsNotNull(flatTracks);
Assert.AreNotEqual(0, flatTracks.Count);
PersistentIDCollection terseTracks =
terse.FindTracksByAlbum("Greatest Hits", "Alice Cooper");
Assert.IsNotNull(terseTracks);
Assert.AreNotEqual(0, terseTracks.Count);
Assert.AreEqual(flatTracks.Count, terseTracks.Count);
foreach (PersistentID id in terseTracks)
{
Assert.IsTrue(flatTracks.Contains(id));
}
Console.WriteLine("FindTracksByAlbum() OK");
// FindTracksByArtist()
flatTracks = flat.FindTracksByArtist("Alice Cooper");
Assert.IsNotNull(flatTracks);
Assert.AreNotEqual(0, flatTracks.Count);
terseTracks = terse.FindTracksByArtist("Alice Cooper");
Assert.IsNotNull(terseTracks);
Assert.AreNotEqual(0, terseTracks.Count);
Assert.AreEqual(flatTracks.Count, terseTracks.Count);
foreach (PersistentID id in terseTracks)
{
Assert.IsTrue(flatTracks.Contains(id));
}
Console.WriteLine("FindTracksByArtist() OK");
// FindTracksByPlaylist()
pid = GetPlaylistPersistentID("My Top Rated");
flatTracks = flat.FindTracksByPlaylist(pid);
Assert.IsNotNull(flatTracks);
Assert.AreNotEqual(0, flatTracks.Count);
terseTracks = terse.FindTracksByPlaylist(pid);
Assert.IsNotNull(terseTracks);
Assert.AreNotEqual(0, terseTracks.Count);
Assert.AreEqual(flatTracks.Count, terseTracks.Count);
foreach (PersistentID id in terseTracks)
{
Assert.IsTrue(flatTracks.Contains(id));
}
Console.WriteLine("FindTracksByPlaylist() OK");
}
public void ReloadPlaylist()
{
// 46CD262697DA37D9 == Classical Music
PersistentID persistentID = PersistentID.Parse("46CD262697DA37D9");
XElement playlist = null;
try
{
using (Stream stream = File.Open(libraryXMLPath,
FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
var settings = new XmlReaderSettings();
settings.IgnoreComments = true;
settings.IgnoreProcessingInstructions = true;
settings.IgnoreWhitespace = true;
settings.DtdProcessing = DtdProcessing.Ignore;
using (var reader = XmlReader.Create(stream, settings))
{
// read into //plist/dict and stop at the first ./array
// this is the playlists collection
if (reader.ReadToDescendant("array"))
{
// by using this subreader and pumping the stream through
// XElement.ReadFrom, we should avoid the Large Object Heap
using (var subreader = reader.ReadSubtree())
{
playlist = XElement.ReadFrom(subreader) as XElement;
}
}
}
}
}
catch (Exception exc)
{
Debug.WriteLine(exc.Message);
return;
}
if (playlist != null)
{
XElement target =
(from node in playlist
.Elements("dict")
.Elements("key")
where node.Value == "Playlist Persistent ID" &&
((XElement)node.NextNode).Value == (string)persistentID
select node.Parent).FirstOrDefault();
if (target != null)
{
var list =
from node in target
.Elements("array")
.Elements("dict")
.Elements("integer")
select node.Value;
}
}
}
public void PeruseLibrary()
{
var controller = new Controller();
System.Threading.Thread.Sleep(5000);
var playlist = controller.LibraryPlaylist;
var librarian = controller.Librarian;
var catalog = librarian.Catalog;
var tagger = new Tagger();
// search the library...
var extensions = catalog.FindExtensionsByPlaylist(controller.LibraryPlaylist.PersistentID);
var filepaths =
from e in Directory.EnumerateFiles(catalog.MusicPath, "*", SearchOption.AllDirectories)
where extensions.Contains(Path.GetExtension(e))
select e;
Logger.WriteLine(String.Format("Found {0} possible tracks to analyze", filepaths.Count()));
var random = new Random();
int maxIndex = filepaths.Count() - 1;
int numFound = 0;
int numFailed = 0;
int numRetrieved = 0;
int numSimilar = 0;
#if true
for (int index = 0; index < maxIndex; index++)
#else
for (int index = 0; index < Math.Min(20, maxIndex); index++)
#endif
{
var trackFile = new TrackFile(filepaths.ElementAt(random.Next(maxIndex)));
Logger.WriteLine();
Logger.WriteLine(String.Format("Reading tags from [{0}]", trackFile.Location));
using (TagLib.File tagFile = TagLib.File.Create(trackFile.Location))
{
if (tagFile != null)
{
trackFile.Album = tagFile.Tag.Album;
trackFile.Artist = tagFile.Tag.FirstAlbumArtist;
trackFile.Title = tagFile.Tag.Title;
Logger.WriteLine(String.Format(" - Tag.Album = [{0}]", tagFile.Tag.Album));
Logger.WriteLine(String.Format(" - Tag.Artist = [{0}]", tagFile.Tag.FirstAlbumArtist));
Logger.WriteLine(String.Format(" - Tag.Title = [{0}]", tagFile.Tag.Title));
}
}
if (String.IsNullOrEmpty(trackFile.Title) ||
(String.IsNullOrEmpty(trackFile.Album) && String.IsNullOrEmpty(trackFile.Artist)))
{
Logger.WriteLine(String.Format(" . Retrieving tags for PUID [{0}]", trackFile.UniqueID));
tagger.RetrieveTags(trackFile);
numRetrieved++;
}
bool found = false;
// can we find the track by artist/album/title?
PersistentID pid = catalog.FindTrack(
trackFile.Album, trackFile.Artist, trackFile.Title);
if (found = !pid.IsEmpty)
{
Track track = playlist.GetTrack(pid);
if (!track.Artist.Equals(trackFile.Artist))
{
Logger.WriteLine(String.Format(
" ~ Similar track '{0}', '{1}', '{2}'",
track.Artist, track.Album, track.Title));
numSimilar++;
}
else
{
Logger.WriteLine(String.Format(
" = Found track '{0}', '{1}', '{2}'",
track.Artist, track.Album, track.Title));
}
numFound++;
}
if (!found)
{
numFailed++;
Logger.WriteLine(String.Format(
" x Could not find track '{0}', '{1}', '{2}'",
trackFile.Artist, trackFile.Album, trackFile.Title));
}
}
Logger.WriteLine();
Logger.WriteLine(String.Format("... {0} found", numFound));
Logger.WriteLine(String.Format("... {0} not found", numFailed));
Logger.WriteLine(String.Format("... {0} similar", numSimilar));
Logger.WriteLine(String.Format("... {0} retrieved", numRetrieved));
}
static void UpdateIDs()
{
int numCheckedIDs = 0;
int numUpdatedIDs = 0;
IDictionary <int, int> duplicateIDCounts = new Dictionary <int, int>();
IList <PersistentID> idObjects = new List <PersistentID>();
//etsi kaikki scenen GameObjecteissa olevat PersistentID-komponentit, myös epäaktiivisista GameObjecteista
GameObject[] gameObjects = Resources.FindObjectsOfTypeAll <GameObject>();
foreach (GameObject obj in gameObjects)
{
//jätä objekti pois listalta jos se on prefab-originaali (ei scenessä)
if (PrefabUtility.GetPrefabParent(obj) == null && PrefabUtility.GetPrefabObject(obj) != null)
{
continue;
}
PersistentID idObj = obj.GetComponent <PersistentID>();
if (idObj != null)
{
idObjects.Add(idObj);
}
}
//tarkista, onko id-arvoissa duplikaatteja ja anna virheilmoitus, mikäli on
foreach (PersistentID id in idObjects)
{
if (id.id > 0)
{
if (duplicateIDCounts.ContainsKey(id.id))
{
duplicateIDCounts[id.id]++;
}
else
{
duplicateIDCounts.Add(id.id, 0);
}
}
}
foreach (int id in duplicateIDCounts.Keys)
{
int dupcount = duplicateIDCounts[id];
if (dupcount > 0)
{
Debug.LogError("IDUpdater - " + dupcount + " duplicate IDs for ID " + id);
}
}
//etsi suurin olemassa oleva ID:n arvo, uudet arvot ovat tätä seuraavasta arvosta alkaen
int maxId = 0;
foreach (PersistentID id in idObjects)
{
if (id.id > maxId)
{
maxId = id.id;
}
}
//aseta ID:t kaikille ID-objekteille, joilta puuttuu arvo
foreach (PersistentID id in idObjects)
{
if (id.id < 0) //negatiivinen id on oletusarvo, joka tarkoittaa että ID:tä ei ole asetettu
{
int newId = maxId + 1;
maxId = newId;
//id pitää asettaa näin, jotta uusi arvo säilyy play modeen siirtymisen jälkeen
SerializedObject obj = new SerializedObject(id);
obj.FindProperty("id").intValue = newId;
obj.ApplyModifiedProperties();
numUpdatedIDs++;
}
}
numCheckedIDs = idObjects.Count;
Debug.Log("IDUpdater:\n" + "Checked " + numCheckedIDs + " IDs\n" + "Updated " + numUpdatedIDs + " IDs");
}
