public static List <string> getFieldNameListFromList <T>(string FieldNameToGet, List <T> elements) where T : DBTable { MPTVSeriesLog.Write("Elements found: " + elements.Count.ToString()); List <string> results = new List <string>(); foreach (T elem in elements) { try { results.Add((string)elem[FieldNameToGet]); } catch (Exception) { MPTVSeriesLog.Write("Wrong call of getPropertyListFromList<T,P>: Type " + elem.GetType().Name); } } return(results); }
public virtual DBValue this[String fieldName] { get { DBField result; if (!m_fields.TryGetValue(fieldName, out result)) { return(string.Empty); } return(result.Value); } set { try { DBField result; if (m_fields.TryGetValue(fieldName, out result)) { if (result.Value != value) { if (result.Type == DBField.cTypeInt) { result.Value = (long)value; } else { result.Value = value; } result.WasChanged = true; m_CommitNeeded = true; } } else { AddColumn(fieldName, new DBField(DBField.cTypeString)); this[fieldName] = value; } } catch (SystemException) { MPTVSeriesLog.Write("Cast exception when trying to assign " + value + " to field " + fieldName + " in table " + m_tableName); } } }
public int MovePlayListItemDown(int iItem) { int selectedItemIndex = -1; if (iItem < 0 || iItem >= _listPlayListItems.Count) { return(-1); } int iNextItem = iItem + 1; if (iNextItem >= _listPlayListItems.Count) { iNextItem = 0; } PlayListItem playListItem1 = _listPlayListItems[iItem]; PlayListItem playListItem2 = _listPlayListItems[iNextItem]; if (playListItem1 == null || playListItem2 == null) { return(-1); } try { MPTVSeriesLog.Write(string.Format("Moving playlist item {0} down. Old index:{1}, new index{2}", playListItem1.EpisodeName, iItem, iNextItem)); System.Threading.Monitor.Enter(this); _listPlayListItems[iItem] = playListItem2; _listPlayListItems[iNextItem] = playListItem1; selectedItemIndex = iNextItem; } catch (Exception ex) { MPTVSeriesLog.Write(string.Format("PlayList.MovePlayListItemDown caused an exception: {0}", ex.Message)); selectedItemIndex = -1; } finally { System.Threading.Monitor.Exit(this); } return(selectedItemIndex); }
/// <summary> /// Creates a List of Fanarts in your Thumbs folder /// </summary> void getFanart() { string fanartFolder = Settings.GetPath(Settings.Path.fanart); // Check if Fanart folder exists in MediaPortal's Thumbs directory if (System.IO.Directory.Exists(fanartFolder)) { MPTVSeriesLog.Write("Checking for Fanart on series: ", Helper.getCorrespondingSeries(_seriesID).ToString(), MPTVSeriesLog.LogLevel.Debug); try { // Create a Filename filter for Season / Series Fanart string seasonFilter = string.Format(seasonFanArtFilenameFormat, _seriesID, _seasonIndex); string seriesFilter = string.Format(seriesFanArtFilenameFormat, _seriesID); string filter = _seasonMode ? seasonFilter : seriesFilter; _fanArts = new List <string>(); // Store list of all fanart files found in all sub-directories of fanart thumbs folder _fanArts.AddRange(System.IO.Directory.GetFiles(fanartFolder, filter, System.IO.SearchOption.AllDirectories)); // If no Season Fanart was found, see if any Series fanart exists if (_fanArts.Count == 0 && _seasonMode) { MPTVSeriesLog.Write("No Season Fanart found on disk, searching for series fanart", MPTVSeriesLog.LogLevel.Debug); _fanArts.AddRange(System.IO.Directory.GetFiles(fanartFolder, seriesFilter, System.IO.SearchOption.AllDirectories)); } // Remove any files that we dont want e.g. thumbnails in the _cache folder // and Season fanart if we are not in Season Mode if (!_seasonMode) { removeSeasonFromSeries(); } removeFromFanart("_cache"); MPTVSeriesLog.Write("Number of fanart found on disk: ", _fanArts.Count.ToString(), MPTVSeriesLog.LogLevel.Debug); } catch (Exception ex) { MPTVSeriesLog.Write("An error occured looking for fanart: " + ex.Message); } } }
private void radOptionSelected(int selectedOption) { if (selectedOption > m_descriptor.m_List.Count) { MPTVSeriesLog.Write("Selected an unavailable Option...."); return; } Feedback.CItem item = m_descriptor.m_List[selectedOption]; if (item != null) { if (item.m_sDescription != "") { this.Text = origTitle + " (" + item.m_sName + ")"; this.textbox_Description.Text = item.m_sDescription; } SelectedItemRadOption = item; button_OK.Text = m_descriptor.m_sbtnOKLabel; } }
private void onStopExternal(Process proc, bool waitForExit) { if (!listenToExternalPlayerEvents) { return; } MPTVSeriesLog.Write("Playback Stopped in External Player:" + m_currentEpisode.ToString()); // Exit fullscreen Video so we can see main facade again if (GUIGraphicsContext.IsFullScreenVideo) { GUIGraphicsContext.IsFullScreenVideo = false; } // Mark Episode as watched regardless and prompt for rating bool markAsWatched = (DBOption.GetOptions(DBOption.cWatchedAfter) > 0 && m_currentEpisode[DBOnlineEpisode.cWatched] == 0); PlaybackOperationEnded(markAsWatched); }
string RunReplacements(Dictionary <Regex, string> replacements, string runAgainst) { string _beforeReplacement = runAgainst; foreach (var replacement in replacements) { if (replacement.Key.IsMatch(runAgainst) && tags.Contains(replacement.Key.ToString())) { m_Tags.Add(replacement.Key.ToString()); } runAgainst = replacement.Value.Equals("<RomanToArabic>", StringComparison.OrdinalIgnoreCase) // special case romans ? replacement.Key.Replace(runAgainst, m => " " + Parse1To19RomanNumberOrKeep(m.Value) + " ") : replacement.Key.Replace(runAgainst, replacement.Value); } MPTVSeriesLog.Write("Replacement: " + _beforeReplacement + " -> " + runAgainst, MPTVSeriesLog.LogLevel.Debug); return(runAgainst); }
private void onStopExternal(Process proc, bool waitForExit) { if (!listenToExternalPlayerEvents) { return; } MPTVSeriesLog.Write("Playback Stopped in External Player"); SetAsWatched(); PlayNext(); if (!g_Player.Playing) { g_Player.Release(); // Clear focus when playback ended GUIMessage msg = new GUIMessage(GUIMessage.MessageType.GUI_MSG_ITEM_FOCUS, 0, 0, 0, -1, 0, null); GUIGraphicsContext.SendMessage(msg); } }
/// <summary> /// Read Logo Rules and Import into Database /// </summary> /// <param name="doc"></param> private static void GetLogoRules(XmlDocument doc) { XmlNode node = null; node = doc.DocumentElement.SelectSingleNode("/settings/logos"); if (node != null && node.Attributes.GetNamedItem("import").Value.ToLower() == "true") { MPTVSeriesLog.Write("Loading Skin Logo Rules", MPTVSeriesLog.LogLevel.Normal); DBOption.SetOptions("logoConfig", ""); List <string> logos = new List <string>(); foreach (string rule in node.InnerText.Split('\n')) { logos.Add(rule.Trim()); } localLogos.saveToDB(logos); ImportLogos = true; } }
static string buildLogoImage(List <string> logosForBuilding, bool firstOnly, int imgWidth, int imgHeight) { try { if (logosForBuilding.Count == 1 || (firstOnly && logosForBuilding.Count > 0)) { return(logosForBuilding[0]); } else if (logosForBuilding.Count > 1) { tmpFile = string.Empty; foreach (string logo in logosForBuilding) { tmpFile += System.IO.Path.GetFileNameWithoutExtension(logo); } tmpFile = Helper.PathCombine(pathfortmpfile, "TVSeriesDynLogo" + tmpFile + ".png"); Bitmap b = new Bitmap(imgWidth, imgHeight); Image img = b; Graphics g = Graphics.FromImage(img); appendLogos(logosForBuilding, ref g, imgHeight, imgWidth); if (Settings.isConfig) { b.Save(tmpFile); return(tmpFile); } else { return(ImageAllocator.GetOtherImage(b, tmpFile, new Size(), true)); // don't resize in allocator } } else { return(string.Empty); } } catch (Exception ex) { MPTVSeriesLog.Write("The Logo Building Engine generated an error: " + ex.Message); return(string.Empty); } }
private void OnSavePlayList() { currentSelectedItem = m_Facade.SelectedListItemIndex; string playlistFileName = string.Empty; if (GetKeyboard(ref playlistFileName)) { string playListPath = string.Empty; playListPath = DBOption.GetOptions(DBOption.cPlaylistPath); playListPath = MediaPortal.Util.Utils.RemoveTrailingSlash(playListPath); // check if Playlist folder exists, create it if not if (!Directory.Exists(playListPath)) { try { Directory.CreateDirectory(playListPath); } catch (Exception e) { MPTVSeriesLog.Write("Error: Unable to create Playlist path: " + e.Message); return; } } string fullPlayListPath = Path.GetFileNameWithoutExtension(playlistFileName); fullPlayListPath += ".tvsplaylist"; if (playListPath.Length != 0) { fullPlayListPath = playListPath + @"\" + fullPlayListPath; } PlayList playlist = new PlayList(); for (int i = 0; i < m_Facade.Count; ++i) { GUIListItem listItem = m_Facade[i]; PlayListItem playListItem = new PlayListItem(); playListItem.Episode = listItem.TVTag as DBEpisode; playlist.Add(playListItem); } PlayListIO saver = new PlayListIO(); saver.Save(playlist, fullPlayListPath); } }
public static void SaveXmlCache(string filename, XmlNode node) { // create cached document try { MPTVSeriesLog.Write("Saving xml to file cache: " + filename, MPTVSeriesLog.LogLevel.Debug); XmlDocument doc = new XmlDocument(); doc.LoadXml(node.OuterXml); if (!Directory.Exists(Path.GetDirectoryName(filename))) { Directory.CreateDirectory(Path.GetDirectoryName(filename)); } doc.Save(filename); } catch (Exception e) { MPTVSeriesLog.Write("Failed to save xml to cache: {0}", filename); MPTVSeriesLog.Write("Exception: {0}", e.Message); } }
public void HideSeason(bool hide) { MPTVSeriesLog.Write(string.Format("{0} series {1}, season {2} from view", (hide ? "Hiding" : "UnHiding"), Helper.getCorrespondingSeries(this[DBSeason.cSeriesID]), this[DBSeason.cIndex])); // respect 'Show Local Files Only' setting List <DBEpisode> episodes = DBEpisode.Get(int.Parse(this[DBSeason.cSeriesID]), int.Parse((this[DBSeason.cIndex]))); if (episodes != null) { foreach (DBEpisode episode in episodes) { // Hide Episodes episode.HideEpisode(hide); } } // Hide Season this[DBSeason.cHidden] = hide; this.Commit(); }
public bool Insert(PlayListItem item, PlayListItem afterThisItem) { bool success = false; if (item == null) { return(success); } for (int i = 0; i < _listPlayListItems.Count; ++i) { if (afterThisItem.FileName == _listPlayListItems[i].FileName) { MPTVSeriesLog.Write(string.Format("Playlist: Insert {0} after {1}", item.FileName, afterThisItem.FileName)); _listPlayListItems.Insert(i + 1, item); success = true; } } return(success); }
public GetFanart(int SeriesID) { XmlNode node = OnlineAPI.getBannerList(SeriesID); if (node == null) { return; } foreach (XmlNode fanartNode in node.SelectNodes("/Banners/Banner[BannerType='fanart']")) { DBFanart dbf = new DBFanart(); foreach (XmlNode propertyNode in fanartNode.ChildNodes) { try { dbf[propertyNode.Name] = propertyNode.InnerText; } catch (Exception ex) { MPTVSeriesLog.Write("Error adding Fanart Property to DBEntry: " + propertyNode.Name + " - " + ex.Message); } } // Sync local files with database string localPath = dbf[DBFanart.cBannerPath]; localPath = localPath.Replace("/", @"\"); string fanart = Helper.PathCombine(Settings.GetPath(Settings.Path.fanart), localPath); if (File.Exists(fanart)) { dbf[DBFanart.cLocalPath] = localPath; } else { dbf[DBFanart.cLocalPath] = string.Empty; } dbf[DBFanart.cSeriesID] = SeriesID; _fanart.Add(dbf); } }
void workerWatcher_DoWork(object sender, DoWorkEventArgs e) { System.Threading.Thread.CurrentThread.Priority = ThreadPriority.Lowest; // delay the start of file monitoring for a small period // this doesnt really need a config setting but can be manually overridden in DB option // purpose of the delay is to allow network devices to get ready after fresh boot from windows // and resume from standby...benifits UNC shares as Mapped drives are picked up from Device Manager events. // also DoFileScan can be expensive, so we dont want to do this on startup while other plugins/background tasks // are running as well. Thread.Sleep((int)DBOption.GetOptions(DBOption.cDelayImportPathMonitoringValue) * 1000); MPTVSeriesLog.Write("File Watcher: Starting File System Watcher Background Task", MPTVSeriesLog.LogLevel.Normal); setUpWatches(); // do the initial scan m_PreviousScan = Filelister.GetFiles(m_ScannedFolders); m_PreviousScanRemovable = Filelister.GetFiles(GetDeviceManagerWatchedFolders()); DateTime timeLastScan = DateTime.Now; // then start the watcher loop while (!worker.CancellationPending) { TimeSpan tsUpdate = DateTime.Now - timeLastScan; if ((int)tsUpdate.TotalMinutes >= m_nScanLapse) { timeLastScan = DateTime.Now; DoFileScan(); } signalModifiedFiles(); if (refreshWatchers) { setUpWatches(); } Thread.Sleep(1000); } }
void setUpWatches() { if (m_watchersList.Count > 0) { MPTVSeriesLog.Write("File Watcher: Cleaning up File System Watchers", MPTVSeriesLog.LogLevel.Normal); // do some cleanup first, remove the existing watchers foreach (FileSystemWatcher watcher in m_watchersList) { watcher.EnableRaisingEvents = false; watcher.Changed -= new FileSystemEventHandler(watcher_Changed); watcher.Created -= new FileSystemEventHandler(watcher_Changed); watcher.Deleted -= new FileSystemEventHandler(watcher_Changed); watcher.Renamed -= new RenamedEventHandler(watcher_Renamed); watcher.Error -= new ErrorEventHandler(watcher_Error); } m_watchersList.Clear(); } // go through all enabled import folders, and add a watchfolder on it foreach (String sWatchedFolder in m_WatchedFolders) { if (Directory.Exists(sWatchedFolder)) { FileSystemWatcher watcher = new FileSystemWatcher(); // ZFLH watch for all types of file notification, filter in the event notification // from MSDN, filter doesn't change the amount of stuff looked at internally watcher.Path = sWatchedFolder; watcher.IncludeSubdirectories = true; watcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.Size; watcher.Changed += new FileSystemEventHandler(watcher_Changed); watcher.Created += new FileSystemEventHandler(watcher_Changed); watcher.Deleted += new FileSystemEventHandler(watcher_Changed); watcher.Renamed += new RenamedEventHandler(watcher_Renamed); watcher.Error += new ErrorEventHandler(watcher_Error); watcher.EnableRaisingEvents = true; m_watchersList.Add(watcher); } } refreshWatchers = false; }
private void worker_DoWork(object sender, DoWorkEventArgs e) { System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.Lowest; List <String> listFolders = new List <string>(); DBImportPath[] importPathes = DBImportPath.GetAll(); if (importPathes != null) { foreach (DBImportPath importPath in importPathes) { if (importPath[DBImportPath.cEnabled] != 0) { listFolders.Add(importPath[DBImportPath.cPath]); } } } List <PathPair> files = Filelister.GetFiles(listFolders); MPTVSeriesLog.Write("Found " + files.Count.ToString() + " supported video files in your import paths"); e.Result = Parse(files); }
public static SQLiteResultSet Execute(String query) { if (m_db == null) { InitDB(); } SQLite.NET.SQLiteResultSet result; try { MPTVSeriesLog.Write(string.Format("Executing SQL query. Query = '{0}'", query), MPTVSeriesLog.LogLevel.DebugSQL); result = m_db.Execute(query); MPTVSeriesLog.Write(string.Format("Successfully executed SQL query. Row Count = '{0}'", result.Rows.Count), MPTVSeriesLog.LogLevel.DebugSQL); return(result); } catch (Exception ex) { MPTVSeriesLog.Write("SQL Execution Failed. Reason = '{0}', Query = '{1}'", ex.Message, query); return(new SQLiteResultSet()); } }
public static void RemoveWatchDrive(string path) { string driveLetter = GetDriveLetter(path); if (driveLetter == null) { return; } lock (syncRoot) { if (watchedDrives != null && watchedDrives.Contains(driveLetter)) { watchedDrives.Remove(driveLetter); MPTVSeriesLog.Write("Removed " + driveLetter + " from Disk Watcher", MPTVSeriesLog.LogLevel.Normal); if (watchedDrives.Count == 0) { StopDiskWatcher(); } } } }
public GetLanguages() { XmlNode rootNode = Online_Parsing_Classes.OnlineAPI.GetLanguages(); if (rootNode != null) { Language lang = null; foreach (XmlNode itemNode in rootNode.ChildNodes) { lang = new Language(); foreach (XmlNode node in itemNode) { if (node.Name == "id") { int.TryParse(node.InnerText, out lang.Id); } if (node.Name == "name") { lang.Name = node.InnerText; } if (node.Name == "abbreviation") { lang.Abbreviation = node.InnerText; try { lang.EnglishName = new System.Globalization.CultureInfo(lang.Abbreviation).EnglishName; } catch { MPTVSeriesLog.Write($"Unable to get English name for language code '{lang.Abbreviation}'", MPTVSeriesLog.LogLevel.Debug); } } } if (lang.Id != default(int) && lang.EnglishName.Length > 0 && !lang.EnglishName.StartsWith("Unknown")) { languages.Add(lang); } } } }
public static void CreateDBIndices(string sCommand, string sTable, bool bSetFlag) { try { switch (sTable) { case "online_episodes": if (m_bIndexOnlineEpisodes) { return; } m_bIndexOnlineEpisodes = bSetFlag; break; case "local_episodes": if (m_bIndexLocalEpisodes) { return; } m_bIndexLocalEpisodes = bSetFlag; break; case "local_series": if (m_bIndexLocalSeries) { return; } m_bIndexLocalSeries = bSetFlag; break; default: return; } m_db.Execute(sCommand); } catch (Exception e) { MPTVSeriesLog.Write("Warning, failed to create Index: " + e.Message); } }
private static bool LoadMirrorList(String sServer) { try { XmlNode node = Online_Parsing_Classes.OnlineAPI.GetMirrors(AppendAPI(sServer, true)); if (node == null) { return(false); } int count = 0; foreach (XmlNode itemNode in node.ChildNodes) { // create a new OnlineMirror object var mirror = new DBOnlineMirror(); foreach (XmlNode propertyNode in itemNode.ChildNodes) { if (mOnlineToFieldMap.ContainsKey(propertyNode.Name)) { mirror[mOnlineToFieldMap[propertyNode.Name]] = propertyNode.InnerText; } else { mirror[propertyNode.Name] = propertyNode.InnerText; } } count++; mMemoryMirrors.Add(mirror); } MPTVSeriesLog.Write("Received " + count.ToString() + " mirror site(s) from " + sServer); return(true); } catch (Exception ex) { MPTVSeriesLog.Write(string.Format("Error: unable to retrieve list of mirrors online: {0}", ex.Message)); return(false); } }
public static bool IsAssemblyAvailable(string name, Version ver) { bool result = false; MPTVSeriesLog.Write(string.Format("Checking whether assembly {0} is available and loaded...", name), MPTVSeriesLog.LogLevel.Debug); Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies(); foreach (Assembly a in assemblies) { try { if (a.GetName().Name == name && a.GetName().Version >= ver) { MPTVSeriesLog.Write(string.Format("Assembly {0} is available and loaded.", name), MPTVSeriesLog.LogLevel.Debug); result = true; break; } } catch { MPTVSeriesLog.Write(string.Format("Assembly.GetName() call failed for '{0}'!\n", a.Location)); } } if (!result) { MPTVSeriesLog.Write(string.Format("Assembly {0} is not loaded (not available?), trying to load it manually...", name), MPTVSeriesLog.LogLevel.Debug); try { //Assembly assembly = AppDomain.CurrentDomain.Reflection(new AssemblyName(name)); Assembly assembly = Assembly.ReflectionOnlyLoad(name); MPTVSeriesLog.Write(string.Format("Assembly {0} is available and loaded successfully.", name), MPTVSeriesLog.LogLevel.Debug); result = true; } catch (Exception e) { MPTVSeriesLog.Write(string.Format("Assembly {0} is unavailable, load unsuccessful: {1}:{2}", name, e.GetType(), e.Message), MPTVSeriesLog.LogLevel.Debug); } } return(result); }
public bool Insert(PlayListItem item, int currentItem) { bool success = false; if (item == null) { return(success); } MPTVSeriesLog.Write(string.Format("Playlist: Insert {0} at {1}", item.FileName, Convert.ToString(currentItem))); if (currentItem < _listPlayListItems.Count) { _listPlayListItems.Insert(currentItem + 1, item); success = true; } else { _listPlayListItems.Add(item); success = true; } return(success); }
/// <summary> /// Read Graphics Quality Settings and Import into Database /// </summary> /// <param name="doc"></param> private static void GetGraphicsQuality(XmlDocument doc) { XmlNode node = null; XmlNode innerNode = null; node = doc.DocumentElement.SelectSingleNode("/settings/graphicsquality"); if (node != null && node.Attributes.GetNamedItem("import").Value.ToLower() == "true") { MPTVSeriesLog.Write("Loading Skin Thumbnail Graphics Quality", MPTVSeriesLog.LogLevel.Normal); innerNode = node.SelectSingleNode("seriesbanners"); if (innerNode != null) { DBOption.SetOptions(DBOption.cQualitySeriesBanners, innerNode.InnerText.Trim()); } innerNode = node.SelectSingleNode("seriesposters"); if (innerNode != null) { DBOption.SetOptions(DBOption.cQualitySeriesPosters, innerNode.InnerText.Trim()); } innerNode = node.SelectSingleNode("seriescoverflow"); if (innerNode != null) { DBOption.SetOptions(DBOption.cQualitySeriesPosters, innerNode.InnerText.Trim()); } innerNode = node.SelectSingleNode("seasonbanners"); if (innerNode != null) { DBOption.SetOptions(DBOption.cQualitySeasonBanners, innerNode.InnerText.Trim()); } innerNode = node.SelectSingleNode("episodethumbs"); if (innerNode != null) { DBOption.SetOptions(DBOption.cQualityEpisodeImages, innerNode.InnerText.Trim()); } ImportGraphics = true; } }
public static bool DownloadFile(string url, string localFile) { WebClient webClient = new WebClient(); webClient.Headers.Add("user-agent", Settings.UserAgent); try { Directory.CreateDirectory(Path.GetDirectoryName(localFile)); if (!File.Exists(localFile) || ImageAllocator.LoadImageFastFromFile(localFile) == null) { MPTVSeriesLog.Write("Downloading new file from: " + url, MPTVSeriesLog.LogLevel.Debug); webClient.DownloadFile(url, localFile); } return(true); } catch (WebException) { MPTVSeriesLog.Write("File download failed from '{0}' to '{1}'", url, localFile); return(false); } }
private static void Backup() { MPTVSeriesLog.Write("Backing up database"); string backupDirectory = Config.GetSubFolder(Config.Dir.Database, "MP-TVSeries_Backup"); string sourceFile = Settings.GetPath(Settings.Path.database); string destinationFile = Path.Combine(backupDirectory, "TVSeriesDatabase4.db3"); try { if (!Directory.Exists(backupDirectory)) { Directory.CreateDirectory(backupDirectory); } File.Copy(sourceFile, destinationFile, true); } catch (Exception ex) { MPTVSeriesLog.Write("Failed to backup database. Source File = '{0}', Destination File = '{1}', Reason = '{2}'", sourceFile, destinationFile, ex.Message); } }
void OnPlaybackChanged(g_Player.MediaType type, int timeMovieStopped, string filename) { if (PlayBackOpWasOfConcern(g_Player.IsVideo? g_Player.MediaType.Video : g_Player.MediaType.Unknown, g_Player.CurrentFile)) { if (PlayPropertyUpdater.IsBusy) { PlayPropertyUpdater.CancelAsync(); } LogPlayBackOp("changed", g_Player.CurrentFile); try { #region Set Resume Point or Watched double watchedAfter = DBOption.GetOptions(DBOption.cWatchedAfter); if (!m_previousEpisode[DBOnlineEpisode.cWatched] && (timeMovieStopped / playlistPlayer.g_Player.Duration) > watchedAfter / 100) { m_previousEpisode[DBEpisode.cStopTime] = 0; m_previousEpisode.Commit(); MPTVSeriesLog.Write("This episode counts as watched"); MarkEpisodeAsWatched(m_previousEpisode); SetGUIProperties(true); } else { m_previousEpisode[DBEpisode.cStopTime] = timeMovieStopped; m_previousEpisode.Commit(); SetGUIProperties(true); } #endregion m_previousEpisode = null; } catch (Exception e) { MPTVSeriesLog.Write("TVSeriesPlugin.VideoHandler.OnPlaybackChanged()\r\n" + e.ToString()); } } }
public static DBValue GetOptions(string property) { try { lock (thisLock) { DBValue retValue; if (optionsCache.TryGetValue(property, out retValue)) { return(retValue); } // ensure our sql query will be using a valid string string convertedProperty = property; DatabaseUtility.RemoveInvalidChars(ref convertedProperty); string sqlQuery = "SELECT value FROM options WHERE property = '" + convertedProperty + "'"; SQLiteResultSet sqlResults = DBTVSeries.Execute(sqlQuery); if (sqlResults.Rows.Count > 0) { string dbValue = DatabaseUtility.Get(sqlResults, 0, "value"); if (!optionsCache.ContainsKey(property)) { optionsCache.Add(property, dbValue); } return(dbValue); } } } catch (Exception ex) { MPTVSeriesLog.Write("An error occurred (" + ex.Message + ")."); } return(null); }