/// <summary>
/// Erstellt einen neuen Zugriff.
/// </summary>
/// <param name="profile">Das zu verwendende Geräteprofil.</param>
/// <param name="target">Die aktuelle Zieladresse für die Nutzdaten.</param>
/// <returns>Die gewünschte Steuerung.</returns>
/// <exception cref="ArgumentNullException">Mindestens ein Parameter wurde nicht angegeben.</exception>
public static ZappingProxy Create(ProfileState profile, string target)
{
// Validate
if (profile == null)
{
throw new ArgumentNullException(nameof(profile));
}
if (string.IsNullOrEmpty(target))
{
throw new ArgumentNullException(nameof(target));
}
// Create controlling information
var now = DateTime.UtcNow;
var primary =
new VCRRecordingInfo
{
Source = new SourceSelection {
ProfileName = profile.ProfileName, DisplayName = VCRJob.ZappingName
},
FileName = Path.Combine(profile.Server.JobManager.CollectorDirectory.FullName, "zapping.live"),
ScheduleUniqueID = Guid.NewGuid(),
EndsAt = now.AddMinutes(2),
Name = VCRJob.ZappingName,
DisableHibernation = true,
StartsLate = false,
IsHidden = false,
StartsAt = now,
};
// Forward
return(new ZappingProxy(profile, primary, target));
}
/// <summary>
/// Kovertiert einen Protokolleintrag in ein für den Client nützliches Format.
/// </summary>
/// <param name="entry">Der originale Eintrag.</param>
/// <returns>Der zugehörige Protokolleintrag.</returns>
public static ProtocolEntry Create( VCRRecordingInfo entry )
{
// Single recording - typically a task
var source = entry.Source;
var sourceName = source.DisplayName;
// Create
var protocol =
new ProtocolEntry
{
PrimaryFile = string.IsNullOrEmpty( entry.FileName ) ? null : Path.GetFileName( entry.FileName ),
Files = entry.RecordingFiles.Select( file => file.Path ).Where( File.Exists ).ToArray(),
Source = entry.Source.DisplayName,
StartTime = entry.PhysicalStart,
EndTime = entry.EndsAt,
};
// Finish
if (VCRJob.ProgramGuideName.Equals( sourceName ))
protocol.SizeHint = $"{entry.TotalSize:N0} Einträge";
else if (VCRJob.SourceScanName.Equals( sourceName ))
protocol.SizeHint = $"{entry.TotalSize:N0} Quellen";
else
protocol.SizeHint = PlanCurrent.GetSizeHint( entry.TotalSize );
// Report
return protocol;
}
/// <summary>
/// Kovertiert einen Protokolleintrag in ein für den Client nützliches Format.
/// </summary>
/// <param name="entry">Der originale Eintrag.</param>
/// <returns>Der zugehörige Protokolleintrag.</returns>
public static ProtocolEntry Create(VCRRecordingInfo entry)
{
// Single recording - typically a task
var source = entry.Source;
var sourceName = source.DisplayName;
// Create
var protocol =
new ProtocolEntry
{
PrimaryFile = string.IsNullOrEmpty(entry.FileName) ? null : Path.GetFileName(entry.FileName),
Files = entry.RecordingFiles.Select(file => file.Path).Where(File.Exists).ToArray(),
Source = entry.Source.DisplayName,
StartTime = entry.PhysicalStart,
EndTime = entry.EndsAt,
};
// Finish
if (VCRJob.ProgramGuideName.Equals(sourceName))
{
protocol.SizeHint = $"{entry.TotalSize:N0} Einträge";
}
else if (VCRJob.SourceScanName.Equals(sourceName))
{
protocol.SizeHint = $"{entry.TotalSize:N0} Quellen";
}
else
{
protocol.SizeHint = PlanCurrent.GetSizeHint(entry.TotalSize);
}
// Report
return(protocol);
}
/// <summary>
/// Legt nach einer abgeschlossenen Aufzeichnung fest, wann frühestens eine Wiederholung
/// stattfinden darf.
/// </summary>
/// <param name="recording">Alle Informationen zur ausgeführten Aufzeichnung.</param>
public void SetRestartThreshold(VCRRecordingInfo recording)
{
// Forward
if (recording != null)
{
SetRestartThreshold(recording, recording.EndsAt);
}
}
/// <summary>
/// Erstellt eine neue Sammlung.
/// </summary>
/// <param name="state">Das zugehörige Geräteprofil.</param>
/// <param name="recording">Die Beschreibung der Aufgabe.</param>
/// <returns>Die gewünschte Steuerung.</returns>
public static SourceScanProxy Create( ProfileState state, VCRRecordingInfo recording )
{
// Validate
if (state == null)
throw new ArgumentNullException( nameof( state ) );
if (recording == null)
throw new ArgumentNullException( nameof( recording ) );
// Forward
return new SourceScanProxy( state, recording );
}
/// <summary>
/// Erzeugt einen Protokolleintrag.
/// </summary>
/// <param name="logEntry">Der Protokolleintrag.</param>
public void CreateLogEntry(VCRRecordingInfo logEntry)
{
// Store
if (logEntry.Source != null)
{
if (!string.IsNullOrEmpty(logEntry.Source.ProfileName))
{
SerializationTools.SafeSave(logEntry, Path.Combine(LogDirectory.FullName, DateTime.UtcNow.ToString(LogEntryDateFormat + LogEntryTimeFormat) + logEntry.Source.ProfileName + VCRRecordingInfo.FileSuffix));
}
}
}
/// <summary>
/// Erzeugt eine neue Beschreibung.
/// </summary>
/// <param name="primary">Die primäre Aufzeichnung für die Quelle, in der auch der Dateiname
/// festgelegt ist.</param>
/// <param name="target">Das aktuelle Ziel eines Netzwerkversands.</param>
/// <param name="fileMap">Die Liste aller Dateien zur Gesamtaktivität.</param>
/// <returns>Die neue Beschreibung.</returns>
public static StreamInfo Create( VCRRecordingInfo primary, string target, Dictionary<Guid, string[]> fileMap )
{
// Create new
return
new StreamInfo
{
Schedules = { ScheduleInfo.Create( primary, fileMap ) },
LiveStream = string.IsNullOrEmpty( primary.FileName ),
TargetFile = primary.FileName,
StreamsTo = target,
};
}
/// <summary>
/// Erzeugt eine neue Beschreibung.
/// </summary>
/// <param name="primary">Die primäre Aufzeichnung für die Quelle, in der auch der Dateiname
/// festgelegt ist.</param>
/// <param name="target">Das aktuelle Ziel eines Netzwerkversands.</param>
/// <param name="fileMap">Die Liste aller Dateien zur Gesamtaktivität.</param>
/// <returns>Die neue Beschreibung.</returns>
public static StreamInfo Create(VCRRecordingInfo primary, string target, Dictionary <Guid, string[]> fileMap)
{
// Create new
return
(new StreamInfo
{
Schedules = { ScheduleInfo.Create(primary, fileMap) },
LiveStream = string.IsNullOrEmpty(primary.FileName),
TargetFile = primary.FileName,
StreamsTo = target,
});
}
/// <summary>
/// Legt nach einer abgeschlossenen Aufzeichnung fest, wann frühestens eine Wiederholung
/// stattfinden darf.
/// </summary>
/// <param name="recording">Alle Informationen zur ausgeführten Aufzeichnung.</param>
/// <param name="endsAt">Der Endzeitpunkt der Aufzeichnung.</param>
public void SetRestartThreshold(VCRRecordingInfo recording, DateTime endsAt)
{
// Forward
if (recording != null)
{
if (recording.JobUniqueID.HasValue)
{
if (recording.ScheduleUniqueID.HasValue)
{
SetRestartThreshold(recording.JobUniqueID.Value, recording.ScheduleUniqueID.Value, endsAt);
}
}
}
}
/// <summary>
/// Erstellt eine neue Sammlung.
/// </summary>
/// <param name="state">Das zugehörige Geräteprofil.</param>
/// <param name="recording">Die Beschreibung der Aufgabe.</param>
/// <returns>Die gewünschte Steuerung.</returns>
public static SourceScanProxy Create(ProfileState state, VCRRecordingInfo recording)
{
// Validate
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
if (recording == null)
{
throw new ArgumentNullException(nameof(recording));
}
// Forward
return(new SourceScanProxy(state, recording));
}
/// <summary>
/// Erstellt eine neue Aktualisierung.
/// </summary>
/// <param name="state">Das zugehörige Geräteprofil.</param>
/// <param name="recording">Daten der primären Aufzeichnung.</param>
private ProgramGuideProxy(ProfileState state, VCRRecordingInfo recording)
: base(state, recording)
{
// Reset fields
if (VCRConfiguration.Current.EnableFreeSat)
{
m_extensions = EPGExtensions.FreeSatUK;
}
else
{
m_extensions = EPGExtensions.None;
}
// All sources we know about
var allSources = new Dictionary <string, SourceSelection>(StringComparer.InvariantCultureIgnoreCase);
// Load all sources of this profile
foreach (var source in VCRProfiles.GetSources(ProfileName))
{
// Remember by direct name
allSources[source.DisplayName] = source;
// allSources by unique name
allSources[source.QualifiedName] = source;
}
// Fill in all
foreach (var legacyName in VCRConfiguration.Current.ProgramGuideSources)
{
// Skip if empty
if (string.IsNullOrEmpty(legacyName))
{
continue;
}
// Locate
SourceSelection realSource;
if (allSources.TryGetValue(legacyName, out realSource))
{
m_selected.Add(realSource.Source);
}
else
{
VCRServer.Log(LoggingLevel.Full, Properties.Resources.BadEPGStation, legacyName);
}
}
}
/// <summary>
/// Erzeugt eine neue Zugriffsinstanz.
/// </summary>
/// <param name="state">Der Zustands des zugehörigen Geräteprofils.</param>
/// <param name="primary">Die primäre Aufzeichnung, auf Grund derer der Aufzeichnungsprozeß aktiviert wurde.</param>
/// <exception cref="ArgumentNullException">Es wurde kein Profil angegeben.</exception>
protected CardServerProxy(ProfileState state, VCRRecordingInfo primary)
{
// Validate
if (state == null)
{
throw new ArgumentNullException("state");
}
// Finish setup of fields and properties
RequestFinished = new ManualResetEvent(false);
// Remember
Representative = primary.Clone();
ProfileState = state;
// Make sure that we report the start
m_start = primary;
}
/// <summary>
/// Ergänzt eine weitere Aufzeichnung.
/// </summary>
/// <param name="recording">Die Daten der neuen Aufzeichnung.</param>
public virtual void Start(VCRRecordingInfo recording)
{
// Validate
if (recording == null)
{
throw new ArgumentNullException("recording");
}
// Remember synchronized
lock (m_active)
if ((m_start == null) && !m_stop.HasValue)
{
m_start = recording;
}
// Do the wakeup call
m_wakeUp.Set();
}
/// <summary>
/// Erzeugt eine neue Beschreibung.
/// </summary>
/// <param name="recording">Die Aufzeichnung, deren Daten übernommen werden sollen.</param>
/// <param name="fileMap">Alle Dateien zur Gesamtaktivität.</param>
/// <returns>Die neue Beschreibung.</returns>
public static ScheduleInfo Create( VCRRecordingInfo recording, Dictionary<Guid, string[]> fileMap )
{
// Find files
string[] files = null;
if (recording.ScheduleUniqueID.HasValue)
fileMap?.TryGetValue( recording.ScheduleUniqueID.Value, out files );
// Create new
return
new ScheduleInfo
{
ScheduleUniqueID = recording.ScheduleUniqueID.HasValue ? recording.ScheduleUniqueID.Value.ToString( "N" ).ToUpper() : null,
JobUniqueID = recording.JobUniqueID.HasValue ? recording.JobUniqueID.Value.ToString( "N" ).ToUpper() : null,
StartsAt = recording.StartsAt.GetValueOrDefault( DateTime.UtcNow ),
TotalSize = recording.TotalSize,
Source = recording.Source,
EndsAt = recording.EndsAt,
Files = files ?? _NoFiles,
Name = recording.Name,
};
}
/// <summary>
/// Ergänzt eine weitere Aufzeichnung. Ein Aufruf dieser Methode erfolgt nur, wenn
/// keine Antworten vom Aufzeichnunsprozeß ausstehen.
/// </summary>
/// <param name="recording">Die Detaildaten der Aufzeichnung.</param>
protected override void OnStartRecording(VCRRecordingInfo recording)
{
// Be safe
lock (m_recordings)
{
// Always stamp time to recording
recording.PhysicalStart = DateTime.UtcNow;
// Remember for further processing
m_allRecordings.Add(recording);
m_recordings.Add(recording);
// Make sure that all paths are unique
EnforceUniqueFileNames();
// Update end time
CalculateNewEndOfRecording();
}
// Enqueue
m_startPending = Server.BeginAddSources(new[] { recording.ToReceiveInformation() });
}
/// <summary>
/// Beginnt eine Aufzeichnung auf diesem Geräteprofil. Eventuell wird diese mit
/// einer anderen zusammen geführt.
/// </summary>
/// <param name="recording">Die gewünschte Aufzeichnung.</param>
public void StartRecording(VCRRecordingInfo recording)
{
// Protect current request against transistions
lock (m_RequestLock)
for (;;)
{
// Attach to the current request
var current = m_CurrentRequest;
// In best case we are just doing nothing
if (ReferenceEquals(current, null))
{
// Create a brand new regular recording request
var request = new RecordingProxy(this, recording);
// Activate the request
request.Start();
// We dit it
break;
}
else if (current is ZappingProxy)
{
// Regular recordings have priority over LIVE mode so request stop and try again later
current.Stop(false);
}
else if (!current.IsShuttingDown)
{
// There is a current recording which is not terminating so just join it
current.Start(recording);
// We dit it
break;
}
// Wait for transition notification
Monitor.Wait(m_RequestLock);
}
}
static void Main3(string[] args)
{
// Attach to job manager
VCRServer server = new VCRServer(new DirectoryInfo(@"C:\temp\VCR.NET 3.9 Alpha\Jobs"));
JobManager jobs = server.JobManager;
// Get the profile
Profile nexus = VCRProfiles.FindProfile("Nexus");
// Find the next recording
VCRRecordingInfo rec = jobs.FindNextJob(new DateTime(2009, 2, 19, 20, 0, 0), null, nexus);
if (null != rec)
{
if (rec.StartsAt.HasValue)
{
using (RecordingRequest recording = jobs.CreateRecording(rec, rec.StartsAt.Value, nexus))
{
// Get the information
FullInfo info0 = recording.CreateFullInformation();
// Start it
recording.BeginExecute(false);
// Report
Console.WriteLine("Recording...");
Console.ReadLine();
// Get the information
FullInfo info1 = recording.CreateFullInformation();
}
}
}
// Done
Console.WriteLine("Done");
Console.ReadLine();
}
/// <summary>
/// Erzeugt eine neue Beschreibung.
/// </summary>
/// <param name="recording">Die Aufzeichnung, deren Daten übernommen werden sollen.</param>
/// <param name="fileMap">Alle Dateien zur Gesamtaktivität.</param>
/// <returns>Die neue Beschreibung.</returns>
public static ScheduleInfo Create(VCRRecordingInfo recording, Dictionary <Guid, string[]> fileMap)
{
// Find files
string[] files = null;
if (recording.ScheduleUniqueID.HasValue)
{
fileMap?.TryGetValue(recording.ScheduleUniqueID.Value, out files);
}
// Create new
return
(new ScheduleInfo
{
ScheduleUniqueID = recording.ScheduleUniqueID.HasValue ? recording.ScheduleUniqueID.Value.ToString("N").ToUpper() : null,
JobUniqueID = recording.JobUniqueID.HasValue ? recording.JobUniqueID.Value.ToString("N").ToUpper() : null,
StartsAt = recording.StartsAt.GetValueOrDefault(DateTime.UtcNow),
TotalSize = recording.TotalSize,
Source = recording.Source,
EndsAt = recording.EndsAt,
Files = files ?? _NoFiles,
Name = recording.Name,
});
}
/// <summary>
/// Erstellt eine neue Aktualisierung.
/// </summary>
/// <param name="state">Das zugehörige Geräteprofil.</param>
/// <param name="recording">Daten der primären Aufzeichnung.</param>
private ProgramGuideProxy( ProfileState state, VCRRecordingInfo recording )
: base( state, recording )
{
// Reset fields
if (VCRConfiguration.Current.EnableFreeSat)
m_extensions = EPGExtensions.FreeSatUK;
else
m_extensions = EPGExtensions.None;
// All sources we know about
var allSources = new Dictionary<string, SourceSelection>( StringComparer.InvariantCultureIgnoreCase );
// Load all sources of this profile
foreach (var source in VCRProfiles.GetSources( ProfileName ))
{
// Remember by direct name
allSources[source.DisplayName] = source;
// allSources by unique name
allSources[source.QualifiedName] = source;
}
// Fill in all
foreach (var legacyName in VCRConfiguration.Current.ProgramGuideSources)
{
// Skip if empty
if (string.IsNullOrEmpty( legacyName ))
continue;
// Locate
SourceSelection realSource;
if (allSources.TryGetValue( legacyName, out realSource ))
m_selected.Add( realSource.Source );
else
VCRServer.Log( LoggingLevel.Full, Properties.Resources.BadEPGStation, legacyName );
}
}
static void Main_FindRecording(string[] args)
{
// Create the server
using (VCRServer server = new VCRServer(new DirectoryInfo(@"C:\temp\VCR.NET 3.9 Alpha\Jobs")))
{
// Attach to the state of a profile
ProfileState nexus = server.FindProfile("Nexus");
// Get the next job to execute
VCRRecordingInfo next = nexus.NextJob;
// Get recording information for the next jon
bool incomplete;
VCRRecordingInfo[] hidden;
FullInfo full = nexus.FindNextRecording(DateTime.UtcNow, out incomplete, out hidden);
// Prepare it
using (HardwareRequest request = nexus.CreateRecordingRequest(next, DateTime.UtcNow))
{
// Set end time
request.Recording.EndsAt = DateTime.UtcNow.AddSeconds(30);
// Report
Console.WriteLine("Recording {0}", request.Recording.FileName);
// Process it
request.Start();
// Wait
while (request.IsRunning)
{
Thread.Sleep(100);
}
}
}
}
/// <summary>
/// Erstellt eine neue Sammlung.
/// </summary>
/// <param name="state">Das zugehörige Geräteprofil.</param>
/// <param name="recording">Die Beschreibung der Aufgabe.</param>
private SourceScanProxy(ProfileState state, VCRRecordingInfo recording)
: base(state, recording)
{
// Finish
m_mergeSources = VCRConfiguration.Current.MergeSourceListUpdateResult;
}
/// <summary>
/// Erzeugt einen neuen Auftrag.
/// </summary>
/// <param name="state">Der Zustands des zugehörigen Geräteprofils.</param>
/// <param name="firstRecording">Die erste Aufzeichnung, auf Grund derer dieser Zugriff angelegt wurde.</param>
public RecordingProxy( ProfileState state, VCRRecordingInfo firstRecording )
: base( state, firstRecording )
{
}
/// <summary>
/// Ergänzt eine weitere Aufzeichnung. Ein Aufruf dieser Methode erfolgt nur, wenn
/// keine Antworten vom Aufzeichnunsprozeß ausstehen.
/// </summary>
/// <param name="recording">Die Detaildaten der Aufzeichnung.</param>
protected override void OnStartRecording( VCRRecordingInfo recording )
{
// Be safe
lock (m_recordings)
{
// Always stamp time to recording
recording.PhysicalStart = DateTime.UtcNow;
// Remember for further processing
m_allRecordings.Add( recording );
m_recordings.Add( recording );
// Make sure that all paths are unique
EnforceUniqueFileNames();
// Update end time
CalculateNewEndOfRecording();
}
// Enqueue
m_startPending = Server.BeginAddSources( new[] { recording.ToReceiveInformation() } );
}
/// <summary>
/// Erzeugt einen Protokolleintrag.
/// </summary>
/// <param name="logEntry">Der Protokolleintrag.</param>
public void CreateLogEntry( VCRRecordingInfo logEntry )
{
// Store
if (logEntry.Source != null)
if (!string.IsNullOrEmpty( logEntry.Source.ProfileName ))
SerializationTools.SafeSave( logEntry, Path.Combine( LogDirectory.FullName, DateTime.UtcNow.ToString( LogEntryDateFormat + LogEntryTimeFormat ) + logEntry.Source.ProfileName + VCRRecordingInfo.FileSuffix ) );
}
/// <summary>
/// Legt nach einer abgeschlossenen Aufzeichnung fest, wann frühestens eine Wiederholung
/// stattfinden darf.
/// </summary>
/// <param name="recording">Alle Informationen zur ausgeführten Aufzeichnung.</param>
/// <param name="endsAt">Der Endzeitpunkt der Aufzeichnung.</param>
public void SetRestartThreshold( VCRRecordingInfo recording, DateTime endsAt )
{
// Forward
if (recording != null)
if (recording.JobUniqueID.HasValue)
if (recording.ScheduleUniqueID.HasValue)
SetRestartThreshold( recording.JobUniqueID.Value, recording.ScheduleUniqueID.Value, endsAt );
}
/// <summary>
/// Legt nach einer abgeschlossenen Aufzeichnung fest, wann frühestens eine Wiederholung
/// stattfinden darf.
/// </summary>
/// <param name="recording">Alle Informationen zur ausgeführten Aufzeichnung.</param>
public void SetRestartThreshold( VCRRecordingInfo recording )
{
// Forward
if (recording != null)
SetRestartThreshold( recording, recording.EndsAt );
}
/// <summary>
/// Meldet, dass eine Aufzeichnung nun beginnen sollte.
/// </summary>
/// <param name="item">Die zu startende Aufzeichnung.</param>
/// <param name="planner">Die Planungsinstanz.</param>
/// <param name="context">Zusatzinformationen zur Aufzeichnungsplanung.</param>
void IRecordingPlannerSite.Start(IScheduleInformation item, RecordingPlanner planner, PlanContext context)
{
// We are no longer active - simulate start and do nothing
if (!m_plannerActive)
{
// Make planner believe we did it
planner.Start(item);
// Make sure that we wake up after the grace period
if (PowerManager.IsSuspended && VCRConfiguration.Current.SuppressDelayAfterForcedHibernation)
{
Tools.ExtendedLogging("Hibernation Delay is disabled and can not be enforced");
}
else
{
m_timer.SecondsToWait = VCRConfiguration.Current.DelayAfterForcedHibernation.TotalSeconds;
}
// Done
return;
}
// Report
VCRServer.Log(LoggingLevel.Schedules, "Start recording '{0}'", item.Definition.Name);
// Locate the profile - if we don't find it we are in big trouble!
ProfileState profile;
if (!m_profiles.TryGetValue(item.Resource.Name, out profile))
{
return;
}
// Mark as pending
m_pendingSchedule = item;
m_pendingStart = true;
// Create the recording
var recording = VCRRecordingInfo.Create(item, context);
// Check for EPG
var guideUpdate = item.Definition as ProgramGuideTask;
if (guideUpdate != null)
{
// Start a new guide collector
m_pendingActions += ProgramGuideProxy.Create(profile, recording).Start;
}
else
{
// Check for PSI
var sourceUpdate = item.Definition as SourceListTask;
if (sourceUpdate != null)
{
// Start a new update
m_pendingActions += SourceScanProxy.Create(profile, recording).Start;
}
else
{
// Start a regular recording - profile will decide if to join an existing recording
m_pendingActions += () => profile.StartRecording(recording);
}
}
}
/// <summary>
/// Erzeugt einen neuen Auftrag.
/// </summary>
/// <param name="state">Der Zustands des zugehörigen Geräteprofils.</param>
/// <param name="firstRecording">Die erste Aufzeichnung, auf Grund derer dieser Zugriff angelegt wurde.</param>
public RecordingProxy(ProfileState state, VCRRecordingInfo firstRecording)
: base(state, firstRecording)
{
}
static void Main1(string[] args)
{
// Attach to job manager
VCRServer server = new VCRServer(new DirectoryInfo(@"C:\temp\VCR.NET 3.9 Alpha\Jobs"));
JobManager jobs = server.JobManager;
// Process all profiles
foreach (Profile profile in VCRProfiles.Profiles)
{
// Report
Console.WriteLine(profile.Name);
// Start time
DateTime start = DateTime.UtcNow;
// Process a bit
for (int i = 10; i-- > 0;)
{
// Helper data
VCRRecordingInfo[] included;
bool inComplete;
// Find the recording
FullInfo info = jobs.FindNextRecording(start, profile, out inComplete, out included);
VCRRecordingInfo rec = info.Recording;
VCRJob job = jobs[rec.JobUniqueID.Value];
VCRSchedule sched = job[rec.ScheduleUniqueID.Value];
// Report
Console.WriteLine("\t{0} {1} {2} ({3}) {4} {5} {6} {7}", rec.StartsAt.Value.ToLocalTime(), rec.EndsAt.ToLocalTime().TimeOfDay, job.Name, sched.Name, inComplete, included.Length, rec.JobUniqueID, rec.ScheduleUniqueID);
// Report
foreach (VCRRecordingInfo include in included)
{
Console.WriteLine("\t\t{0} {1} {2} {3} {4}", include.Source.GetUniqueName(), include.StartsAt.Value.ToLocalTime(), include.EndsAt.ToLocalTime().TimeOfDay, include.JobUniqueID, include.ScheduleUniqueID);
}
// Report
foreach (StreamInfo stream in info.Streams)
{
foreach (ScheduleInfo schedule in stream.Schedules)
{
Console.WriteLine("\t\t{0} {1} {2} {3}", schedule.JobUniqueID, schedule.ScheduleUniqueID, schedule.StartsAt.ToLocalTime(), schedule.EndsAt.ToLocalTime().TimeOfDay);
}
}
// Advance
start = rec.EndsAt;
}
// Helper data
VCRRecordingInfo[] incDummy;
bool dummyFlag;
// Start timer
Stopwatch timer = Stopwatch.StartNew();
// Measure
for (int n = 0; ++n > 0;)
{
// Find the recording
jobs.FindNextRecording(DateTime.UtcNow, profile, out dummyFlag, out incDummy);
// Get the time
TimeSpan delta = timer.Elapsed;
if (delta.TotalSeconds >= 5)
{
// Report
Console.WriteLine("{0}ms", delta.TotalMilliseconds / n);
// Done
break;
}
}
}
// Get the profile
Profile nexus = VCRProfiles.FindProfile("Nexus");
// Find the next recording
VCRRecordingInfo rec2 = jobs.FindNextJob(new DateTime(2009, 2, 19, 20, 0, 0), null, nexus);
if (null != rec2)
{
if (rec2.StartsAt.HasValue)
{
using (RecordingRequest recording = jobs.CreateRecording(rec2, rec2.StartsAt.Value, nexus))
{
// Get the information
FullInfo info0 = recording.CreateFullInformation();
#if EXEC
// Start it
recording.BeginExecute(false);
// Report
Console.WriteLine("Recording...");
Console.ReadLine();
// Get the information
FullInfo info1 = recording.CreateFullInformation();
#endif
}
}
}
// Done
Console.WriteLine("Done");
Console.ReadLine();
}
/// <summary>
/// Beginnt eine neue Aufzeichnung.
/// </summary>
/// <param name="recording">Die Daten der Aufzeichung.</param>
protected virtual void OnStartRecording(VCRRecordingInfo recording)
{
}
/// <summary>
/// Bestätigt die Bearbeitung des zuletzt erhaltenen Aufzeichnungsauftrags.
/// </summary>
/// <param name="notifyOnly">Gesetzt, wenn nur eine Benachrichtigung ausgelöst werden soll.</param>
private void ConfirmPendingRequest(bool notifyOnly = false)
{
// Current settings
VCRRecordingInfo start = null;
Guid scheduleIdentifier;
// Protect against change and check mode
lock (m_active)
if (m_start != null)
{
// Load the current value
start = m_start;
scheduleIdentifier = start.ScheduleUniqueID.Value;
// Reset it
m_start = null;
// Add to map
m_active.Add(scheduleIdentifier, start);
}
else if (m_stop.HasValue)
{
// Load the current value
scheduleIdentifier = m_stop.Value;
// Reset it
m_stop = null;
// Remove from to map
m_active.Remove(scheduleIdentifier);
// We did it
if (m_active.Count < 1)
{
m_running = false;
}
}
else
{
// We are idle - nothing more to do
return;
}
// Check mode
var isStart = (start != null);
// Notify derived class if we are not in shutdown mode
if (!notifyOnly)
{
if (isStart)
{
OnStartRecording(start);
}
else
{
OnEndRecording(scheduleIdentifier);
}
}
// Inform scheduler outside the lock
ProfileState.Collection.ConfirmOperation(scheduleIdentifier, isStart);
}
/// <summary>
/// Erstellt eine neue Sammlung.
/// </summary>
/// <param name="state">Das zugehörige Geräteprofil.</param>
/// <param name="recording">Die Beschreibung der Aufgabe.</param>
private SourceScanProxy( ProfileState state, VCRRecordingInfo recording )
: base( state, recording )
{
// Finish
m_mergeSources = VCRConfiguration.Current.MergeSourceListUpdateResult;
}
/// <summary>
/// Erstellt einen neuen Zugriff.
/// </summary>
/// <param name="profile">Das zu verwendende Geräteprofil.</param>
/// <param name="primary">Informationen zur Aufzeichnung als Ganzes.</param>
/// <param name="target">Die aktuelle Zieladresse für die Nutzdaten.</param>
private ZappingProxy(ProfileState profile, VCRRecordingInfo primary, string target)
: base(profile, primary)
{
// Remember
m_target = target;
}