/// <summary>
/// Gets the current channel.
/// </summary>
/// <param name="user">The user.</param>
/// <returns>id of database channel</returns>
public int CurrentDbChannel(ref IUser user)
{
try
{
if (_dbsCard.Enabled == false)
{
return(-1);
}
if (IsLocal == false)
{
try
{
RemoteControl.HostName = _dbsCard.ReferencedServer().HostName;
return(RemoteControl.Instance.CurrentDbChannel(ref user));
}
catch (Exception)
{
Log.Error("card: unable to connect to slave controller at:{0}", _dbsCard.ReferencedServer().HostName);
return(-1);
}
}
ITvCardContext context = _card.Context as ITvCardContext;
context.GetUser(ref user);
return(user.IdChannel);
}
catch (ThreadAbortException)
{
return(-1);
}
catch (Exception ex)
{
Log.Write(ex);
return(-1);
}
}
/// <summary>
/// Gets the current video stream.
/// </summary>
/// <returns></returns>
public IVideoStream GetCurrentVideoStream(IUser user)
{
if (_dbsCard.Enabled == false)
{
return(null);
}
if (IsLocal == false)
{
try
{
RemoteControl.HostName = _dbsCard.ReferencedServer().HostName;
return(RemoteControl.Instance.GetCurrentVideoStream(user));
}
catch (Exception)
{
Log.Error("card: unable to connect to slave controller at:{0}", _dbsCard.ReferencedServer().HostName);
return(null);
}
}
ITvCardContext context = _card.Context as ITvCardContext;
if (context == null)
{
return(null);
}
context.GetUser(ref user);
ITvSubChannel subchannel = _card.GetSubChannel(user.SubChannel);
if (subchannel == null)
{
return(null);
}
return(subchannel.GetCurrentVideoStream);
}
/// <summary>
/// Stops the grabbing epg.
/// </summary>
/// <param name="user">User</param>
public void Stop(IUser user)
{
Log.Epg("EpgGrabbing: Stop - user {0}", user.Name);
if (_cardHandler.IsLocal == false)
{
// RemoteControl.HostName = _cardHandler.DataBaseCard.ReferencedServer().HostName;
// RemoteControl.Instance.StopGrabbingEpg();
return;
}
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
if (context != null)
{
context.Remove(user);
if (context.ContainsUsersForSubchannel(user.SubChannel) == false)
{
if (user.SubChannel > -1)
{
_cardHandler.Card.FreeSubChannel(user.SubChannel);
}
}
}
else
{
Log.Epg("EpgGrabbing: Stop - context == null");
}
_cardHandler.Card.IsEpgGrabbing = false;
}
private TvResult AfterTune(IUser user, int idChannel, ITvSubChannel result)
{
bool isLocked = _cardHandler.Card.IsTunerLocked;
Log.Debug("card: Tuner locked: {0}", isLocked);
Log.Info("**************************************************");
Log.Info("***** SIGNAL LEVEL: {0}, SIGNAL QUALITY: {1} *****", _cardHandler.Card.SignalLevel,
_cardHandler.Card.SignalQuality);
Log.Info("**************************************************");
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
if (result != null)
{
Log.Debug("card: tuned user: {0} subchannel: {1}", user.Name, result.SubChannelId);
user.SubChannel = result.SubChannelId;
user.IdChannel = idChannel;
context.Add(user);
}
else
{
return(TvResult.AllCardsBusy);
}
if (result.IsTimeShifting || result.IsRecording)
{
context.OnZap(user);
}
return(TvResult.Succeeded);
}
/// <summary>
/// Unlocks this card.
/// </summary>
/// <param name="user">The user.</param>
///
public void Unlock(IUser user)
{
if (_cardHandler.Card != null)
{
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
context.Remove(user);
}
}
/// <summary>
/// Gets the teletext page.
/// </summary>
/// <param name="user">User</param>
/// <param name="pageNumber">The page number.</param>
/// <param name="subPageNumber">The sub page number.</param>
/// <returns></returns>
public byte[] GetTeletextPage(IUser user, int pageNumber, int subPageNumber)
{
try
{
if (_cardHandler.DataBaseCard.Enabled == false)
{
return new byte[] { 1 }
}
;
try
{
RemoteControl.HostName = _cardHandler.DataBaseCard.ReferencedServer().HostName;
if (!RemoteControl.Instance.CardPresent(_cardHandler.DataBaseCard.IdCard))
{
return new byte[] { 1 }
}
;
if (_cardHandler.IsLocal == false)
{
return(RemoteControl.Instance.GetTeletextPage(user, pageNumber, subPageNumber));
}
}
catch (Exception)
{
Log.Error("card: unable to connect to slave controller at:{0}",
_cardHandler.DataBaseCard.ReferencedServer().HostName);
return(new byte[] { 1 });
}
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
if (context == null)
{
return new byte[] { 1 }
}
;
context.GetUser(ref user);
ITvSubChannel subchannel = _cardHandler.Card.GetSubChannel(user.SubChannel);
if (subchannel == null)
{
return new byte[] { 1 }
}
;
if (subchannel.TeletextDecoder == null)
{
return new byte[] { 1 }
}
;
return(subchannel.TeletextDecoder.GetRawPage(pageNumber, subPageNumber));
}
catch (Exception ex)
{
Log.Write(ex);
return(new byte[] { 1 });
}
}
public TvStoppedReason GetTvStoppedReason(IUser user)
{
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
if (context == null)
{
return(TvStoppedReason.UnknownReason);
}
return(context.GetTimeshiftStoppedReason(user));
}
public void SetTvStoppedReason(IUser user, TvStoppedReason reason)
{
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
if (context == null)
{
return;
}
context.SetTimeshiftStoppedReason(user, reason);
}
/// <summary>
/// Determines whether the card is locked and ifso returns by which user
/// </summary>
/// <param name="user">The user.</param>
/// <returns>
/// <c>true</c> if the specified card is locked; otherwise, <c>false</c>.
/// </returns>
public bool IsLocked(out IUser user)
{
user = null;
if (_cardHandler.Card != null)
{
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
context.IsLocked(out user);
return(user != null);
}
return(false);
}
/// <summary>
/// Pauses the card.
/// </summary>
public void PauseCard(IUser user)
{
try
{
if (_dbsCard.Enabled == false)
{
return;
}
if (IsLocal == false)
{
try
{
RemoteControl.HostName = _dbsCard.ReferencedServer().HostName;
RemoteControl.Instance.PauseCard(user);
return;
}
catch (Exception)
{
Log.Error("card: unable to connect to slave controller at:{0}", _dbsCard.ReferencedServer().HostName);
return;
}
}
Log.Info("Pausecard");
//remove all subchannels, except for this user...
ITvSubChannel[] channels = _card.SubChannels;
for (int i = 0; i < channels.Length; ++i)
{
_card.FreeSubChannel(channels[i].SubChannelId);
}
ITvCardContext context = _card.Context as ITvCardContext;
if (context != null)
{
context.Clear();
}
if (_card.SupportsPauseGraph)
{
_card.PauseGraph();
}
else
{
_card.StopGraph();
}
}
catch (ThreadAbortException)
{
}
catch (Exception ex)
{
Log.Write(ex);
}
}
/// <summary>
/// Returns if the card is timeshifting or not
/// </summary>
/// <returns>true when card is timeshifting otherwise false</returns>
public bool IsTimeShifting(ref IUser user)
{
try
{
if (_cardHandler.DataBaseCard.Enabled == false)
{
return(false);
}
try
{
RemoteControl.HostName = _cardHandler.DataBaseCard.ReferencedServer().HostName;
if (!RemoteControl.Instance.CardPresent(_cardHandler.DataBaseCard.IdCard))
{
return(false);
}
if (_cardHandler.IsLocal == false)
{
return(RemoteControl.Instance.IsTimeShifting(ref user));
}
}
catch (Exception)
{
Log.Error("card: unable to connect to slave controller at:{0}",
_cardHandler.DataBaseCard.ReferencedServer().HostName);
return(false);
}
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
if (context == null)
{
return(false);
}
bool userExists;
context.GetUser(ref user, out userExists);
if (!userExists)
{
return(false);
}
ITvSubChannel subchannel = _cardHandler.Card.GetSubChannel(user.SubChannel);
if (subchannel == null)
{
return(false);
}
return(subchannel.IsTimeShifting);
}
catch (Exception ex)
{
Log.Write(ex);
return(false);
}
}
/// <summary>
/// Gets the current channel name.
/// </summary>
/// <param name="user">The user.</param>
/// <returns>channel</returns>
public string CurrentChannelName(ref IUser user)
{
try
{
if (_dbsCard.Enabled == false)
{
return("");
}
if (IsLocal == false)
{
try
{
RemoteControl.HostName = _dbsCard.ReferencedServer().HostName;
return(RemoteControl.Instance.CurrentChannelName(ref user));
}
catch (Exception)
{
Log.Error("card: unable to connect to slave controller at:{0}", _dbsCard.ReferencedServer().HostName);
return("");
}
}
ITvCardContext context = _card.Context as ITvCardContext;
if (context == null)
{
return("");
}
context.GetUser(ref user);
ITvSubChannel subchannel = _card.GetSubChannel(user.SubChannel);
if (subchannel == null)
{
return("");
}
if (subchannel.CurrentChannel == null)
{
return("");
}
return(subchannel.CurrentChannel.Name);
}
catch (ThreadAbortException)
{
return("");
}
catch (Exception ex)
{
Log.Write(ex);
return("");
}
}
public void HeartBeartUser(IUser user)
{
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
if (context == null)
{
return;
}
if (!context.DoesExists(user))
{
return;
}
context.HeartBeatUser(user);
}
/// <summary>
/// Returns the position in the current timeshift file and the id of the current timeshift file
/// </summary>
/// <param name="user">The user.</param>
/// <param name="position">The position in the current timeshift buffer file</param>
/// <param name="bufferId">The id of the current timeshift buffer file</param>
public bool GetCurrentFilePosition(ref IUser user, ref Int64 position, ref long bufferId)
{
try
{
if (_cardHandler.DataBaseCard.Enabled == false)
{
return(false);
}
try
{
RemoteControl.HostName = _cardHandler.DataBaseCard.ReferencedServer().HostName;
if (!RemoteControl.Instance.CardPresent(_cardHandler.DataBaseCard.IdCard))
{
return(false);
}
if (_cardHandler.IsLocal == false)
{
return(RemoteControl.Instance.TimeShiftGetCurrentFilePosition(ref user, ref position,
ref bufferId));
}
}
catch (Exception)
{
Log.Error("card: unable to connect to slave controller at:{0}",
_cardHandler.DataBaseCard.ReferencedServer().HostName);
return(false);
}
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
if (context == null)
{
return(false);
}
context.GetUser(ref user);
ITvSubChannel subchannel = _cardHandler.Card.GetSubChannel(user.SubChannel);
if (subchannel == null)
{
return(false);
}
subchannel.TimeShiftGetCurrentFilePosition(ref position, ref bufferId);
return(position != -1);
}
catch (Exception ex)
{
Log.Write(ex);
return(false);
}
}
private bool UserExists(ITvCardContext ctx, IUser user)
{
foreach (User u in ctx.Users)
{
if (
u.CardId == user.CardId &&
u.IdChannel == user.IdChannel &&
u.IsAdmin == user.IsAdmin &&
u.Name == user.Name &&
u.SubChannel == user.SubChannel)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Sets the current audio stream.
/// </summary>
/// <param name="user">User</param>
/// <param name="stream">The stream.</param>
public void Set(IUser user, IAudioStream stream)
{
if (_cardHandler.DataBaseCard.Enabled == false)
{
return;
}
try
{
RemoteControl.HostName = _cardHandler.DataBaseCard.ReferencedServer().HostName;
if (!RemoteControl.Instance.CardPresent(_cardHandler.DataBaseCard.IdCard))
{
return;
}
Log.WriteFile("card: SetCurrentAudioStream: {0} - {1}", _cardHandler.DataBaseCard.IdCard, stream);
if (_cardHandler.IsLocal == false)
{
Log.WriteFile("card: SetCurrentAudioStream: controlling remote instance {0}", RemoteControl.HostName);
RemoteControl.Instance.SetCurrentAudioStream(user, stream);
}
}
catch (Exception)
{
Log.Error("card: unable to connect to slave controller at:{0}",
_cardHandler.DataBaseCard.ReferencedServer().HostName);
return;
}
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
if (context == null)
{
Log.WriteFile("card: SetCurrentAudioStream: TvCardContext == null");
return;
}
context.GetUser(ref user);
ITvSubChannel subchannel = _cardHandler.Card.GetSubChannel(user.SubChannel);
if (subchannel == null)
{
Log.WriteFile("card: SetCurrentAudioStream: ITvSubChannel == null");
return;
}
subchannel.CurrentAudioStream = stream;
}
/// <summary>
/// returns the date/time when timeshifting has been started for the card specified
/// </summary>
/// <returns>DateTime containg the date/time when timeshifting was started</returns>
public DateTime TimeShiftStarted(IUser user)
{
try
{
if (_cardHandler.DataBaseCard.Enabled == false)
{
return(DateTime.MinValue);
}
try
{
RemoteControl.HostName = _cardHandler.DataBaseCard.ReferencedServer().HostName;
if (!RemoteControl.Instance.CardPresent(_cardHandler.DataBaseCard.IdCard))
{
return(DateTime.MinValue);
}
if (_cardHandler.IsLocal == false)
{
return(RemoteControl.Instance.TimeShiftStarted(user));
}
}
catch (Exception)
{
Log.Error("card: unable to connect to slave controller at:{0}",
_cardHandler.DataBaseCard.ReferencedServer().HostName);
return(DateTime.MinValue);
}
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
if (context == null)
{
return(DateTime.MinValue);
}
context.GetUser(ref user);
ITvSubChannel subchannel = _cardHandler.Card.GetSubChannel(user.SubChannel);
if (subchannel == null)
{
return(DateTime.MinValue);
}
return(subchannel.StartOfTimeShift);
}
catch (Exception ex)
{
Log.Write(ex);
return(DateTime.MinValue);
}
}
private void SetContextOwnerToNextRecUser(ITvCardContext context)
{
IUser[] users = context.Users;
foreach (IUser t in users)
{
ITvSubChannel subchannel = GetSubChannel(t.SubChannel);
if (subchannel != null)
{
if (subchannel.IsRecording)
{
Log.Write("card: StopRecording setting new context owner on user '{0}'", t.Name);
context.Owner = t;
break;
}
}
}
}
/// <summary>
/// Returns the rotation time for a specific teletext page
/// </summary>
/// <param name="user">User</param>
/// <param name="pageNumber">The pagenumber (0x100-0x899)</param>
/// <returns>timespan containing the rotation time</returns>
public TimeSpan TeletextRotation(IUser user, int pageNumber)
{
try
{
if (_cardHandler.DataBaseCard.Enabled == false)
{
return(new TimeSpan(0, 0, 0, 15));
}
try
{
RemoteControl.HostName = _cardHandler.DataBaseCard.ReferencedServer().HostName;
if (!RemoteControl.Instance.CardPresent(_cardHandler.DataBaseCard.IdCard))
{
return(new TimeSpan(0, 0, 0, 15));
}
if (_cardHandler.IsLocal == false)
{
return(RemoteControl.Instance.TeletextRotation(user, pageNumber));
}
}
catch (Exception)
{
Log.Error("card: unable to connect to slave controller at:{0}",
_cardHandler.DataBaseCard.ReferencedServer().HostName);
return(new TimeSpan(0, 0, 0, 15));
}
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
if (context == null)
{
return(new TimeSpan(0, 0, 0, 15));
}
context.GetUser(ref user);
ITvSubChannel subchannel = _cardHandler.Card.GetSubChannel(user.SubChannel);
if (subchannel == null)
{
return(new TimeSpan(0, 0, 0, 15));
}
return(subchannel.TeletextDecoder.RotationTime(pageNumber));
}
catch (Exception ex)
{
Log.Write(ex);
return(new TimeSpan(0, 0, 0, 15));
}
}
/// <summary>
/// turn on/off teletext grabbing
/// </summary>
/// <param name="user">User</param>
/// <param name="onOff">turn on/off teletext grabbing</param>
public void GrabTeletext(IUser user, bool onOff)
{
try
{
if (_cardHandler.DataBaseCard.Enabled == false)
{
return;
}
try
{
RemoteControl.HostName = _cardHandler.DataBaseCard.ReferencedServer().HostName;
if (!RemoteControl.Instance.CardPresent(_cardHandler.DataBaseCard.IdCard))
{
return;
}
if (_cardHandler.IsLocal == false)
{
RemoteControl.Instance.GrabTeletext(user, onOff);
}
}
catch (Exception)
{
Log.Error("card: unable to connect to slave controller at:{0}",
_cardHandler.DataBaseCard.ReferencedServer().HostName);
return;
}
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
if (context == null)
{
return;
}
context.GetUser(ref user);
ITvSubChannel subchannel = _cardHandler.Card.GetSubChannel(user.SubChannel);
if (subchannel == null)
{
return;
}
subchannel.GrabTeletext = onOff;
}
catch (Exception ex)
{
Log.Write(ex);
return;
}
}
/// <summary>
/// Gets the teletext pagenumber for the blue button
/// </summary>
/// <param name="user">The user.</param>
/// <returns>Teletext pagenumber for the blue button</returns>
public int GetTeletextBluePageNumber(IUser user)
{
try
{
if (_cardHandler.DataBaseCard.Enabled == false)
{
return(-1);
}
if (_cardHandler.IsLocal == false)
{
try
{
RemoteControl.HostName = _cardHandler.DataBaseCard.ReferencedServer().HostName;
return(RemoteControl.Instance.GetTeletextBluePageNumber(user));
}
catch (Exception)
{
Log.Error("card: unable to connect to slave controller at:{0}",
_cardHandler.DataBaseCard.ReferencedServer().HostName);
return(-1);
}
}
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
if (context == null)
{
return(-1);
}
context.GetUser(ref user);
ITvSubChannel subchannel = _cardHandler.Card.GetSubChannel(user.SubChannel);
if (subchannel == null)
{
return(-1);
}
if (subchannel.TeletextDecoder == null)
{
return(-1);
}
return(subchannel.TeletextDecoder.PageBlue);
}
catch (Exception ex)
{
Log.Write(ex);
return(-1);
}
}
private TvResult GetTvResultFromTimeshiftingSubchannel(ref IUser user, ITvCardContext context)
{
TvResult result;
bool isScrambled;
if (WaitForFile(ref user, out isScrambled))
{
context.OnZap(user);
StartLinkageScanner();
StartTimeShiftingEPGgrabber(user);
result = TvResult.Succeeded;
}
else
{
result = GetFailedTvResult(isScrambled);
}
return(result);
}
/// <summary>
/// Fetches the stream quality information
/// </summary>
/// <param name="user">user</param>
/// <param name="totalTSpackets">Amount of packets processed</param>
/// <param name="discontinuityCounter">Number of stream discontinuities</param>
/// <returns></returns>
public void GetStreamQualityCounters(IUser user, out int totalTSpackets, out int discontinuityCounter)
{
totalTSpackets = 0;
discontinuityCounter = 0;
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
bool userExists;
context.GetUser(ref user, out userExists);
ITvSubChannel subchannel = _cardHandler.Card.GetSubChannel(user.SubChannel);
TvDvbChannel dvbSubchannel = subchannel as TvDvbChannel;
if (dvbSubchannel != null)
{
dvbSubchannel.GetStreamQualityCounters(out totalTSpackets, out discontinuityCounter);
}
}
/// <summary>
/// Determines whether the specified user is owner of this card
/// </summary>
/// <param name="user">The user.</param>
/// <returns>
/// <c>true</c> if the specified user is owner; otherwise, <c>false</c>.
/// </returns>
public bool IsOwner(IUser user)
{
if (_cardHandler.IsLocal == false)
{
try
{
RemoteControl.HostName = _cardHandler.DataBaseCard.ReferencedServer().HostName;
return(RemoteControl.Instance.IsOwner(_cardHandler.DataBaseCard.IdCard, user));
}
catch (Exception)
{
Log.Error("card: unable to connect to slave controller at:{0}",
_cardHandler.DataBaseCard.ReferencedServer().HostName);
return(false);
}
}
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
return(context.IsOwner(user));
}
/// <summary>
/// Gets the current audio stream.
/// </summary>
/// <returns></returns>
public IAudioStream GetCurrent(IUser user)
{
if (_cardHandler.DataBaseCard.Enabled == false)
{
return(null);
}
try
{
RemoteControl.HostName = _cardHandler.DataBaseCard.ReferencedServer().HostName;
if (!RemoteControl.Instance.CardPresent(_cardHandler.DataBaseCard.IdCard))
{
return(null);
}
if (_cardHandler.IsLocal == false)
{
return(RemoteControl.Instance.GetCurrentAudioStream(user));
}
}
catch (Exception)
{
Log.Error("card: unable to connect to slave controller at:{0}",
_cardHandler.DataBaseCard.ReferencedServer().HostName);
return(null);
}
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
if (context == null)
{
return(null);
}
context.GetUser(ref user);
ITvSubChannel subchannel = _cardHandler.Card.GetSubChannel(user.SubChannel);
if (subchannel == null)
{
return(null);
}
return(subchannel.CurrentAudioStream);
}
/// <summary>
/// Returns whether the channel to which the card is tuned is
/// scrambled or not.
/// </summary>
/// <returns>yes if channel is scrambled and CI/CAM cannot decode it, otherwise false</returns>
public bool IsScrambled(ref IUser user)
{
try
{
if (_dbsCard.Enabled == false)
{
return(true);
}
if (IsLocal == false)
{
try
{
RemoteControl.HostName = _dbsCard.ReferencedServer().HostName;
return(RemoteControl.Instance.IsScrambled(ref user));
}
catch (Exception)
{
Log.Error("card: unable to connect to slave controller at:{0}", _dbsCard.ReferencedServer().HostName);
return(false);
}
}
ITvCardContext context = _card.Context as ITvCardContext;
if (context == null)
{
return(false);
}
context.GetUser(ref user);
ITvSubChannel subchannel = _card.GetSubChannel(user.SubChannel);
if (subchannel == null)
{
return(false);
}
return(false == subchannel.IsReceivingAudioVideo);
}
catch (Exception ex)
{
Log.Write(ex);
return(false);
}
}
/// <summary>
/// Gets the users for this card.
/// </summary>
/// <returns></returns>
public IUser[] GetUsers()
{
if (_cardHandler.IsLocal == false)
{
try
{
RemoteControl.HostName = _cardHandler.DataBaseCard.ReferencedServer().HostName;
return(RemoteControl.Instance.GetUsersForCard(_cardHandler.DataBaseCard.IdCard));
}
catch (Exception)
{
Log.Error("card: unable to connect to slave controller at:{0}",
_cardHandler.DataBaseCard.ReferencedServer().HostName);
return(null);
}
}
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
if (context == null)
{
return(null);
}
return(context.Users);
}
/// <summary>
/// Stops the time shifting.
/// </summary>
/// <returns></returns>
public bool Stop(ref IUser user)
{
try
{
if (_cardHandler.DataBaseCard.Enabled == false)
{
return(true);
}
ITvSubChannel subchannel = _cardHandler.Card.GetSubChannel(user.SubChannel);
if (subchannel is BaseSubChannel)
{
((BaseSubChannel)subchannel).AudioVideoEvent -= AudioVideoEventHandler;
}
Log.Write("card {2}: StopTimeShifting user:{0} sub:{1}", user.Name, user.SubChannel,
_cardHandler.Card.Name);
lock (this)
{
try
{
RemoteControl.HostName = _cardHandler.DataBaseCard.ReferencedServer().HostName;
if (!RemoteControl.Instance.CardPresent(_cardHandler.DataBaseCard.IdCard))
{
return(true);
}
Log.Write("card: StopTimeShifting user:{0} sub:{1}", user.Name, user.SubChannel);
if (_cardHandler.IsLocal == false)
{
return(RemoteControl.Instance.StopTimeShifting(ref user));
}
}
catch (Exception)
{
Log.Error("card: unable to connect to slave controller at:{0}",
_cardHandler.DataBaseCard.ReferencedServer().HostName);
return(false);
}
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
if (context == null)
{
return(true);
}
if (_linkageScannerEnabled)
{
_cardHandler.Card.ResetLinkageScanner();
}
if (_cardHandler.IsIdle)
{
_cardHandler.PauseCard(user);
}
else
{
Log.Debug("card not IDLE - removing user: {0}", user.Name);
_cardHandler.Users.RemoveUser(user);
}
context.Remove(user);
return(true);
}
}
catch (Exception ex)
{
Log.Write(ex);
}
return(false);
}
/// <summary>
/// Removes the user from this card
/// </summary>
/// <param name="user">The user.</param>
public void RemoveUser(IUser user)
{
if (_cardHandler.IsLocal == false)
{
try
{
RemoteControl.HostName = _cardHandler.DataBaseCard.ReferencedServer().HostName;
RemoteControl.Instance.RemoveUserFromOtherCards(_cardHandler.DataBaseCard.IdCard, user);
return;
}
catch (Exception)
{
Log.Error("card: unable to connect to slave controller at:{0}",
_cardHandler.DataBaseCard.ReferencedServer().HostName);
return;
}
}
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
if (context == null)
{
return;
}
if (!context.DoesExists(user))
{
return;
}
context.GetUser(ref user, _cardHandler.DataBaseCard.IdCard);
Log.Debug("usermanagement.RemoveUser: {0}, subch: {1} of {2}, card: {3}", user.Name, user.SubChannel, _cardHandler.Card.SubChannels.Length, _cardHandler.DataBaseCard.IdCard);
context.Remove(user);
if (!context.ContainsUsersForSubchannel(user.SubChannel))
{
//only remove subchannel if it exists.
if (_cardHandler.Card.GetSubChannel(user.SubChannel) != null)
{
int usedSubChannel = user.SubChannel;
// Before we remove the subchannel we have to stop it
ITvSubChannel subChannel = _cardHandler.Card.GetSubChannel(user.SubChannel);
if (subChannel.IsTimeShifting)
{
subChannel.StopTimeShifting();
}
else if (subChannel.IsRecording)
{
subChannel.StopRecording();
}
_cardHandler.Card.FreeSubChannel(user.SubChannel);
CleanTimeshiftFilesThread cleanTimeshiftFilesThread =
new CleanTimeshiftFilesThread(_cardHandler.DataBaseCard.TimeShiftFolder,
String.Format("live{0}-{1}.ts", _cardHandler.DataBaseCard.IdCard,
usedSubChannel));
Thread cleanupThread = new Thread(cleanTimeshiftFilesThread.CleanTimeshiftFiles);
cleanupThread.IsBackground = true;
cleanupThread.Name = "TS_File_Cleanup";
cleanupThread.Priority = ThreadPriority.Lowest;
cleanupThread.Start();
}
}
if (_cardHandler.IsIdle)
{
if (_cardHandler.Card.SupportsPauseGraph)
{
_cardHandler.Card.PauseGraph();
}
else
{
_cardHandler.Card.StopGraph();
}
}
}
private bool UserExists (ITvCardContext ctx, IUser user)
{
foreach (User u in ctx.Users)
{
if (
u.CardId == user.CardId &&
u.IdChannel == user.IdChannel &&
u.IsAdmin == user.IsAdmin &&
u.Name == user.Name &&
u.SubChannel == user.SubChannel)
{
return true;
}
}
return false;
}
private TvResult GetTvResultFromTimeshiftingSubchannel(ref IUser user, ITvCardContext context)
{
TvResult result;
bool isScrambled;
if (WaitForFile(ref user, out isScrambled))
{
context.OnZap(user);
StartLinkageScanner();
StartTimeShiftingEPGgrabber(user);
result = TvResult.Succeeded;
}
else
{
result = GetFailedTvResult(isScrambled);
}
return result;
}
private void SetContextOwnerToNextRecUser(ITvCardContext context)
{
IUser[] users = context.Users;
foreach (IUser t in users)
{
ITvSubChannel subchannel = GetSubChannel(t.SubChannel);
if (subchannel != null)
{
if (subchannel.IsRecording)
{
Log.Write("card: StopRecording setting new context owner on user '{0}'", t.Name);
context.Owner = t;
break;
}
}
}
}
private bool BeforeTune(IChannel channel, ref IUser user, out TvResult result)
{
result = TvResult.UnknownError;
//@FIX this fails for back-2-back recordings
//if (CurrentDbChannel(ref user) == idChannel && idChannel >= 0)
//{
// return true;
//}
Log.Debug("card: user: {0}:{1}:{2} tune {3}", user.Name, user.CardId, user.SubChannel, channel.ToString());
_cardHandler.Card.CamType = (CamType)_cardHandler.DataBaseCard.CamType;
_cardHandler.SetParameters();
//check if transponder differs
ITvCardContext context = _cardHandler.Card.Context as ITvCardContext;
if (_cardHandler.Card.SubChannels.Length > 0)
{
if (IsTunedToTransponder(channel) == false)
{
if (context.IsOwner(user) || user.IsAdmin)
{
Log.Debug("card: to different transponder");
//remove all subchannels, except for this user...
IUser[] users = context.Users;
for (int i = 0; i < users.Length; ++i)
{
if (users[i].Name != user.Name)
{
Log.Debug(" stop subchannel: {0} user: {1}", i, users[i].Name);
//fix for b2b mantis; http://mantis.team-mediaportal.com/view.php?id=1112
if (users[i].IsAdmin)
// if we are stopping an on-going recording/schedule (=admin), we have to make sure that we remove the schedule also.
{
Log.Debug("user is scheduler: {0}", users[i].Name);
int recScheduleId = RemoteControl.Instance.GetRecordingSchedule(users[i].CardId,
users[i].IdChannel);
if (recScheduleId > 0)
{
Schedule schedule = Schedule.Retrieve(recScheduleId);
Log.Info("removing schedule with id: {0}", schedule.IdSchedule);
RemoteControl.Instance.StopRecordingSchedule(schedule.IdSchedule);
schedule.Delete();
}
}
else
{
_cardHandler.Card.FreeSubChannel(users[i].SubChannel);
context.Remove(users[i]);
}
}
}
}
else
{
Log.Debug("card: user: {0} is not the card owner. Cannot switch transponder", user.Name);
result = TvResult.NotTheOwner;
return(false);
}
}
else // same transponder, free previous subchannel before tuning..
{
_cardHandler.Card.FreeSubChannel(user.SubChannel);
}
}
if (OnBeforeTuneEvent != null)
{
OnBeforeTuneEvent(_cardHandler);
}
TvCardBase card = _cardHandler.Card as TvCardBase;
if (card != null)
{
card.AfterTuneEvent -= new TvCardBase.OnAfterTuneDelegate(Card_OnAfterTuneEvent);
card.AfterTuneEvent += new TvCardBase.OnAfterTuneDelegate(Card_OnAfterTuneEvent);
}
else
{
HybridCard hybridCard = _cardHandler.Card as HybridCard;
if (hybridCard != null)
{
hybridCard.AfterTuneEvent = new TvCardBase.OnAfterTuneDelegate(Card_OnAfterTuneEvent);
}
}
result = TvResult.Succeeded;
return(true);
}
