public static bool SaveOnlineMediaData(OnlineMediaData data)
{
bool isSaved = false;
lock (_dbLock)
{
string xml = null;
try
{
using (StringWriter sw = new StringWriter())
using (XmlWriter xw = XmlWriter.Create(sw))
{
XmlSerializer xs = new XmlSerializer(typeof(OnlineMediaData));
xs.Serialize(xw, data);
xml = sw.ToString();
}
if (xml != null)
{
PersistenceProxy.SaveObject("OnlineMediaData", xml, false);
isSaved = true;
}
}
catch (Exception ex)
{
Logger.LogException(ex);
}
}
return(isSaved);
}
static void Main()
{
int j = 0;
//using (StreamReader sr = new StreamReader(@"c:\radio_stations.csv"))
//{
// int j = 0;
// while (!sr.EndOfStream)
// {
// string line = sr.ReadLine();
// string[] fields = line.Split(",".ToCharArray());
// int i = 0;
// string url = fields[i++];
// string title = fields[i++];
// string genre = fields[i++];
// RadioStation rs = new RadioStation();
// rs.Url = url;
// rs.Title = title;
// rs.Genre = genre;
// Console.WriteLine(">> {0} / {1}", j++, 857);
// ValidateUrl(url, title, genre);
// }
// data.SavePersistentList();
//}
data = RadioStationsData.Load();
foreach (RadioStation rs in data.RadioStations)
{
Console.WriteLine(">> {0} / {1}", j++, data.RadioStations.Count);
Console.WriteLine("Trying url: {0}", rs.Url);
try
{
ShoutcastStream ss = new ShoutcastStream(rs.Url, 500);
if (ss.Connected)
{
if (ss.Bitrate >= 128)
{
data2.RadioStations.Add(rs);
}
}
}
catch { }
data2.SavePersistentList();
}
string xml = PersistenceProxy.ReadObject("RadioStationsData", string.Empty);
using (StreamWriter sw = new StreamWriter(@"c:\radio_stations.xml"))
{
sw.Write(xml);
}
}
public void PersistDisc()
{
StringBuilder xml = new StringBuilder();
XmlWriterSettings settings = new XmlWriterSettings();
settings.NewLineHandling = NewLineHandling.Entitize;
settings.OmitXmlDeclaration = true;
settings.NewLineChars = "\r\n";
settings.Indent = true;
settings.IndentChars = " ";
settings.ConformanceLevel = ConformanceLevel.Document;
settings.CloseOutput = true;
settings.NamespaceHandling = NamespaceHandling.OmitDuplicates;
using (XmlWriter xw = XmlWriter.Create(xml, settings))
{
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add("", "");
XmlSerializer xs = new XmlSerializer(typeof(CDEntry));
xs.Serialize(xw, this, ns);
}
PersistenceProxy.SaveObject("CDA:" + this.Discid, xml.ToValidXml(), false);
}
public static void Save(Playlist playlist)
{
if (_isLoading)
{
playlist.AbortLoad();
}
else
{
string persistedPlaylist = playlist.SaveM3UPlaylistAsString();
PersistenceProxy.SaveObject(true, "PersistentPlaylist", persistedPlaylist);
}
}
public static List <string> GetFavoriteFolders(string favFoldersHiveName)
{
List <string> favoriteFolders = new List <string>();
string str = PersistenceProxy.ReadObject(favFoldersHiveName, string.Empty);
if (!string.IsNullOrEmpty(str))
{
string[] favFolders = StringUtils.ToStringArray(str, '?');
favoriteFolders.AddRange(favFolders);
}
return(favoriteFolders);
}
public static void SetFavoriteFolders(List <string> folders, string favFoldersHiveName)
{
List <string> favoriteFolders = new List <string>();
favoriteFolders.AddRange(folders);
string favFolders = StringUtils.FromStringArray(favoriteFolders.ToArray(), '?');
if (favFolders == null)
{
favFolders = string.Empty;
}
PersistenceProxy.SaveObject(favFoldersHiveName, favFolders);
}
static AppConfig()
{
if (string.Compare(Constants.PersistenceServiceShortName,
ApplicationInfo.ApplicationName, true) != 0)
{
_cultures.Add("en", new CultureInfo("en"));
_cultures.Add("de", new CultureInfo("de"));
_cultures.Add("fr", new CultureInfo("fr"));
_cultures.Add("ro", new CultureInfo("ro"));
_skinType = PersistenceProxy.ReadObject("SkinType", "Black");
string defLangId = Regedit.InstallLanguageID;
_languageId = PersistenceProxy.ReadObject("LanguageID", defLangId);
}
}
public static OnlineMediaData LoadOnlineMediaData()
{
lock (_dbLock)
{
OnlineMediaData internalDatabase = null;
try
{
// Fill with Internal stations list from Persistence Service
string xml = PersistenceProxy.ReadObject("OnlineMediaData", string.Empty, false);
if (!string.IsNullOrEmpty(xml))
{
using (StringReader sr = new StringReader(xml))
using (XmlReader xr = XmlReader.Create(sr))
{
XmlSerializer xs = new XmlSerializer(typeof(OnlineMediaData));
internalDatabase = xs.Deserialize(xr) as OnlineMediaData;
}
}
}
catch (Exception ex)
{
internalDatabase = null;
Logger.LogException(ex);
}
// Try fall back to DefaultOnlineMediaData.xml
if (internalDatabase == null)
{
using (FileStream fs = new FileStream(@".\DefaultOnlineMediaData.xml", FileMode.Open, FileAccess.Read))
using (XmlReader xr = XmlReader.Create(fs))
{
XmlSerializer xs = new XmlSerializer(typeof(OnlineMediaData));
internalDatabase = xs.Deserialize(xr) as OnlineMediaData;
}
}
// Try fallback to empty data
if (internalDatabase == null)
{
internalDatabase = new OnlineMediaData();
}
return(internalDatabase);
}
}
public static void Load(ref Playlist playlist)
{
string persistedPlaylist = PersistenceProxy.ReadObject(true, "PersistentPlaylist", string.Empty);
if (string.IsNullOrEmpty(persistedPlaylist) == false)
{
try
{
_isLoading = true;
playlist.LoadM3UPlaylistFromString(persistedPlaylist);
}
finally
{
_isLoading = false;
}
}
}
private static string[] ReadAddonConfig(string keyBase)
{
string[] names = null;
string namesRaw = PersistenceProxy.ReadObject(true, keyBase, string.Empty, false);
if (!string.IsNullOrEmpty(namesRaw))
{
names = namesRaw.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string name in names)
{
string val = PersistenceProxy.ReadObject(true, name, string.Empty, false);
_assemblies.Add(name, val);
}
}
return(names);
}
public static CDEntry LoadPersistentDisc(string discId)
{
string xml = PersistenceProxy.ReadObject("CDA:" + discId, string.Empty, false);
if (!string.IsNullOrEmpty(xml))
{
XmlReaderSettings settings = new XmlReaderSettings();
using (StringReader sr = new StringReader(xml))
using (XmlReader xr = XmlReader.Create(sr))
{
XmlSerializer xs = new XmlSerializer(typeof(CDEntry));
return(xs.Deserialize(xr) as CDEntry);
}
}
return(null);
}
internal static void MarkForUninstall(string assembly)
{
string markedForUninstall = PersistenceProxy.ReadObject(true, "MarkedForUninstall", string.Empty, false);
List <string> filesToDelete = new List <string>();
IEnumerable <string> files = PathUtils.EnumFiles(Application.StartupPath, $"{assembly}*");
foreach (string asmFile in files)
{
Assembly asm = Assembly.LoadFrom(asmFile);
if (asm != null)
{
filesToDelete.Add(asmFile);
foreach (CultureInfo ci in AppConfig.SupportedCultures)
{
try
{
Assembly satAsm = asm.GetSatelliteAssembly(ci);
if (satAsm != null)
{
string path = satAsm.Location.ToLowerInvariant();
if (!filesToDelete.Contains(path))
{
filesToDelete.Add(path.ToLowerInvariant());
}
}
}
catch (Exception ex)
{
Logger.LogException(ex);
}
}
foreach (string file in filesToDelete)
{
markedForUninstall += file;
markedForUninstall += "|";
}
}
}
PersistenceProxy.SaveObject(true, "MarkedForUninstall", markedForUninstall, false);
}
public static void Save()
{
try
{
StringBuilder sb = new StringBuilder();
KeysConverter kc = new KeysConverter();
for (OPMShortcut cmd = CmdFirst; cmd < CmdLast; cmd++)
{
sb.AppendLine(string.Format("{0};{1};{2}",
cmd,
kc.ConvertToInvariantString(keyCommands[(int)cmd].KeyData),
kc.ConvertToInvariantString(altKeyCommands[(int)cmd].KeyData)));
}
PersistenceProxy.SaveObject(true, "Keymap", sb.ToString());
}
catch { }
}
private void ScheduleForUninstall(string assembly)
{
string addons = string.Empty;
List <AddonInfo> itemsToDisable = new List <AddonInfo>();
foreach (AddonInfo ai in addonList.AllAddons)
{
string[] codebaseParts = ai.CodeBase.Split(new char[] { '|' });
if (codebaseParts.Length > 0 &&
codebaseParts[0].ToLowerInvariant() == assembly.ToLowerInvariant())
{
addons += ai.TranslatedName;
addons += "\n";
itemsToDisable.Add(ai);
}
}
if (itemsToDisable.Count < 1)
{
return;
}
if (itemsToDisable.Count == 1 ||
(MessageDisplay.Query(Translator.Translate("TXT_SHAREDADDONS", addons),
Translator.Translate("TXT_CAUTION"), MessageBoxIcon.Question) == DialogResult.Yes))
{
// Clear for uninstalling.
foreach (AddonInfo ai in itemsToDisable)
{
PersistenceProxy.DeleteObject(ai.Name, false);
addonList.RemoveAddon(ai);
}
AddonsConfig.MarkForUninstall(assembly);
_uninstallScheduled = true;
}
}
private static void UninstallMarkedItems()
{
string[] names = null;
string namesRaw = PersistenceProxy.ReadObject(true, "MarkedForUninstall", string.Empty, false);
if (!string.IsNullOrEmpty(namesRaw))
{
names = namesRaw.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string name in names)
{
try
{
UninstallAddonLibrary(name);
}
catch (Exception ex)
{
Logger.LogException(ex);
}
}
PersistenceProxy.SaveObject(true, "MarkedForUninstall", string.Empty, false);
}
}
public static void Load()
{
try
{
KeysConverter kc = new KeysConverter();
string keymap = PersistenceProxy.ReadObject(true, "Keymap", string.Empty);
if (string.IsNullOrEmpty(keymap) == false)
{
string[] lines = keymap.Split("\r\n".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
if (lines != null)
{
foreach (string line in lines)
{
string[] fields = line.Split(";".ToCharArray());
if (fields.Length >= 2)
{
OPMShortcut cmd = (OPMShortcut)Enum.Parse(typeof(OPMShortcut), fields[0]);
keyCommands[(int)cmd] = new KeyEventArgs((Keys)kc.ConvertFromInvariantString(fields[1]));
if (fields.Length >= 3)
{
altKeyCommands[(int)cmd] = new KeyEventArgs((Keys)kc.ConvertFromInvariantString(fields[2]));
}
else
{
altKeyCommands[(int)cmd] = new KeyEventArgs(keyCommands[(int)cmd].KeyData);
}
}
}
}
}
}
catch
{
}
}
private void SaveGroup(List <AddonInfo> addonList, string groupName)
{
string addons = string.Empty;
foreach (AddonInfo ai in addonList)
{
if (ai.Selected || ai.IsRequired)
{
addons += ai.Name;
addons += "|";
PersistenceProxy.SaveObject(true, ai.Name, ai.CodeBase, false);
}
}
if (addons.Length > 0)
{
PersistenceProxy.SaveObject(true, groupName, addons.TrimEnd(new char[] { '|' }), false);
}
else
{
PersistenceProxy.SaveObject(true, groupName, string.Empty, false);
}
}
public static IPerformanceResult GetPerformanceResult(PersistenceProxy databaseProxy, string runtimeHash, int session)
{
// TODO not implemented
return(new PerformanceResult());
}
