public static bool GetIsTuningPending(ITvCardHandler tvcard, ICardTuneReservationTicket ticket, out bool ticketFound)
{
bool isTuningPending;
bool cardStopStateIdle;
lock (tvcard.Tuner.CardReservationsLock)
{
cardStopStateIdle = (tvcard.Tuner.CardStopState == CardStopState.Idle);
isTuningPending = (tvcard.Tuner.CardTuneState == CardTuneState.TunePending);
ticketFound = (tvcard.Tuner.ReservationsForTune.Contains(ticket));
if (isTuningPending && cardStopStateIdle)
{
if (ticketFound)
{
tvcard.Tuner.CardTuneState = CardTuneState.Tuning;
}
else
{
//_cardTuneState = CardTuneState.TunePending;
}
}
}
if (ticket == null)
{
Log.Debug("GetIsTuningPending: ticket is null!");
}
return(isTuningPending && cardStopStateIdle);
}
protected override int NumberOfOtherUsersOnCurrentCard(ITvCardHandler tvcard, IUser user)
{
int numberOfOtherUsersOnCurrentCard = 0;
ICardTuneReservationTicket ticket = GetCardTuneReservationTicket(tvcard.DataBaseCard.IdCard);
if (ticket != null)
{
numberOfOtherUsersOnCurrentCard = ticket.NumberOfOtherUsersOnCurrentCard;
}
return(numberOfOtherUsersOnCurrentCard);
}
protected override bool IsSameTransponder(ITvCardHandler tvcard, IChannel tuningDetail)
{
bool isSameTransponder = false;
ICardTuneReservationTicket ticket = GetCardTuneReservationTicket(tvcard.DataBaseCard.IdCard);
if (ticket != null)
{
isSameTransponder = ticket.IsSameTransponder;
}
return(isSameTransponder);
}
protected override int NumberOfChannelsDecrypting(ITvCardHandler tvcard)
{
int numberOfChannelsDecrypting = 0;
ICardTuneReservationTicket ticket = GetCardTuneReservationTicket(tvcard.DataBaseCard.IdCard);
if (ticket != null)
{
numberOfChannelsDecrypting = (ticket.NumberOfChannelsDecrypting);
}
return(numberOfChannelsDecrypting);
}
protected override bool IsFreeToAir(ITvCardHandler tvcard, ref IUser user)
{
bool isFreeToAir = true;
ICardTuneReservationTicket ticket = GetCardTuneReservationTicket(tvcard.DataBaseCard.IdCard);
if (ticket != null)
{
isFreeToAir = (ticket.IsFreeToAir);
}
return(isFreeToAir);
}
public static void RemoveTuneTicket(ITvCardHandler tvcard, ICardTuneReservationTicket ticket, bool ticketFound)
{
if (ticketFound)
{
lock (tvcard.Tuner.CardReservationsLock)
{
Log.Debug("CardReservation.RemoveTuneTicket: removed reservation with id={0}, tuningdetails={1}", ticket.Id, ticket.TuningDetail);
tvcard.Tuner.ReservationsForTune.Remove(ticket);
ResetCardTuneStateToIdle(tvcard);
}
}
}
protected override bool IsCamAlreadyDecodingChannel(ITvCardHandler tvcard, IChannel tuningDetail)
{
bool isCamAlreadyDecodingChannel = false;
ICardTuneReservationTicket ticket = GetCardTuneReservationTicket(tvcard.DataBaseCard.IdCard);
if (ticket != null)
{
//TODO: check code
isCamAlreadyDecodingChannel = (ticket.IsCamAlreadyDecodingChannel);
}
return(isCamAlreadyDecodingChannel);
}
protected override int GetNumberOfUsersOnCurrentChannel(ITvCardHandler tvcard, IUser user)
{
int numberOfUsersOnCurrentChannel = 0;
ICardTuneReservationTicket ticket = GetCardTuneReservationTicket(tvcard.DataBaseCard.IdCard);
if (ticket != null)
{
//TODO: check code
numberOfUsersOnCurrentChannel = ticket.NumberOfUsersOnSameCurrentChannel;
}
return(numberOfUsersOnCurrentChannel);
}
private bool TuneEPGgrabber(Channel channel, IChannel tuning, Card card, TvResult result)
{
try
{
_user.CardId = Card.IdCard;
ITvCardHandler cardHandler;
if (_tvController.CardCollection.TryGetValue(Card.IdCard, out cardHandler))
{
ICardTuneReservationTicket ticket = null;
try
{
ICardReservation cardReservationImpl = new CardReservationTimeshifting(_tvController);
ticket = cardReservationImpl.RequestCardTuneReservation(cardHandler, tuning, _user, channel.IdChannel);
if (ticket != null)
{
result = _tvController.Tune(ref _user, tuning, channel.IdChannel, ticket);
if (result == TvResult.Succeeded)
{
if (!_isRunning || false == _tvController.GrabEpg(this, Card.IdCard))
{
if (!_isRunning)
{
Log.Epg("Tuning finished but EpgGrabber no longer enabled");
}
_tvController.StopGrabbingEpg(_user);
_user.CardId = -1;
Log.Epg("Epg: card:{0} could not start dvbt grabbing", Card.IdCard);
return(false);
}
_user.CardId = Card.IdCard;
return(true);
}
}
}
catch (Exception)
{
CardReservationHelper.CancelCardReservation(cardHandler, ticket);
throw;
}
}
_user.CardId = -1;
Log.Epg("Epg: card:{0} could not tune to channel:{1}", Card.IdCard, result.ToString());
return(false);
}
catch (Exception ex)
{
Log.Write(ex);
throw;
}
}
public static ICardTuneReservationTicket RequestCardReservation(IUser user, CardDetail cardDetail, TVController tvController, ICardReservation cardResImpl, int idChannel)
{
ICardTuneReservationTicket ticket = null;
int idCard = cardDetail.Card.IdCard;
IUser userCopy = user.Clone() as User;
if (userCopy != null)
{
IDictionary <int, ITvCardHandler> cards = tvController.CardCollection;
userCopy.CardId = idCard;
ITvCardHandler tvcard = cards[idCard];
ticket = cardResImpl.RequestCardTuneReservation(tvcard, cardDetail.TuningDetail, userCopy, idChannel);
}
return(ticket);
}
public static void CancelCardReservation(ITvCardHandler tvCardHandler, ICardTuneReservationTicket ticket)
{
lock (tvCardHandler.Tuner.CardReservationsLock)
{
if (ticket != null && tvCardHandler.Tuner.ReservationsForTune.Contains(ticket))
{
Log.Debug("CardReservation.CancelCardReservation id={0}", ticket.Id);
if (tvCardHandler.Tuner.ActiveCardTuneReservationTicket != null && tvCardHandler.Tuner.ActiveCardTuneReservationTicket.Id == ticket.Id)
{
tvCardHandler.Tuner.ActiveCardTuneReservationTicket = null;
}
tvCardHandler.Tuner.ReservationsForTune.Remove(ticket);
ResetCardTuneStateToIdle(tvCardHandler);
}
else
{
//Log.Debug("CardReservation.CancelCardReservation FAILED id={0}", ticket.Id);
}
}
}
public IList <CardDetail> UpdateFreeCardsForChannelBasedOnTicket(ICollection <CardDetail> cardsAvailable, IUser user, out TvResult result)
{
var cardetails = new List <CardDetail>();
foreach (CardDetail cardDetail in cardsAvailable)
{
ICardTuneReservationTicket ticket = GetCardTuneReservationTicket(cardDetail.Card.IdCard);
if (ticket != null)
{
cardDetail.SameTransponder = ticket.IsSameTransponder;
cardDetail.NumberOfOtherUsers = ticket.NumberOfOtherUsersOnCurrentCard;
LogNumberOfOtherUsersFound(cardDetail);
IDictionary <int, ITvCardHandler> cards = _controller.CardCollection;
IChannel tuningDetail = cardDetail.TuningDetail;
bool checkTransponder = CheckTransponder(user,
cards[cardDetail.Card.IdCard],
tuningDetail);
if (checkTransponder)
{
cardetails.Add(cardDetail);
}
}
}
cardetails.SortStable();
if (cardetails.Count > 0)
{
result = TvResult.Succeeded;
}
else
{
result = cardsAvailable.Count == 0 ? TvResult.ChannelNotMappedToAnyCard : TvResult.AllCardsBusy;
}
return(cardetails);
}
protected override bool IsOwnerOfCard(ITvCardHandler tvcard, IUser user)
{
bool isOwnerOfCard = false;
ICardTuneReservationTicket ticket = GetCardTuneReservationTicket(tvcard.DataBaseCard.IdCard);
if (ticket != null)
{
bool hasHighestPriority = ticket.HasHighestPriority;
if (hasHighestPriority)
{
isOwnerOfCard = true;
}
else
{
bool hasEqualOrHigherPriority = ticket.HasEqualOrHigherPriority;
if (hasEqualOrHigherPriority)
{
isOwnerOfCard = ticket.IsOwner;
}
}
}
return(isOwnerOfCard);
}
public static IDictionary <CardDetail, ICardTuneReservationTicket> RequestCardReservations(IUser user, IEnumerable <CardDetail> availCardsForReservation, TVController tvController, ICardReservation cardResImpl, IEnumerable <CardDetail> ignoreCards, int idChannel)
{
IDictionary <CardDetail, ICardTuneReservationTicket> tickets = new Dictionary <CardDetail, ICardTuneReservationTicket>();
ICollection <int> cardIds = new HashSet <int>();
foreach (CardDetail cardDetail in availCardsForReservation)
{
ICardTuneReservationTicket ticket = null;
int idCard = cardDetail.Card.IdCard;
bool cardAlreadyHasTicket = cardIds.Contains(idCard);
if (!cardAlreadyHasTicket)
{
bool foundIgnoredCard = ignoreCards.Contains(cardDetail);
if (!foundIgnoredCard)
{
ticket = RequestCardReservation(user, cardDetail, tvController, cardResImpl, idChannel);
}
cardIds.Add(idCard);
}
tickets.Add(cardDetail, ticket);
}
return(tickets);
}
public TvResult Tune(ITvCardHandler tvcard, ref IUser user, IChannel channel, int idChannel, ICardTuneReservationTicket ticket)
{
TvResult tvResult = TvResult.AllCardsBusy;
bool ticketFound;
bool isTuningPending = CardReservationHelper.GetIsTuningPending(tvcard, ticket, out ticketFound);
try
{
if (isTuningPending && ticketFound)
{
tvResult = tvcard.Tuner.Tune(ref user, channel, idChannel);
bool succes = (tvResult == TvResult.Succeeded);
if (succes)
{
if (!OnStartTune(user))
{
tvResult = TvResult.AllCardsBusy;
}
}
CardReservationHelper.SetCardStateBasedOnTVresult(tvcard, tvResult);
}
else // state is not tuning, some other card tune session is busy.
{
}
}
finally
{
CardReservationHelper.RemoveTuneTicket(tvcard, ticket, ticketFound);
tvcard.Tuner.CleanUpPendingTune(ticket.PendingSubchannel);
}
return(tvResult);
}
private bool SetupAndStartRecord(RecordingDetail recDetail, ref IUser user, CardDetail cardInfo, ICardTuneReservationTicket ticket, CardReservationRec cardResImpl)
{
bool result = false;
if (cardInfo != null)
{
user.CardId = cardInfo.Id;
StartRecordingNotification(recDetail);
SetupRecordingFolder(cardInfo);
if (StartRecordingOnDisc(recDetail, ref user, cardInfo, ticket, cardResImpl))
{
CreateRecording(recDetail);
try
{
recDetail.User.CardId = user.CardId;
SetRecordingProgramState(recDetail);
_recordingsInProgressList.Add(recDetail);
RecordingStartedNotification(recDetail);
SetupQualityControl(recDetail);
WriteMatroskaFile(recDetail);
}
catch (Exception ex)
{
//consume exception, since it isn't catastrophic
Log.Write(ex);
}
Log.Write("Scheduler: recList: count: {0} add scheduleid: {1} card: {2}",
_recordingsInProgressList.Count,
recDetail.Schedule.IdSchedule, recDetail.CardInfo.Card.Name);
result = true;
}
}
else
{
Log.Write("scheduler: no card found to record on.");
}
return result;
}
public static bool GetIsTuningPending(ITvCardHandler tvcard, ICardTuneReservationTicket ticket, out bool ticketFound)
{
bool isTuningPending;
bool cardStopStateIdle;
lock (tvcard.Tuner.CardReservationsLock)
{
cardStopStateIdle = (tvcard.Tuner.CardStopState == CardStopState.Idle);
isTuningPending = (tvcard.Tuner.CardTuneState == CardTuneState.TunePending);
ticketFound = (tvcard.Tuner.ReservationsForTune.Contains(ticket));
if (isTuningPending && cardStopStateIdle)
{
if (ticketFound)
{
tvcard.Tuner.CardTuneState = CardTuneState.Tuning;
}
else
{
//_cardTuneState = CardTuneState.TunePending;
}
}
}
if (ticket == null)
{
Log.Debug("GetIsTuningPending: ticket is null!");
}
return (isTuningPending && cardStopStateIdle);
}
public TvResult CardTune(ITvCardHandler tvcard, ref IUser user, IChannel channel, Channel dbChannel, ICardTuneReservationTicket ticket)
{
TvResult tvResult = TvResult.AllCardsBusy;
bool ticketFound;
bool isTuningPending = CardReservationHelper.GetIsTuningPending(tvcard, ticket, out ticketFound);
try
{
if (isTuningPending && ticketFound)
{
user.IsFreeToAir = ticket.TuningDetail.FreeToAir;
Log.Debug("CardReservationBase.CardTune: tvcard={0}, user={1}, dbChannel={2}, ticket={3}, tunestate={4}, stopstate={5}, ticketFTA={6}", tvcard.DataBaseCard.IdCard, user.Name, dbChannel.IdChannel, ticket.Id, tvcard.Tuner.CardTuneState, tvcard.Tuner.CardStopState, ticket.TuningDetail.FreeToAir);
tvResult = tvcard.Tuner.CardTune(ref user, channel, dbChannel);
if (tvResult == TvResult.Succeeded)
{
if (OnStartCardTune != null)
{
if (!_tvController.IsTimeShifting(ref user))
{
CleanTimeShiftFiles(tvcard.DataBaseCard.TimeShiftFolder,
String.Format("live{0}-{1}.ts", user.CardId, user.SubChannel));
}
string timeshiftFileName = String.Format(@"{0}\live{1}-{2}.ts", tvcard.DataBaseCard.TimeShiftFolder,
user.CardId,
user.SubChannel);
tvResult = OnStartCardTune(ref user, ref timeshiftFileName);
}
}
CardReservationHelper.SetCardStateBasedOnTVresult(tvcard, tvResult);
}
else // state is not tuning, some other card tune session is busy.
{
}
}
finally
{
CardReservationHelper.RemoveTuneTicket(tvcard, ticket, ticketFound);
tvcard.Tuner.CleanUpPendingTune(ticket.PendingSubchannel);
}
return(tvResult);
}
public static void RemoveTuneTicket(ITvCardHandler tvcard, ICardTuneReservationTicket ticket, bool ticketFound)
{
if (ticketFound)
{
lock (tvcard.Tuner.CardReservationsLock)
{
Log.Debug("CardReservation.RemoveTuneTicket: removed reservation with id={0}, tuningdetails={1}", ticket.Id, ticket.TuningDetail);
tvcard.Tuner.ReservationsForTune.Remove(ticket);
ResetCardTuneStateToIdle(tvcard);
}
}
}
public static void CancelCardReservation(ITvCardHandler tvCardHandler, ICardTuneReservationTicket ticket)
{
lock (tvCardHandler.Tuner.CardReservationsLock)
{
if (ticket != null && tvCardHandler.Tuner.ReservationsForTune.Contains(ticket))
{
Log.Debug("CardReservation.CancelCardReservation id={0}", ticket.Id);
if (tvCardHandler.Tuner.ActiveCardTuneReservationTicket != null && tvCardHandler.Tuner.ActiveCardTuneReservationTicket.Id == ticket.Id)
{
tvCardHandler.Tuner.ActiveCardTuneReservationTicket = null;
}
tvCardHandler.Tuner.ReservationsForTune.Remove(ticket);
ResetCardTuneStateToIdle(tvCardHandler);
}
else
{
//Log.Debug("CardReservation.CancelCardReservation FAILED id={0}", ticket.Id);
}
}
}
private void KickUserOnSameTransponder(CardDetail cardDetail, ICardTuneReservationTicket ticket, ref CardDetail cardInfo)
{
bool canKickAllUsersOnTransponder = CanKickAllUsersOnTransponder(ticket);
if (canKickAllUsersOnTransponder)
{
for (int i = 0; i < ticket.TimeshiftingUsers.Count; i++)
{
IUser timeshiftingUser = ticket.TimeshiftingUsers[i];
Log.Write(
"Scheduler : card is tuned to the same transponder but not free. record on card:{0} priority:{1}, kicking user:{2}",
cardDetail.Id, cardDetail.Card.Priority, timeshiftingUser.Name);
_tvController.StopTimeShifting(ref timeshiftingUser, TvStoppedReason.RecordingStarted);
cardInfo = cardDetail;
break;
}
}
}
private bool StartRecordingOnDisc(RecordingDetail recDetail, ref IUser user, CardDetail cardInfo, ICardTuneReservationTicket ticket, CardReservationRec cardResImpl)
{
bool startRecordingOnDisc = false;
_tvController.EpgGrabberEnabled = false;
Log.Write("Scheduler : record, first tune to channel");
cardResImpl.CardInfo = cardInfo;
cardResImpl.RecDetail = recDetail;
TvResult tuneResult = _tvController.Tune(ref user, cardInfo.TuningDetail, recDetail.Channel.IdChannel, ticket, cardResImpl);
startRecordingOnDisc = (tuneResult == TvResult.Succeeded);
return startRecordingOnDisc;
}
private CardDetail HijackCardTimeshiftingOnSameTransponder(IEnumerable<CardDetail> availableCards, ICardTuneReservationTicket ticket)
{
CardDetail cardInfo = null;
foreach (CardDetail cardDetail in availableCards.Where(cardDetail => cardDetail.SameTransponder))
{
KickUserOnSameTransponder(cardDetail, ticket, ref cardInfo);
if (cardInfo != null)
{
break;
}
}
return cardInfo;
}
private static bool CanKickAllUsersOnTransponder(ICardTuneReservationTicket ticket)
{
IList<IUser> recUsers = ticket.RecordingUsers;
bool canKickAll = (recUsers.Count == 0);
return canKickAll;
}
private void KickAllUsersOnTransponder(CardDetail cardDetail, ICardTuneReservationTicket ticket)
{
Log.Write(
"Scheduler : card is not tuned to the same transponder and not recording, kicking all users. record on card:{0} priority:{1}",
cardDetail.Id, cardDetail.Card.Priority);
for (int i = 0; i < ticket.TimeshiftingUsers.Count; i++ )
{
IUser timeshiftingUser = ticket.TimeshiftingUsers[i];
Log.Write(
"Scheduler : kicking user:{0}",
timeshiftingUser.Name);
_tvController.StopTimeShifting(ref timeshiftingUser, TvStoppedReason.RecordingStarted);
Log.Write(
"Scheduler : card is tuned to the same transponder but not free. record on card:{0} priority:{1}, kicking user:{2}",
cardDetail.Id, cardDetail.Card.Priority, timeshiftingUser.Name);
}
}
public ICardTuneReservationTicket RequestCardTuneReservation(ITvCardHandler tvcard, IChannel tuningDetail, IUser user, int idChannel)
{
ICardTuneReservationTicket cardTuneReservationTicket = null;
var layer = new TvBusinessLayer();
CardTuneState cardTuneState;
int ticketId = 0;
bool isCardAvail;
bool hasUserHigherPriorityThanBlockingUser = false;
lock (tvcard.Tuner.CardReservationsLock)
{
isCardAvail = IsCardAvail(tvcard);
if (!isCardAvail)
{
if (tvcard.Tuner.CardTuneState != CardTuneState.TuneCancelled)
{
IUser blockingUser = GetBlockingUser(tvcard);
hasUserHigherPriorityThanBlockingUser = (HasUserHigherPriorityThanBlockingUser(user, blockingUser));
if (hasUserHigherPriorityThanBlockingUser)
{
tvcard.Tuner.CardTuneState = CardTuneState.TuneCancelled;
}
}
}
}
if (!isCardAvail)
{
if (hasUserHigherPriorityThanBlockingUser)
{
tvcard.Tuner.CancelTune(tvcard.Tuner.ActiveCardTuneReservationTicket.PendingSubchannel);
lock (tvcard.Tuner.CardReservationsLock)
{
isCardAvail = IsCardAvail(tvcard);
}
}
}
lock (tvcard.Tuner.CardReservationsLock)
{
if (isCardAvail)
{
tvcard.Tuner.CardTuneState = CardTuneState.TunePending;
bool isTunedToTransponder = IsTunedToTransponder(tvcard, tuningDetail);
int ownerSubchannel = -1;
int numberOfUsersOnSameCurrentChannel = 0;
int numberOfOtherUsersOnSameChannel = 0;
int numberOfOtherUsersOnCurrentCard = 0;
bool hasUserHighestPriority = false;
bool hasUserEqualOrHigherPriority = false;
bool isCamAlreadyDecodingChannel = false;
bool conflictingSubchannelFound = false;
bool isRecordingAnyUser = false;
bool isAnySubChannelTimeshifting = tvcard.TimeShifter.IsAnySubChannelTimeshifting;
bool isOwner = tvcard.Users.IsOwner(user);
var users = new List <IUser>(tvcard.Users.GetUsers());
var inactiveUsers = new List <IUser>();
var activeUsers = new List <IUser>();
var recUsers = new List <IUser>();
var tsUsers = new List <IUser>();
var context = tvcard.Card.Context as ITvCardContext;
if (context != null)
{
context.GetUser(ref user);
hasUserHighestPriority = context.HasUserHighestPriority(user);
hasUserEqualOrHigherPriority = context.HasUserEqualOrHigherPriority(user);
}
int currentChannelId = tvcard.CurrentDbChannel(ref user);
for (int i = users.Count - 1; i > -1; i--)
{
IUser actualUser = users[i];
CardReservationHelper.AddUserIfRecording(tvcard, ref actualUser, recUsers);
CardReservationHelper.AddUserIfTimeshifting(tvcard, ref actualUser, tsUsers);
bool isCurrentUser = user.Name.Equals(actualUser.Name);
IChannel userChannel = tvcard.CurrentChannel(ref actualUser);
var userDVBchannel = userChannel as DVBBaseChannel;
if (!isCurrentUser)
{
if (!isRecordingAnyUser)
{
isRecordingAnyUser = CardReservationHelper.IsRecordingUser(tvcard, user, ref actualUser);
}
if (actualUser.SubChannel == user.SubChannel && user.IdChannel > 0)
{
conflictingSubchannelFound = true;
}
numberOfOtherUsersOnCurrentCard = CardReservationHelper.GetNumberOfOtherUsersOnCurrentCard(user,
numberOfOtherUsersOnCurrentCard);
if (userChannel == null)
{
inactiveUsers.Add(actualUser);
}
else
{
if (userDVBchannel != null)
{
actualUser.IdChannel = layer.GetTuningDetail(userDVBchannel).IdChannel;
}
bool isDiffTS = tuningDetail.IsDifferentTransponder(userChannel);
if (isDiffTS)
{
activeUsers.Add(actualUser);
}
else
{
if (!isOwner)
{
bool isUserOnSameChannel = CardReservationHelper.IsUserOnSameChannel(tuningDetail, layer,
userDVBchannel);
if (isUserOnSameChannel)
{
numberOfOtherUsersOnSameChannel++;
//we do not want to hook up on schedulers existing subchannel
if (!actualUser.IsAdmin)
{
ownerSubchannel = actualUser.SubChannel;
}
}
}
}
}
}
bool isUserOnSameCurrentChannel = CardReservationHelper.IsUserOnSameCurrentChannel(currentChannelId, actualUser);
if (isUserOnSameCurrentChannel)
{
numberOfUsersOnSameCurrentChannel++;
}
if (!isCamAlreadyDecodingChannel)
{
isCamAlreadyDecodingChannel = IsCamAlreadyDecodingChannel(tuningDetail, userChannel);
}
}
bool isFreeToAir = CardReservationHelper.IsFreeToAir(tvcard, user);
cardTuneReservationTicket = new CardTuneReservationTicket
(
user,
tuningDetail,
isTunedToTransponder,
numberOfOtherUsersOnSameChannel,
isAnySubChannelTimeshifting,
inactiveUsers,
activeUsers,
users,
ownerSubchannel,
isOwner,
tvcard.DataBaseCard.IdCard,
tvcard.NumberOfChannelsDecrypting,
isFreeToAir,
numberOfOtherUsersOnCurrentCard,
recUsers,
tsUsers,
conflictingSubchannelFound,
numberOfUsersOnSameCurrentChannel,
isCamAlreadyDecodingChannel,
hasUserHighestPriority,
hasUserEqualOrHigherPriority);
tvcard.Tuner.ActiveCardTuneReservationTicket = cardTuneReservationTicket;
tvcard.Tuner.ReservationsForTune.Add(cardTuneReservationTicket);
}
cardTuneState = tvcard.Tuner.CardTuneState;
if (tvcard.Tuner.ActiveCardTuneReservationTicket != null)
{
ticketId = tvcard.Tuner.ActiveCardTuneReservationTicket.Id;
}
}
if (cardTuneReservationTicket != null)
{
Log.Debug("RequestCardTuneReservation: placed reservation with id={0}, tuningdetails={1}", cardTuneReservationTicket.Id, cardTuneReservationTicket.TuningDetail);
}
else
{
if (ticketId > 0)
{
Log.Debug("RequestCardTuneReservation: failed reservation tuningdetails={0}, res id blocking={1}, state={2}", tuningDetail, ticketId, cardTuneState);
}
else
{
Log.Debug("RequestCardTuneReservation: failed reservation tuningdetails={0}, res id blocking={1}, state={2}", tuningDetail, "n/a", cardTuneState);
}
}
return(cardTuneReservationTicket);
}
public TvResult Tune(ITvCardHandler tvcard, ref IUser user, IChannel channel, int idChannel, ICardTuneReservationTicket ticket)
{
TvResult tvResult = TvResult.AllCardsBusy;
bool ticketFound;
bool isTuningPending = CardReservationHelper.GetIsTuningPending(tvcard, ticket, out ticketFound);
try
{
if (isTuningPending && ticketFound)
{
tvResult = tvcard.Tuner.Tune(ref user, channel, idChannel);
bool succes = (tvResult == TvResult.Succeeded);
if (succes)
{
if (!OnStartTune(user))
{
tvResult = TvResult.AllCardsBusy;
}
}
CardReservationHelper.SetCardStateBasedOnTVresult(tvcard, tvResult);
}
else // state is not tuning, some other card tune session is busy.
{
}
}
finally
{
CardReservationHelper.RemoveTuneTicket(tvcard, ticket, ticketFound);
tvcard.Tuner.CleanUpPendingTune(ticket.PendingSubchannel);
}
return tvResult;
}
private CardDetail HijackCardForRecording(ICollection<CardDetail> availableCards, ICardTuneReservationTicket ticket)
{
CardDetail cardInfo = HijackCardTimeshiftingOnSameTransponder(availableCards, ticket);
if (cardInfo == null)
{
cardInfo = HijackCardTimeshiftingOnDifferentTransponder(availableCards, ticket);
}
if (cardInfo == null)
{
Log.Write("Scheduler : no free card was found and no card was found where user can be kicked.");
}
return cardInfo;
}
private CardDetail HijackCardTimeshiftingOnDifferentTransponder(IEnumerable<CardDetail> availableCards, ICardTuneReservationTicket ticket)
{
CardDetail cardInfo = null;
foreach (CardDetail cardDetail in availableCards)
{
if (!cardDetail.SameTransponder)
{
bool canKickAll = CanKickAllUsersOnTransponder(ticket);
if (canKickAll)
{
cardInfo = cardDetail;
KickAllUsersOnTransponder(cardDetail, ticket);
break;
}
}
}
return cardInfo;
}
public TvResult CardTune(ITvCardHandler tvcard, ref IUser user, IChannel channel, Channel dbChannel, ICardTuneReservationTicket ticket)
{
TvResult tvResult = TvResult.AllCardsBusy;
bool ticketFound;
bool isTuningPending = CardReservationHelper.GetIsTuningPending(tvcard, ticket, out ticketFound);
try
{
if (isTuningPending && ticketFound)
{
Log.Debug("CardReservationBase: tvcard={0}, user={1}, dbChannel={2}, ticket={3}, tunestate={4}, stopstate={5}", tvcard.DataBaseCard.IdCard, user.Name, dbChannel.IdChannel, ticket.Id, tvcard.Tuner.CardTuneState, tvcard.Tuner.CardStopState);
tvResult = tvcard.Tuner.CardTune(ref user, channel, dbChannel);
if (tvResult == TvResult.Succeeded)
{
if (OnStartCardTune != null)
{
if (!_tvController.IsTimeShifting(ref user))
{
CleanTimeShiftFiles(tvcard.DataBaseCard.TimeShiftFolder,
String.Format("live{0}-{1}.ts", user.CardId, user.SubChannel));
}
string timeshiftFileName = String.Format(@"{0}\live{1}-{2}.ts", tvcard.DataBaseCard.TimeShiftFolder,
user.CardId,
user.SubChannel);
tvResult = OnStartCardTune(ref user, ref timeshiftFileName);
}
}
CardReservationHelper.SetCardStateBasedOnTVresult(tvcard, tvResult);
}
else // state is not tuning, some other card tune session is busy.
{
}
}
finally
{
CardReservationHelper.RemoveTuneTicket(tvcard, ticket, ticketFound);
tvcard.Tuner.CleanUpPendingTune(ticket.PendingSubchannel);
}
return tvResult;
}
public IList <CardDetail> UpdateFreeCardsForChannelBasedOnTicket(ICollection <CardDetail> cardsAvailable, IUser user, out TvResult result)
{
if (LogEnabled)
{
Log.Debug("UpdateFreeCardsForChannelBasedOnTicket: user: {0}", user.Name);
}
var cardsFree = new List <CardDetail>();
// first check if card can be added
bool currLogEn = LogEnabled;
LogEnabled = false;
foreach (CardDetail cardDetail in cardsAvailable)
{
ICardTuneReservationTicket ticket = GetCardTuneReservationTicket(cardDetail.Card.IdCard);
if (ticket != null)
{
cardDetail.SameTransponder = ticket.IsSameTransponder;
cardDetail.NumberOfOtherUsers = ticket.NumberOfOtherUsersOnCurrentCard;
LogNumberOfOtherUsersFound(cardDetail);
IDictionary <int, ITvCardHandler> cards = _controller.CardCollection;
IChannel tuningDetail = cardDetail.TuningDetail;
for (int i = 0; i <= 2; i++)
{
// Try up to 3 times with increasing user priority level
bool checkTransponder = CheckTransponder(user, cards[cardDetail.Card.IdCard], tuningDetail, i);
if (i == 0)
{
cardDetail.SameTranspCAMavail = checkTransponder;
}
if (checkTransponder)
{
cardDetail.TransponderCheckLevel = i;
cardsFree.Add(cardDetail);
break;
}
}
}
}
LogEnabled = currLogEn;
//Sort the list so that the 'most preferred' Card Details are at the front (see 'CardDetail.cs' for sort order)
cardsFree.SortStable();
if (cardsFree.Count > 0)
{
result = TvResult.Succeeded;
}
else
{
result = cardsAvailable.Count == 0 ? TvResult.ChannelNotMappedToAnyCard : TvResult.AllCardsBusy;
}
if (LogEnabled)
{
Log.Info("UpdateFreeCardsForChannelBasedOnTicket found {0} free card(s), user:{1}", cardsFree.Count, user.Name);
for (int i = 0; i < cardsFree.Count; i++)
{
Log.Debug("UpdateFreeCardsForChannelBasedOnTicket, free card:{0}, id:{1}, STCA:{2}, ST:{3}, PRI:{4}, CL:{5}, NOU:{6}",
i, cardsFree[i].Id, cardsFree[i].SameTranspCAMavail, cardsFree[i].SameTransponder, cardsFree[i].Priority,
cardsFree[i].TransponderCheckLevel, cardsFree[i].NumberOfOtherUsers);
}
}
return(cardsFree);
}
