protected override DVBBaseChannel CreateChannel(int networkid, int transportid, int serviceid, string name)
{
DVBIPChannel channel = new DVBIPChannel();
channel.NetworkId = networkid;
channel.TransportId = transportid;
channel.ServiceId = serviceid;
channel.Name = name;
return(channel);
}
/// <summary>
/// CreateNewChannel
/// </summary>
/// <param name="channel">The high level tuning detail.</param>
/// <param name="info">The subchannel detail.</param>
/// <returns>The new channel.</returns>
protected override IChannel CreateNewChannel(IChannel channel, ChannelInfo info)
{
DVBIPChannel tuningChannel = (DVBIPChannel)channel;
DVBIPChannel dvbipChannel = new DVBIPChannel();
dvbipChannel.Name = info.service_name;
dvbipChannel.LogicalChannelNumber = info.LCN;
dvbipChannel.Provider = info.service_provider_name;
dvbipChannel.Url = tuningChannel.Url;
dvbipChannel.IsTv = IsTvService(info.serviceType);
dvbipChannel.IsRadio = IsRadioService(info.serviceType);
dvbipChannel.NetworkId = info.networkID;
dvbipChannel.ServiceId = info.serviceID;
dvbipChannel.TransportId = info.transportStreamID;
dvbipChannel.PmtPid = info.network_pmt_PID;
dvbipChannel.FreeToAir = !info.scrambled;
Log.Log.Write("Found: {0}", dvbipChannel);
return(dvbipChannel);
}
private void DoScan()
{
int tvChannelsNew = 0;
int radioChannelsNew = 0;
int tvChannelsUpdated = 0;
int radioChannelsUpdated = 0;
IUser user = new User();
user.CardId = _cardNumber;
try
{
// First lock the card, because so that other parts of a hybrid card can't be used at the same time
RemoteControl.Instance.EpgGrabberEnabled = false;
TvBusinessLayer layer = new TvBusinessLayer();
Card card = layer.GetCardByDevicePath(RemoteControl.Instance.CardDevice(_cardNumber));
int index = -1;
IEnumerator <PlayListItem> enumerator = playlist.GetEnumerator();
while (enumerator.MoveNext())
{
string url = enumerator.Current.FileName.Substring(enumerator.Current.FileName.LastIndexOf('\\') + 1);
string name = enumerator.Current.Description;
DVBIPChannel tuneChannel = new DVBIPChannel();
tuneChannel.Url = url;
tuneChannel.Name = name;
string line = String.Format("{0}- {1} - {2}", 1 + index, tuneChannel.Name, tuneChannel.Url);
Log.Debug(line);
RemoteControl.Instance.Tune(ref user, tuneChannel, -1);
IChannel[] channels;
channels = RemoteControl.Instance.Scan(_cardNumber, tuneChannel);
if (channels == null || channels.Length == 0)
{
if (RemoteControl.Instance.TunerLocked(_cardNumber) == false)
{
line = String.Format("{0}- {1} - {2} :No Signal", 1 + index, tuneChannel.Url, tuneChannel.Name);
Log.Debug(line);
continue;
}
else
{
line = String.Format("{0}- {1} - {2} :Nothing found", 1 + index, tuneChannel.Url, tuneChannel.Name);
Log.Debug(line);
continue;
}
}
int newChannels = 0;
int updatedChannels = 0;
for (int i = 0; i < channels.Length; ++i)
{
Channel dbChannel;
DVBIPChannel channel = (DVBIPChannel)channels[i];
if (channels.Length > 1)
{
if (channel.Name.IndexOf("Unknown") == 0)
{
channel.Name = name + (i + 1);
}
}
else
{
channel.Name = name;
}
bool exists;
TuningDetail currentDetail;
//Check if we already have this tuningdetail. According to DVB-IP specifications there are two ways to identify DVB-IP
//services: one ONID + SID based, the other domain/URL based. At this time we don't fully and properly implement the DVB-IP
//specifications, so the safest method for service identification is the URL. The user has the option to enable the use of
//ONID + SID identification and channel move detection...
if (true)
{
currentDetail = layer.GetTuningDetail(channel.NetworkId, channel.ServiceId,
TvBusinessLayer.GetChannelType(channel));
}
else
{
currentDetail = layer.GetTuningDetail(channel.Url, TvBusinessLayer.GetChannelType(channel));
}
if (currentDetail == null)
{
//add new channel
exists = false;
dbChannel = layer.AddNewChannel(channel.Name, channel.LogicalChannelNumber);
dbChannel.SortOrder = 10000;
if (channel.LogicalChannelNumber >= 1)
{
dbChannel.SortOrder = channel.LogicalChannelNumber;
}
dbChannel.IsTv = channel.IsTv;
dbChannel.IsRadio = channel.IsRadio;
dbChannel.Persist();
}
else
{
exists = true;
dbChannel = currentDetail.ReferencedChannel();
}
layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.AllChannels);
if (_defaultTVGroup != "")
{
layer.AddChannelToGroup(dbChannel, _defaultTVGroup);
}
if (currentDetail == null)
{
layer.AddTuningDetails(dbChannel, channel);
}
else
{
//update tuning details...
TuningDetail td = layer.UpdateTuningDetails(dbChannel, channel, currentDetail);
td.Persist();
}
if (channel.IsTv)
{
if (exists)
{
tvChannelsUpdated++;
updatedChannels++;
}
else
{
tvChannelsNew++;
newChannels++;
}
}
if (channel.IsRadio)
{
if (exists)
{
radioChannelsUpdated++;
updatedChannels++;
}
else
{
radioChannelsNew++;
newChannels++;
}
}
layer.MapChannelToCard(card, dbChannel, false);
line = String.Format("{0}- {1} :New:{2} Updated:{3}", 1 + index, tuneChannel.Name, newChannels,
updatedChannels);
Log.Debug(line);
}
}
}
catch (Exception ex)
{
Log.Write(ex);
}
finally
{
RemoteControl.Instance.StopCard(user);
}
}
/// <summary>
/// Tune to channel
/// </summary>
/// <param name="subChannelId"></param>
/// <param name="channel"></param>
/// <returns></returns>
private ITvSubChannel DoTune(int subChannelId, IChannel channel, bool ignorePMT)
{
Log.Log.WriteFile("dvbip: Tune:{0}", channel);
ITvSubChannel ch = null;
try
{
DVBIPChannel dvbipChannel = channel as DVBIPChannel;
if (dvbipChannel == null)
{
Log.Log.WriteFile("Channel is not a IP TV channel!!! {0}", channel.GetType().ToString());
return(null);
}
Log.Log.Info("dvbip: tune: Assigning oldChannel");
DVBIPChannel oldChannel = CurrentChannel as DVBIPChannel;
if (CurrentChannel != null)
{
//@FIX this fails for back-2-back recordings
//if (oldChannel.Equals(channel)) return _mapSubChannels[0];
Log.Log.Info("dvbip: tune: Current Channel != null {0}", CurrentChannel.ToString());
}
else
{
Log.Log.Info("dvbip: tune: Current channel is null");
}
if (_graphState == GraphState.Idle)
{
Log.Log.Info("dvbip: tune: Building graph");
BuildGraph();
if (_mapSubChannels.ContainsKey(subChannelId) == false)
{
subChannelId = GetNewSubChannel(channel);
}
}
else
{
Log.Log.Info("dvbip: tune: Graph is running");
}
//_pmtPid = -1;
Log.Log.Info("dvb:Submiting tunerequest Channel:{0} subChannel:{1} ", channel.Name, subChannelId);
if (_mapSubChannels.ContainsKey(subChannelId) == false)
{
Log.Log.Info("dvb:Getting new subchannel");
subChannelId = GetNewSubChannel(channel);
}
else
{
}
Log.Log.Info("dvb:Submit tunerequest size:{0} new:{1}", _mapSubChannels.Count, subChannelId);
_mapSubChannels[subChannelId].CurrentChannel = channel;
_mapSubChannels[subChannelId].OnBeforeTune();
if (_interfaceEpgGrabber != null)
{
_interfaceEpgGrabber.Reset();
}
Log.Log.WriteFile("dvb:Submit tunerequest calling put_TuneRequest");
_lastSignalUpdate = DateTime.MinValue;
_mapSubChannels[subChannelId].OnAfterTune();
ch = _mapSubChannels[subChannelId];
Log.Log.Info("dvbip: tune: Running graph for channel {0}", ch.ToString());
Log.Log.Info("dvbip: tune: SubChannel {0}", ch.SubChannelId);
try
{
RunGraph(ch.SubChannelId, dvbipChannel.Url);
}
catch (TvExceptionNoPMT)
{
if (!ignorePMT)
{
throw;
}
}
Log.Log.Info("dvbip: tune: Graph running. Returning {0}", ch.ToString());
return(ch);
}
catch (Exception ex)
{
if (ch != null)
{
FreeSubChannel(ch.SubChannelId);
}
Log.Log.Write(ex);
throw;
}
//unreachable return null;
}
/// <summary>
/// This method will try to start the epg grabber for the channel and tuning details specified
/// Epg grabbing can only be started if there is a card idle which can receive the channel specified
/// </summary>
/// <param name="channel">channel to grab/param>
/// <param name="tuning">tuning information</param>
/// <param name="card">card to use for grabbing</param>
/// <returns>true if grabbing has started else false</returns>
private bool GrabEpgForChannel(Channel channel, IChannel tuning, Card card)
{
if (channel == null)
{
Log.Error("Epg: invalid channel");
return(false);
}
if (tuning == null)
{
Log.Error("Epg: invalid tuning");
return(false);
}
if (card == null)
{
Log.Error("Epg: invalid card");
return(false);
}
if (_tvController == null)
{
Log.Error("Epg: invalid tvcontroller");
return(false);
}
if (_user == null)
{
Log.Error("Epg: invalid user");
return(false);
}
//remove following check to enable multi-card epg grabbing (still beta)
if (_tvController.AllCardsIdle == false)
{
Log.Epg("Epg: card:{0} cards are not idle", Card.IdCard);
return(false);
}
TvResult result = TvResult.UnknownError;
//handle ATSC
ATSCChannel atscChannel = tuning as ATSCChannel;
if (atscChannel != null)
{
if (_tvController.Type(Card.IdCard) == CardType.Atsc)
{
if (IsCardIdle(Card.IdCard) == false)
{
Log.Epg("Epg: card:{0} atsc card is not idle", Card.IdCard);
return(false); //card is busy
}
return(TuneEPGgrabber(channel, tuning, card, result));
}
Log.Epg("Epg: card:{0} could not tune to atsc channel:{1}", Card.IdCard, tuning.ToString());
return(false);
}
//handle DVBC
DVBCChannel dvbcChannel = tuning as DVBCChannel;
if (dvbcChannel != null)
{
if (_tvController.Type(Card.IdCard) == CardType.DvbC)
{
if (IsCardIdle(Card.IdCard) == false)
{
Log.Epg("Epg: card:{0} dvbc card is not idle", Card.IdCard);
return(false); //card is busy
}
return(TuneEPGgrabber(channel, tuning, card, result));
}
Log.Epg("Epg: card:{0} could not tune to dvbc channel:{1}", Card.IdCard, tuning.ToString());
return(false);
}
//handle DVBS
DVBSChannel dvbsChannel = tuning as DVBSChannel;
if (dvbsChannel != null)
{
if (_tvController.Type(Card.IdCard) == CardType.DvbS)
{
if (IsCardIdle(Card.IdCard) == false)
{
Log.Epg("Epg: card:{0} dvbs card is not idle", Card.IdCard);
return(false); //card is busy
}
return(TuneEPGgrabber(channel, tuning, card, result));
}
Log.Epg("Epg: card:{0} could not tune to dvbs channel:{1}", Card.IdCard, tuning.ToString());
return(false);
}
//handle DVBT
DVBTChannel dvbtChannel = tuning as DVBTChannel;
if (dvbtChannel != null)
{
if (_tvController.Type(Card.IdCard) == CardType.DvbT)
{
if (IsCardIdle(Card.IdCard) == false)
{
Log.Epg("Epg: card:{0} dvbt card is not idle", Card.IdCard);
return(false); //card is busy
}
return(TuneEPGgrabber(channel, tuning, card, result));
}
Log.Epg("Epg: card:{0} could not tune to dvbt channel:{1}", Card.IdCard, tuning.ToString());
return(false);
}
//handle DVBIP
DVBIPChannel dvbipChannel = tuning as DVBIPChannel;
if (dvbipChannel != null)
{
if (_tvController.Type(Card.IdCard) == CardType.DvbIP)
{
if (IsCardIdle(Card.IdCard) == false)
{
Log.Epg("Epg: card:{0} dvbip card is not idle", Card.IdCard);
return(false); //card is busy
}
return(TuneEPGgrabber(channel, tuning, card, result));
}
else
{
Log.Epg("Epg: card:{0} could not tune to dvbip channel:{1}", Card.IdCard, tuning.ToString());
}
return(false);
}
Log.Epg("Epg: card:{0} could not tune to channel:{1}", Card.IdCard, tuning.ToString());
return(false);
}
private void DoScan()
{
int tvChannelsNew = 0;
int radioChannelsNew = 0;
int tvChannelsUpdated = 0;
int radioChannelsUpdated = 0;
string buttonText = mpButtonScanTv.Text;
IUser user = new User();
user.CardId = _cardNumber;
try
{
// First lock the card, because so that other parts of a hybrid card can't be used at the same time
_isScanning = true;
_stopScanning = false;
mpButtonScanTv.Text = "Cancel...";
RemoteControl.Instance.EpgGrabberEnabled = false;
listViewStatus.Items.Clear();
PlayList playlist = new PlayList();
if (mpComboBoxService.SelectedIndex == 0)
{
//TODO read SAP announcements
}
else
{
IPlayListIO playlistIO =
PlayListFactory.CreateIO(String.Format(@"{0}\TuningParameters\dvbip\{1}.m3u", PathManager.GetDataPath,
mpComboBoxService.SelectedItem));
playlistIO.Load(playlist,
String.Format(@"{0}\TuningParameters\dvbip\{1}.m3u", PathManager.GetDataPath,
mpComboBoxService.SelectedItem));
}
if (playlist.Count == 0)
{
return;
}
mpComboBoxService.Enabled = false;
checkBoxCreateGroups.Enabled = false;
checkBoxEnableChannelMoveDetection.Enabled = false;
TvBusinessLayer layer = new TvBusinessLayer();
Card card = layer.GetCardByDevicePath(RemoteControl.Instance.CardDevice(_cardNumber));
int index = -1;
IEnumerator <PlayListItem> enumerator = playlist.GetEnumerator();
while (enumerator.MoveNext())
{
if (_stopScanning)
{
return;
}
index++;
float percent = ((float)(index)) / playlist.Count;
percent *= 100f;
if (percent > 100f)
{
percent = 100f;
}
progressBar1.Value = (int)percent;
string url = enumerator.Current.FileName.Substring(enumerator.Current.FileName.LastIndexOf('\\') + 1);
string name = enumerator.Current.Description;
DVBIPChannel tuneChannel = new DVBIPChannel();
tuneChannel.Url = url;
tuneChannel.Name = name;
string line = String.Format("{0}- {1} - {2}", 1 + index, tuneChannel.Name, tuneChannel.Url);
ListViewItem item = listViewStatus.Items.Add(new ListViewItem(line));
item.EnsureVisible();
RemoteControl.Instance.Tune(ref user, tuneChannel, -1);
IChannel[] channels;
channels = RemoteControl.Instance.Scan(_cardNumber, tuneChannel);
UpdateStatus();
if (channels == null || channels.Length == 0)
{
if (RemoteControl.Instance.TunerLocked(_cardNumber) == false)
{
line = String.Format("{0}- {1} :No Signal", 1 + index, tuneChannel.Url);
item.Text = line;
item.ForeColor = Color.Red;
continue;
}
else
{
line = String.Format("{0}- {1} :Nothing found", 1 + index, tuneChannel.Url);
item.Text = line;
item.ForeColor = Color.Red;
continue;
}
}
int newChannels = 0;
int updatedChannels = 0;
for (int i = 0; i < channels.Length; ++i)
{
Channel dbChannel;
DVBIPChannel channel = (DVBIPChannel)channels[i];
if (channels.Length > 1)
{
if (channel.Name.IndexOf("Unknown") == 0)
{
channel.Name = name + (i + 1);
}
}
else
{
channel.Name = name;
}
bool exists;
TuningDetail currentDetail;
//Check if we already have this tuningdetail. According to DVB-IP specifications there are two ways to identify DVB-IP
//services: one ONID + SID based, the other domain/URL based. At this time we don't fully and properly implement the DVB-IP
//specifications, so the safest method for service identification is the URL. The user has the option to enable the use of
//ONID + SID identification and channel move detection...
if (checkBoxEnableChannelMoveDetection.Checked)
{
currentDetail = layer.GetTuningDetail(channel.NetworkId, channel.ServiceId,
TvBusinessLayer.GetChannelType(channel));
}
else
{
currentDetail = layer.GetTuningDetail(channel.Url, TvBusinessLayer.GetChannelType(channel));
}
if (currentDetail == null)
{
//add new channel
exists = false;
dbChannel = layer.AddNewChannel(channel.Name, channel.LogicalChannelNumber);
dbChannel.SortOrder = 10000;
if (channel.LogicalChannelNumber >= 1)
{
dbChannel.SortOrder = channel.LogicalChannelNumber;
}
dbChannel.IsTv = channel.IsTv;
dbChannel.IsRadio = channel.IsRadio;
dbChannel.Persist();
}
else
{
exists = true;
dbChannel = currentDetail.ReferencedChannel();
}
layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.AllChannels);
if (checkBoxCreateGroups.Checked)
{
layer.AddChannelToGroup(dbChannel, channel.Provider);
}
if (currentDetail == null)
{
layer.AddTuningDetails(dbChannel, channel);
}
else
{
//update tuning details...
TuningDetail td = layer.UpdateTuningDetails(dbChannel, channel, currentDetail);
td.Persist();
}
if (channel.IsTv)
{
if (exists)
{
tvChannelsUpdated++;
updatedChannels++;
}
else
{
tvChannelsNew++;
newChannels++;
}
}
if (channel.IsRadio)
{
if (exists)
{
radioChannelsUpdated++;
updatedChannels++;
}
else
{
radioChannelsNew++;
newChannels++;
}
}
layer.MapChannelToCard(card, dbChannel, false);
line = String.Format("{0}- {1} :New:{2} Updated:{3}", 1 + index, tuneChannel.Name, newChannels,
updatedChannels);
item.Text = line;
}
}
//DatabaseManager.Instance.SaveChanges();
}
catch (Exception ex)
{
Log.Write(ex);
}
finally
{
RemoteControl.Instance.StopCard(user);
RemoteControl.Instance.EpgGrabberEnabled = true;
progressBar1.Value = 100;
mpComboBoxService.Enabled = true;
checkBoxCreateGroups.Enabled = true;
checkBoxEnableChannelMoveDetection.Enabled = true;
mpButtonScanTv.Text = buttonText;
_isScanning = false;
}
ListViewItem lastItem = listViewStatus.Items.Add(new ListViewItem("Scan done..."));
lastItem =
listViewStatus.Items.Add(
new ListViewItem(String.Format("Total radio channels new:{0} updated:{1}", radioChannelsNew,
radioChannelsUpdated)));
lastItem =
listViewStatus.Items.Add(
new ListViewItem(String.Format("Total tv channels new:{0} updated:{1}", tvChannelsNew, tvChannelsUpdated)));
lastItem.EnsureVisible();
}
private void importButton_Click(object sender, EventArgs e)
{
bool importtv = imCheckTvChannels.Checked;
bool importtvgroups = imCheckTvGroups.Checked;
bool importradio = imCheckRadioChannels.Checked;
bool importradiogroups = imCheckRadioGroups.Checked;
bool importschedules = imCheckSchedules.Checked;
openFileDialog1.CheckFileExists = true;
openFileDialog1.DefaultExt = "xml";
openFileDialog1.RestoreDirectory = true;
openFileDialog1.Title = "Load channels, channel groups and schedules";
openFileDialog1.InitialDirectory = String.Format(@"{0}\Team MediaPortal\MediaPortal TV Server",
Environment.GetFolderPath(
Environment.SpecialFolder.CommonApplicationData));
openFileDialog1.FileName = "export.xml";
openFileDialog1.AddExtension = true;
openFileDialog1.Multiselect = false;
if (openFileDialog1.ShowDialog(this) != DialogResult.OK)
{
return;
}
NotifyForm dlg = new NotifyForm("Importing tv channels...", "This can take some time\n\nPlease be patient...");
try
{
dlg.Show();
dlg.WaitForDisplay();
CountryCollection collection = new CountryCollection();
TvBusinessLayer layer = new TvBusinessLayer();
bool mergeChannels = false; // every exported channel will be imported on its own.
int channelCount = 0;
int scheduleCount = 0;
int tvChannelGroupCount = 0;
int radioChannelGroupCount = 0;
if (layer.Channels.Count > 0 && (importtv || importradio))
{
// rtv: we could offer to set a "merge" property here so tuningdetails would be updated for existing channels.
if (
MessageBox.Show(
"Existing channels detected! \nIf you continue to import your old backup then all identically named channels will be treated equal - there is a risk of duplicate entries. \nDo you really want to go on?",
"Channels found", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning) == DialogResult.Cancel)
{
return;
}
else
{
mergeChannels = true;
}
}
XmlDocument doc = new XmlDocument();
Log.Info("TvChannels: Trying to import channels from {0}", openFileDialog1.FileName);
doc.Load(openFileDialog1.FileName);
XmlNodeList channelList = doc.SelectNodes("/tvserver/channels/channel");
XmlNodeList tvChannelGroupList = doc.SelectNodes("/tvserver/channelgroups/channelgroup");
XmlNodeList radioChannelGroupList = doc.SelectNodes("/tvserver/radiochannelgroups/radiochannelgroup");
XmlNodeList scheduleList = doc.SelectNodes("/tvserver/schedules/schedule");
if (channelList != null)
{
foreach (XmlNode nodeChannel in channelList)
{
try
{
Channel dbChannel;
XmlNodeList tuningList = nodeChannel.SelectNodes("TuningDetails/tune");
XmlNodeList mappingList = nodeChannel.SelectNodes("mappings/map");
bool grabEpg = (GetNodeAttribute(nodeChannel, "GrabEpg", "True") == "True");
bool isRadio = (GetNodeAttribute(nodeChannel, "IsRadio", "False") == "True");
bool isTv = (GetNodeAttribute(nodeChannel, "IsTv", "True") == "True");
DateTime lastGrabTime = DateTime.ParseExact(GetNodeAttribute(nodeChannel, "LastGrabTime", "01.01.1900"),
"yyyy-M-d H:m:s", CultureInfo.InvariantCulture);
int sortOrder = Int32.Parse(GetNodeAttribute(nodeChannel, "SortOrder", "0"));
int timesWatched = Int32.Parse(GetNodeAttribute(nodeChannel, "TimesWatched", "0"));
DateTime totalTimeWatched =
DateTime.ParseExact(GetNodeAttribute(nodeChannel, "TotalTimeWatched", "01.01.1900"), "yyyy-M-d H:m:s",
CultureInfo.InvariantCulture);
bool visibileInGuide = (GetNodeAttribute(nodeChannel, "VisibleInGuide", "True") == "True");
bool FreeToAir = (GetNodeAttribute(nodeChannel, "FreeToAir", "True") == "True");
string displayName = GetNodeAttribute(nodeChannel, "DisplayName", "Unkown");
// Only import TV or radio channels if the corresponding checkbox was checked
if ((isTv && !importtv) || (isRadio && !importradio))
{
continue;
}
channelCount++;
// rtv: since analog allows NOT to merge channels we need to take care of this. US users e.g. have multiple stations named "Sport" with different tuningdetails.
// using AddChannel would incorrectly "merge" these totally different channels.
// see this: http://forum.team-mediaportal.com/1-0-rc1-svn-builds-271/importing-exported-channel-list-groups-channels-39368/
Log.Info("TvChannels: Adding {0}. channel: {1}", channelCount, displayName);
IList <Channel> foundExistingChannels = layer.GetChannelsByName(displayName);
if (mergeChannels && (foundExistingChannels != null && foundExistingChannels.Count > 0))
{
dbChannel = foundExistingChannels[0];
}
else
{
dbChannel = layer.AddNewChannel(displayName);
}
dbChannel.GrabEpg = grabEpg;
dbChannel.IsRadio = isRadio;
dbChannel.IsTv = isTv;
dbChannel.LastGrabTime = lastGrabTime;
dbChannel.SortOrder = sortOrder;
dbChannel.TimesWatched = timesWatched;
dbChannel.TotalTimeWatched = totalTimeWatched;
dbChannel.VisibleInGuide = visibileInGuide;
dbChannel.DisplayName = displayName;
dbChannel.Persist();
//
// chemelli: When we import channels we need to add those to the "AllChannels" group
//
if (isTv)
{
layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.AllChannels);
}
else
{
layer.AddChannelToRadioGroup(dbChannel, TvConstants.RadioGroupNames.AllChannels);
}
foreach (XmlNode nodeMap in mappingList)
{
int idCard = Int32.Parse(nodeMap.Attributes["IdCard"].Value);
XmlNode nodeCard =
doc.SelectSingleNode(String.Format("/tvserver/servers/server/cards/card[@IdCard={0}]", idCard));
Card dbCard = layer.GetCardByDevicePath(nodeCard.Attributes["DevicePath"].Value);
if (dbCard != null)
{
layer.MapChannelToCard(dbCard, dbChannel, false);
}
}
foreach (XmlNode nodeTune in tuningList)
{
int bandwidth = Int32.Parse(nodeTune.Attributes["Bandwidth"].Value);
int channelNumber = Int32.Parse(nodeTune.Attributes["ChannelNumber"].Value);
int channelType = Int32.Parse(nodeTune.Attributes["ChannelType"].Value);
int countryId = Int32.Parse(nodeTune.Attributes["CountryId"].Value);
int diseqc = Int32.Parse(nodeTune.Attributes["Diseqc"].Value);
bool fta = (nodeTune.Attributes["FreeToAir"].Value == "True");
int frequency = Int32.Parse(nodeTune.Attributes["Frequency"].Value);
int majorChannel = Int32.Parse(nodeTune.Attributes["MajorChannel"].Value);
int minorChannel = Int32.Parse(nodeTune.Attributes["MinorChannel"].Value);
int modulation = Int32.Parse(nodeTune.Attributes["Modulation"].Value);
string name = nodeTune.Attributes["Name"].Value;
int networkId = Int32.Parse(nodeTune.Attributes["NetworkId"].Value);
int pmtPid = Int32.Parse(nodeTune.Attributes["PmtPid"].Value);
int polarisation = Int32.Parse(nodeTune.Attributes["Polarisation"].Value);
string provider = GetNodeAttribute(nodeTune, "Provider", "");
int serviceId = Int32.Parse(nodeTune.Attributes["ServiceId"].Value);
int switchingFrequency = Int32.Parse(nodeTune.Attributes["SwitchingFrequency"].Value);
int symbolrate = Int32.Parse(nodeTune.Attributes["Symbolrate"].Value);
int transportId = Int32.Parse(nodeTune.Attributes["TransportId"].Value);
int tuningSource = Int32.Parse(GetNodeAttribute(nodeTune, "TuningSource", "0"));
int videoSource = Int32.Parse(GetNodeAttribute(nodeTune, "VideoSource", "0"));
int audioSource = Int32.Parse(GetNodeAttribute(nodeTune, "AudioSource", "0"));
bool isVCRSignal = (GetNodeAttribute(nodeChannel, "IsVCRSignal", "False") == "True");
int SatIndex = Int32.Parse(GetNodeAttribute(nodeTune, "SatIndex", "-1"));
int InnerFecRate = Int32.Parse(GetNodeAttribute(nodeTune, "InnerFecRate", "-1"));
int band = Int32.Parse(GetNodeAttribute(nodeTune, "Band", "0"));
int pilot = Int32.Parse(GetNodeAttribute(nodeTune, "Pilot", "-1"));
int rollOff = Int32.Parse(GetNodeAttribute(nodeTune, "RollOff", "-1"));
string url = GetNodeAttribute(nodeTune, "Url", "");
int bitrate = Int32.Parse(GetNodeAttribute(nodeTune, "Bitrate", "0"));
switch (channelType)
{
case 0: //AnalogChannel
AnalogChannel analogChannel = new AnalogChannel();
analogChannel.ChannelNumber = channelNumber;
analogChannel.Country = collection.Countries[countryId];
analogChannel.Frequency = frequency;
analogChannel.IsRadio = isRadio;
analogChannel.IsTv = isTv;
analogChannel.Name = name;
analogChannel.TunerSource = (TunerInputType)tuningSource;
analogChannel.AudioSource = (AnalogChannel.AudioInputType)audioSource;
analogChannel.VideoSource = (AnalogChannel.VideoInputType)videoSource;
analogChannel.IsVCRSignal = isVCRSignal;
layer.AddTuningDetails(dbChannel, analogChannel);
Log.Info("TvChannels: Added tuning details for analog channel: {0} number: {1}", name, channelNumber);
break;
case 1: //ATSCChannel
ATSCChannel atscChannel = new ATSCChannel();
atscChannel.MajorChannel = majorChannel;
atscChannel.MinorChannel = minorChannel;
atscChannel.PhysicalChannel = channelNumber;
atscChannel.FreeToAir = fta;
atscChannel.Frequency = frequency;
atscChannel.IsRadio = isRadio;
atscChannel.IsTv = isTv;
atscChannel.Name = name;
atscChannel.NetworkId = networkId;
atscChannel.PmtPid = pmtPid;
atscChannel.Provider = provider;
atscChannel.ServiceId = serviceId;
atscChannel.TransportId = transportId;
atscChannel.ModulationType = (ModulationType)modulation;
layer.AddTuningDetails(dbChannel, atscChannel);
Log.Info("TvChannels: Added tuning details for ATSC channel: {0} number: {1} provider: {2}", name,
channelNumber, provider);
break;
case 2: //DVBCChannel
DVBCChannel dvbcChannel = new DVBCChannel();
dvbcChannel.ModulationType = (ModulationType)modulation;
dvbcChannel.FreeToAir = fta;
dvbcChannel.Frequency = frequency;
dvbcChannel.IsRadio = isRadio;
dvbcChannel.IsTv = isTv;
dvbcChannel.Name = name;
dvbcChannel.NetworkId = networkId;
dvbcChannel.PmtPid = pmtPid;
dvbcChannel.Provider = provider;
dvbcChannel.ServiceId = serviceId;
dvbcChannel.SymbolRate = symbolrate;
dvbcChannel.TransportId = transportId;
dvbcChannel.LogicalChannelNumber = channelNumber;
layer.AddTuningDetails(dbChannel, dvbcChannel);
Log.Info("TvChannels: Added tuning details for DVB-C channel: {0} provider: {1}", name, provider);
break;
case 3: //DVBSChannel
DVBSChannel dvbsChannel = new DVBSChannel();
dvbsChannel.DisEqc = (DisEqcType)diseqc;
dvbsChannel.Polarisation = (Polarisation)polarisation;
dvbsChannel.SwitchingFrequency = switchingFrequency;
dvbsChannel.FreeToAir = fta;
dvbsChannel.Frequency = frequency;
dvbsChannel.IsRadio = isRadio;
dvbsChannel.IsTv = isTv;
dvbsChannel.Name = name;
dvbsChannel.NetworkId = networkId;
dvbsChannel.PmtPid = pmtPid;
dvbsChannel.Provider = provider;
dvbsChannel.ServiceId = serviceId;
dvbsChannel.SymbolRate = symbolrate;
dvbsChannel.TransportId = transportId;
dvbsChannel.SatelliteIndex = SatIndex;
dvbsChannel.ModulationType = (ModulationType)modulation;
dvbsChannel.InnerFecRate = (BinaryConvolutionCodeRate)InnerFecRate;
dvbsChannel.BandType = (BandType)band;
dvbsChannel.Pilot = (Pilot)pilot;
dvbsChannel.Rolloff = (RollOff)rollOff;
dvbsChannel.LogicalChannelNumber = channelNumber;
layer.AddTuningDetails(dbChannel, dvbsChannel);
Log.Info("TvChannels: Added tuning details for DVB-S channel: {0} provider: {1}", name, provider);
break;
case 4: //DVBTChannel
DVBTChannel dvbtChannel = new DVBTChannel();
dvbtChannel.BandWidth = bandwidth;
dvbtChannel.FreeToAir = fta;
dvbtChannel.Frequency = frequency;
dvbtChannel.IsRadio = isRadio;
dvbtChannel.IsTv = isTv;
dvbtChannel.Name = name;
dvbtChannel.NetworkId = networkId;
dvbtChannel.PmtPid = pmtPid;
dvbtChannel.Provider = provider;
dvbtChannel.ServiceId = serviceId;
dvbtChannel.TransportId = transportId;
dvbtChannel.LogicalChannelNumber = channelNumber;
layer.AddTuningDetails(dbChannel, dvbtChannel);
Log.Info("TvChannels: Added tuning details for DVB-T channel: {0} provider: {1}", name, provider);
break;
case 5: //Webstream
layer.AddWebStreamTuningDetails(dbChannel, url, bitrate);
break;
case 7: //DVBIPChannel
DVBIPChannel dvbipChannel = new DVBIPChannel();
dvbipChannel.FreeToAir = fta;
dvbipChannel.Frequency = frequency;
dvbipChannel.IsRadio = isRadio;
dvbipChannel.IsTv = isTv;
dvbipChannel.LogicalChannelNumber = channelNumber;
dvbipChannel.Name = name;
dvbipChannel.NetworkId = networkId;
dvbipChannel.PmtPid = pmtPid;
dvbipChannel.Provider = provider;
dvbipChannel.ServiceId = serviceId;
dvbipChannel.TransportId = transportId;
dvbipChannel.Url = url;
layer.AddTuningDetails(dbChannel, dvbipChannel);
Log.Info("TvChannels: Added tuning details for DVB-IP channel: {0} provider: {1}", name, provider);
break;
}
}
}
catch (Exception exc)
{
Log.Error("TvChannels: Failed to add channel - {0}", exc.Message);
}
}
}
if (tvChannelGroupList != null && importtvgroups)
{
// Import tv channel groups
foreach (XmlNode nodeChannelGroup in tvChannelGroupList)
{
try
{
tvChannelGroupCount++;
string groupName = nodeChannelGroup.Attributes["GroupName"].Value;
int groupSortOrder = Int32.Parse(nodeChannelGroup.Attributes["SortOrder"].Value);
ChannelGroup group = null;
if (groupName == TvConstants.TvGroupNames.AllChannels)
{
group = layer.GetGroupByName(groupName) ??
new ChannelGroup(groupName, groupSortOrder);
}
else
{
group = layer.GetGroupByName(groupName, groupSortOrder) ??
new ChannelGroup(groupName, groupSortOrder);
}
group.Persist();
XmlNodeList mappingList = nodeChannelGroup.SelectNodes("mappings/map");
foreach (XmlNode nodeMap in mappingList)
{
IList <Channel> channels = layer.GetChannelsByName(nodeMap.Attributes["ChannelName"].Value);
int sortOrder = Int32.Parse(GetNodeAttribute(nodeMap, "SortOrder", "9999"));
if (channels != null && channels.Count > 0)
{
Channel channel = channels[0];
if (!channel.GroupNames.Contains(group.GroupName))
{
GroupMap map = new GroupMap(group.IdGroup, channel.IdChannel, sortOrder);
map.Persist();
}
else
{
foreach (GroupMap map in channel.ReferringGroupMap())
{
if (map.IdGroup == group.IdGroup)
{
map.SortOrder = sortOrder;
map.Persist();
break;
}
}
}
}
}
}
catch (Exception exg)
{
Log.Error("TvChannels: Failed to add group - {0}", exg.Message);
}
}
}
if (radioChannelGroupList != null && importradiogroups)
{
// Import radio channel groups
foreach (XmlNode nodeChannelGroup in radioChannelGroupList)
{
try
{
radioChannelGroupCount++;
string groupName = nodeChannelGroup.Attributes["GroupName"].Value;
int groupSortOrder = Int32.Parse(nodeChannelGroup.Attributes["SortOrder"].Value);
RadioChannelGroup group = layer.GetRadioChannelGroupByName(groupName) ??
new RadioChannelGroup(groupName, groupSortOrder);
group.Persist();
XmlNodeList mappingList = nodeChannelGroup.SelectNodes("mappings/map");
foreach (XmlNode nodeMap in mappingList)
{
IList <Channel> channels = layer.GetChannelsByName(nodeMap.Attributes["ChannelName"].Value);
int sortOrder = Int32.Parse(GetNodeAttribute(nodeMap, "SortOrder", "9999"));
if (channels != null && channels.Count > 0)
{
Channel channel = channels[0];
if (!channel.GroupNames.Contains(group.GroupName))
{
RadioGroupMap map = new RadioGroupMap(group.IdGroup, channel.IdChannel, sortOrder);
map.Persist();
}
else
{
foreach (RadioGroupMap map in channel.ReferringRadioGroupMap())
{
if (map.IdGroup == group.IdGroup)
{
map.SortOrder = sortOrder;
map.Persist();
break;
}
}
}
}
}
}
catch (Exception exg)
{
Log.Error("Radio Channels: Failed to add group - {0}", exg.Message);
}
}
}
if (scheduleList != null && importschedules)
{
// Import schedules
foreach (XmlNode nodeSchedule in scheduleList)
{
try
{
int idChannel = -1;
string programName = nodeSchedule.Attributes["ProgramName"].Value;
string channel = nodeSchedule.Attributes["ChannelName"].Value;
if (!string.IsNullOrEmpty(channel))
{
IList <Channel> channels = layer.GetChannelsByName(channel);
if (channels != null && channels.Count > 0)
{
idChannel = channels[0].IdChannel;
}
}
DateTime startTime = DateTime.ParseExact(nodeSchedule.Attributes["StartTime"].Value, "yyyy-M-d H:m:s",
CultureInfo.InvariantCulture);
DateTime endTime = DateTime.ParseExact(nodeSchedule.Attributes["EndTime"].Value, "yyyy-M-d H:m:s",
CultureInfo.InvariantCulture);
int scheduleType = Int32.Parse(nodeSchedule.Attributes["ScheduleType"].Value);
Schedule schedule = layer.AddSchedule(idChannel, programName, startTime, endTime, scheduleType);
schedule.ScheduleType = scheduleType;
schedule.KeepDate = DateTime.ParseExact(nodeSchedule.Attributes["KeepDate"].Value, "yyyy-M-d H:m:s",
CultureInfo.InvariantCulture);
schedule.PreRecordInterval = Int32.Parse(nodeSchedule.Attributes["PreRecordInterval"].Value);
schedule.PostRecordInterval = Int32.Parse(nodeSchedule.Attributes["PostRecordInterval"].Value);
schedule.Priority = Int32.Parse(nodeSchedule.Attributes["Priority"].Value);
schedule.Quality = Int32.Parse(nodeSchedule.Attributes["Quality"].Value);
schedule.Directory = nodeSchedule.Attributes["Directory"].Value;
schedule.KeepMethod = Int32.Parse(nodeSchedule.Attributes["KeepMethod"].Value);
schedule.MaxAirings = Int32.Parse(nodeSchedule.Attributes["MaxAirings"].Value);
schedule.RecommendedCard = Int32.Parse(nodeSchedule.Attributes["RecommendedCard"].Value);
schedule.ScheduleType = Int32.Parse(nodeSchedule.Attributes["ScheduleType"].Value);
schedule.Series = (GetNodeAttribute(nodeSchedule, "Series", "False") == "True");
if (idChannel > -1)
{
schedule.Persist();
scheduleCount++;
Log.Info("TvChannels: Added schedule: {0} on channel: {1}", programName, channel);
}
else
{
Log.Info("TvChannels: Skipped schedule: {0} because the channel was unknown: {1}", programName, channel);
}
}
catch (Exception ex)
{
Log.Error("TvChannels: Failed to add schedule - {0}", ex.Message);
}
}
}
dlg.Close();
Log.Info(
"TvChannels: Imported {0} channels, {1} tv channel groups, {2} radio channel groups and {3} schedules",
channelCount, tvChannelGroupCount, radioChannelGroupCount, scheduleCount);
MessageBox.Show(
String.Format("Imported {0} channels, {1} tv channel groups, {2} radio channel groups and {3} schedules",
channelCount, tvChannelGroupCount, radioChannelGroupCount, scheduleCount));
}
catch (Exception ex)
{
MessageBox.Show(this, "Error while importing:\n\n" + ex + " " + ex.StackTrace);
}
finally
{
dlg.Close();
OnSectionActivated();
}
}
/// <summary>
/// This method will try to start the epg grabber for the channel and tuning details specified
/// Epg grabbing can only be started if there is a card idle which can receive the channel specified
/// </summary>
/// <param name="channel">channel to grab/param>
/// <param name="tuning">tuning information</param>
/// <param name="card">card to use for grabbing</param>
/// <returns>true if grabbing has started else false</returns>
private bool GrabEpgForChannel(Channel channel, IChannel tuning, Card card)
{
if (channel == null)
{
Log.Error("Epg: invalid channel");
return(false);
}
if (tuning == null)
{
Log.Error("Epg: invalid tuning");
return(false);
}
if (card == null)
{
Log.Error("Epg: invalid card");
return(false);
}
if (_tvController == null)
{
Log.Error("Epg: invalid tvcontroller");
return(false);
}
if (_user == null)
{
Log.Error("Epg: invalid user");
return(false);
}
//remove following check to enable multi-card epg grabbing (still beta)
if (_tvController.AllCardsIdle == false)
{
Log.Epg("Epg: card:{0} cards are not idle", card.IdCard);
return(false);
}
TvResult result;
//handle ATSC
ATSCChannel atscChannel = tuning as ATSCChannel;
if (atscChannel != null)
{
if (_tvController.Type(card.IdCard) == CardType.Atsc)
{
if (IsCardIdle(card.IdCard) == false)
{
Log.Epg("Epg: card:{0} atsc card is not idle", card.IdCard);
return(false); //card is busy
}
try
{
IUser cardUser;
if (_tvController.IsCardInUse(card.IdCard, out cardUser) == false)
{
_user.CardId = card.IdCard;
result = RemoteControl.Instance.Tune(ref _user, tuning, channel.IdChannel);
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 atsc epg grabbing", card.IdCard);
return(false);
}
_user.CardId = card.IdCard;
return(true);
}
_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;
}
return(false);
}
Log.Epg("Epg: card:{0} could not tune to atsc channel:{1}", card.IdCard, tuning.ToString());
return(false);
}
//handle DVBC
DVBCChannel dvbcChannel = tuning as DVBCChannel;
if (dvbcChannel != null)
{
if (_tvController.Type(card.IdCard) == CardType.DvbC)
{
if (IsCardIdle(card.IdCard) == false)
{
Log.Epg("Epg: card:{0} dvbc card is not idle", card.IdCard);
return(false); //card is busy
}
try
{
_user.CardId = card.IdCard;
result = RemoteControl.Instance.Tune(ref _user, tuning, channel.IdChannel);
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 dvbc epg grabbing", card.IdCard);
return(false);
}
_user.CardId = card.IdCard;
return(true);
}
_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;
}
//unreachable return false;
}
Log.Epg("Epg: card:{0} could not tune to dvbc channel:{1}", card.IdCard, tuning.ToString());
return(false);
}
//handle DVBS
DVBSChannel dvbsChannel = tuning as DVBSChannel;
if (dvbsChannel != null)
{
if (_tvController.Type(card.IdCard) == CardType.DvbS)
{
if (IsCardIdle(card.IdCard) == false)
{
Log.Epg("Epg: card:{0} dvbs card is not idle", card.IdCard);
return(false); //card is busy
}
try
{
_user.CardId = card.IdCard;
result = RemoteControl.Instance.Tune(ref _user, tuning, channel.IdChannel);
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 dvbs epg grabbing", card.IdCard);
return(false);
}
_user.CardId = card.IdCard;
return(true);
}
_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;
}
//unreachable return false;
}
Log.Epg("Epg: card:{0} could not tune to dvbs channel:{1}", card.IdCard, tuning.ToString());
return(false);
}
//handle DVBT
DVBTChannel dvbtChannel = tuning as DVBTChannel;
if (dvbtChannel != null)
{
if (_tvController.Type(card.IdCard) == CardType.DvbT)
{
if (IsCardIdle(card.IdCard) == false)
{
Log.Epg("Epg: card:{0} dvbt card is not idle", card.IdCard);
return(false); //card is busy
}
try
{
_user.CardId = card.IdCard;
result = RemoteControl.Instance.Tune(ref _user, tuning, channel.IdChannel);
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);
}
_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;
}
//unreachable return false;
}
Log.Epg("Epg: card:{0} could not tune to dvbt channel:{1}", card.IdCard, tuning.ToString());
return(false);
}
//handle DVBIP
DVBIPChannel dvbipChannel = tuning as DVBIPChannel;
if (dvbipChannel != null)
{
if (_tvController.Type(card.IdCard) == CardType.DvbIP)
{
if (IsCardIdle(card.IdCard) == false)
{
Log.Epg("Epg: card:{0} dvbip card is not idle", card.IdCard);
return(false); //card is busy
}
try
{
_user.CardId = card.IdCard;
result = RemoteControl.Instance.Tune(ref _user, tuning, channel.IdChannel);
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 dvbip grabbing", card.IdCard);
return(false);
}
_user.CardId = card.IdCard;
return(true);
}
else
{
_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 ex;
}
//unreachable return false;
}
else
{
Log.Epg("Epg: card:{0} could not tune to dvbip channel:{1}", card.IdCard, tuning.ToString());
}
return(false);
}
Log.Epg("Epg: card:{0} could not tune to channel:{1}", card.IdCard, tuning.ToString());
return(false);
}
