private void LoadGroups()
{
ChannelType channelType = this.ChannelType;
if (!_channelGroups.ContainsKey(channelType))
{
try
{
List<ChannelGroup> channelGroups = new List<ChannelGroup>(Proxies.SchedulerService.GetAllChannelGroups(channelType, true).Result);
ChannelGroup allChannelsGroup = new ChannelGroup()
{
ChannelGroupId = channelType == ChannelType.Television ? ChannelGroup.AllTvChannelsGroupId : ChannelGroup.AllRadioChannelsGroupId,
ChannelType = channelType,
GroupName = "All Channels",
VisibleInGuide = true
};
if (this.ShowAllChannelsOnTop)
{
channelGroups.Insert(0, allChannelsGroup);
}
else
{
channelGroups.Add(allChannelsGroup);
}
_channelGroups[channelType] = channelGroups;
}
catch (Exception ex)
{
MessageBox.Show(this, ex.Message, null, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
_channelGroupsComboBox.DataSource = _channelGroups[channelType];
_channelGroupsComboBox.DisplayMember = "GroupName";
_channelGroupsComboBox.ValueMember = "ChannelGroupId";
}
private void ImportChannel(GuideServiceAgent tvGuideAgent, SchedulerServiceAgent tvSchedulerAgent, ImportChannelsContext.ImportChannel importChannel)
{
Guid channelId;
Channels.ChannelLink channelLink = Channels.ChannelLinks.GetChannelLinkForMediaPortalChannel(importChannel.Channel);
if (channelLink == null)
{
Channel channel = new Channel();
channel.ChannelType = this.Context.ChannelType;
channel.VisibleInGuide = true;
channel.DisplayName = importChannel.Channel.DisplayName;
channel.LogicalChannelNumber = importChannel.LogicalChannelNumber;
channel.Sequence = importChannel.Channel.SortOrder;
channel = tvSchedulerAgent.SaveChannel(channel);
Channels.ChannelLinks.SetLinkedMediaPortalChannel(channel, importChannel.Channel);
channelId = channel.ChannelId;
}
else
{
channelId = channelLink.ChannelId;
}
if (!_importChannelsOnlyRadioButton.Checked)
{
string groupName;
int groupSequence;
if (_importChannelsAndGroupsRadioButton.Checked)
{
groupName = importChannel.GroupName;
groupSequence = importChannel.GroupSequence;
}
else
{
groupName = _groupNameTextBox.Text.Trim();
groupSequence = 0;
}
if (!String.IsNullOrEmpty(importChannel.GroupName))
{
if (!_channelGroupsByName.ContainsKey(groupName))
{
ChannelGroup channelGroup = new ChannelGroup();
channelGroup.GroupName = groupName;
channelGroup.VisibleInGuide = true;
channelGroup.ChannelType = this.Context.ChannelType;
channelGroup.Sequence = groupSequence;
channelGroup = tvSchedulerAgent.SaveChannelGroup(channelGroup);
_channelGroupsByName[groupName] = channelGroup;
_channelMembersByName[groupName] = new List<Guid>();
}
if (!_channelMembersByName.ContainsKey(groupName))
{
_channelMembersByName[groupName] = new List<Guid>(
tvSchedulerAgent.GetChannelGroupMembers(_channelGroupsByName[groupName].ChannelGroupId));
}
_channelMembersByName[groupName].Add(channelId);
}
}
}
private void CreateNewChannelGroup()
{
VirtualKeyboard keyboard = (VirtualKeyboard)GUIWindowManager.GetWindow((int)GUIWindow.Window.WINDOW_VIRTUAL_KEYBOARD);
if (keyboard != null)
{
keyboard.Reset();
keyboard.IsSearchKeyboard = false;
keyboard.Text = string.Empty;
keyboard.DoModal(GetID);
if (keyboard.IsConfirmed && keyboard.Text != string.Empty)
{
ChannelGroup group = new ChannelGroup()
{
Sequence = GetAllChannelGroups().Length,
ChannelType = _currentChannelType,
VisibleInGuide = true,
GroupName = keyboard.Text
};
SchedulerAgent.SaveChannelGroup(group);
}
}
}
/// <summary>
/// Save a modified or new channel group. A new channel group is recognized by a Guid.Empty ID.
/// </summary>
/// <param name="channelGroup">The channel group to save.</param>
/// <returns>The saved channel group.</returns>
public async Task<ChannelGroup> SaveChannelGroup(ChannelGroup channelGroup)
{
var request = NewRequest(HttpMethod.Post, "SaveChannelGroup");
request.AddBody(channelGroup);
return await ExecuteAsync<ChannelGroup>(request).ConfigureAwait(false);
}
/// <summary>
/// Set the current channelgroup.
/// </summary>
/// <param name="channelType">Type of channelgroup.</param>
/// <param name="currentGroup">Channelgroup to set as current.</param>
public void SetCurrentGroup(ChannelType channelType, ChannelGroup currentGroup)
{
_currentChannelGroup = currentGroup;
RefreshChannelsInGroup(channelType);
}
private void LoadGroupAndChannelSettings(Settings xmlreader, ChannelType channelType, string section)
{
string channelName = xmlreader.GetValueAsString(section, "channel", String.Empty);
string groupname = xmlreader.GetValueAsString(section, "group", Utility.GetLocalizedText(TextId.AllChannels));
foreach (ChannelGroup group in _navigatorChannels[channelType].Groups)
{
if (group.GroupName == groupname)
{
_navigatorChannels[channelType].PreviousChannelGroup = group;
_currentChannelGroup = group;
RefreshChannelsInGroup(channelType);
break;
}
}
_navigatorChannels[channelType].LastChannelGroup = _navigatorChannels[channelType].PreviousChannelGroup;
_navigatorChannels[channelType].PreviousChannel = null;
foreach (Channel channel in _navigatorChannels[channelType].Channels)
{
if (channel.DisplayName == channelName)
{
_navigatorChannels[channelType].PreviousChannel = channel;
break;
}
}
_navigatorChannels[channelType].LastChannel = _navigatorChannels[channelType].PreviousChannel;
}
private void _groupsTreeView_AfterSelect(object sender, TreeViewEventArgs e)
{
ChannelGroup group = GetCurrentGroup();
if (group != _activeGroup)
{
RefreshAvailableChannels(group);
_activeGroup = group;
}
if (group != null
&& !e.Node.IsExpanded)
{
e.Node.Expand();
}
EnableButtons();
}
/// <summary>
/// Checks if it is time to zap to a different channel. This is called during Process().
/// </summary>
public bool CheckChannelChange()
{
if (_reentrant)
{
return false;
}
try
{
_reentrant = true;
// Zapping to another group or channel?
if (_zapGroup != null || _zapChannel != null)
{
// Time to zap?
if (DateTime.Now >= _zapTime)
{
Log.Debug("ChannelNavigator: CheckChannelChange()_DateTime.Now >= _zapTime,_zapgroup = {0} , _zapchannel = {1}", _zapGroup.GroupName, _zapChannel.DisplayName);
// Zapping to another group?
if (_zapGroup != null && _zapGroup != _currentChannelGroup)
{
// Change current group (and possibly zap to the first channel of the group)
if (_currentChannelGroup != null)
{
_navigatorChannels[_currentChannelGroup.ChannelType].PreviousChannelGroup = _currentChannelGroup;
}
_currentChannelGroup = _zapGroup;
RefreshChannelsInGroup(_zapGroup.ChannelType);
if (_zapChannel == null
&& _navigatorChannels[_zapGroup.ChannelType].Channels.Count > 0)
{
_zapChannel = _navigatorChannels[_zapGroup.ChannelType].Channels[0];
}
}
// Zap to desired channel
Channel zappingTo = _zapChannel;
_zapChannel = null;
_zapGroup = null;
if (PluginMain.Navigator.CurrentChannel != null
&& PluginMain.Navigator.CurrentChannel.ChannelId == zappingTo.ChannelId
&& _liveStream != null && !_lastChannelChangeFailed)
{
Log.Debug("ChannelNavigator: CheckChannelChange()_CurrentChannel.ChannelId = zappingTo.ChannelId --> break off zapping");
zappingTo = null;
}
if (zappingTo != null)
{
if ((this.IsLiveStreamOn && _currentChannel != null
&& zappingTo.ChannelType != _currentChannel.ChannelType)
|| (g_Player.Playing && !this.IsLiveStreamOn))
{
//g_Player needs a comlete stop when the ChannelType changes
if (_liveStream != null)
{
g_Player.PauseGraph();
Thread.Sleep(100);
this.StopLiveStream();
}
g_Player.Stop(true);
Thread.Sleep(250);
}
Channel prevChannel = _currentChannel;
ChannelGroup prevGroup = _currentChannelGroup;
TuneLiveStream(zappingTo);
if (prevChannel != null)
{
_navigatorChannels[prevChannel.ChannelType].PreviousChannel = prevChannel;
_navigatorChannels[prevGroup.ChannelType].PreviousChannelGroup = prevGroup;
}
_navigatorChannels[zappingTo.ChannelType].LastChannel = _currentChannel;
_navigatorChannels[zappingTo.ChannelType].LastChannelGroup = _currentChannelGroup;
if (zappingTo.ChannelType == ChannelType.Radio)
{
RadioHome.SetMusicProperties(zappingTo.DisplayName, zappingTo.ChannelId);
}
}
_zapChannelNr = -1;
_reentrant = false;
return true;
}
}
}
catch (Exception ex)
{
Log.Error("ChannelNavigator: error CheckChannelChange() = {0}", ex.Message);
}
finally
{
_reentrant = false;
}
return false;
}
private void LoadChannelsForGroup(ChannelGroup group)
{
_channelsInGroupList.Clear();
_channelIdsInList.Clear();
if (group != null)
{
Channel[] channels = SchedulerAgent.GetChannelsInGroup(group.ChannelGroupId, false);
if (channels != null && channels.Length > 0)
{
foreach (Channel channel in channels)
{
_channelIdsInList.Add(channel.ChannelId);
GUIListItem item = new GUIListItem();
item.Label = channel.DisplayName;
item.TVTag = channel;
string logo = Utility.GetLogoImage(channel, SchedulerAgent);
if (!string.IsNullOrEmpty(logo))
{
item.IconImage = logo;
}
if (!channel.VisibleInGuide)
{
item.IsPlayed = true;
}
_channelsInGroupList.Add(item);
}
}
}
}
private void _createNewButton_Click(object sender, EventArgs e)
{
ChannelGroup channelGroup = new ChannelGroup();
channelGroup.ChannelType = this.ChannelType;
channelGroup.GroupName = "-Unnamed-";
channelGroup.VisibleInGuide = true;
TreeNode newNode = _groupsTreeView.Nodes.Add(channelGroup.GroupName);
newNode.Checked = channelGroup.VisibleInGuide;
newNode.Tag = channelGroup;
_groupsTreeView.SelectedNode = newNode;
newNode.BeginEdit();
}
private void LoadChannelGroups(ChannelGroup groupToSelect)
{
_channelGroupsList.Clear();
ChannelGroup[] groups = GetAllChannelGroups();
if (groups != null && groups.Length > 0)
{
foreach (ChannelGroup group in groups)
{
GUIListItem item = new GUIListItem();
item.Label = group.GroupName;
item.TVTag = group;
if (!group.VisibleInGuide)
{
item.IsPlayed = true;
}
if (group.ChannelGroupId == groupToSelect.ChannelGroupId)
{
item.IsRemote = true;
}
_channelGroupsList.Add(item);
}
}
}
private void LoadAll(ChannelGroup group)
{
if (group == null)
{
if (GetAllChannelGroups() != null && GetAllChannelGroups().Length > 0)
{
group = GetAllChannelGroups()[0];
}
LoadChannelGroups(group);
}
_currentGroup = group;
LoadChannelsForGroup(group);
LoadAllChannels();
switch(_currentChannelType)
{
case ChannelType.Television:
_channelTypeButton.Label = "Channeltype: television";
break;
case ChannelType.Radio:
_channelTypeButton.Label = "Channeltye: radio";
break;
}
}
private void DeleteChannelGroup(ChannelGroup group)
{
if (group != null)
{
SchedulerAgent.DeleteChannelGroup(group.ChannelGroupId, true, true);
}
}
/// <summary>
/// Fill up the list with groups
/// </summary>
private void FillGroupList()
{
PluginMain.Navigator.RefreshChannelGroups(this.ChannelType);
_channelGroupList = PluginMain.Navigator.GetGroups(this.ChannelType);
_currentGroup = PluginMain.Navigator.CurrentGroup;
// empty list of groups currently in the spin control
_spinGroup.Reset();
// start to fill them up again
bool groupFound = false;
for (int index = 0; index < _channelGroupList.Count; index++)
{
ChannelGroup group = _channelGroupList[index];
_spinGroup.AddLabel(group.GroupName, index);
// set selected
if (_currentGroup != null
&& group.ChannelGroupId == _currentGroup.ChannelGroupId)
{
_spinGroup.Value = index;
groupFound = true;
}
}
if (!groupFound)
{
_currentGroup = (_channelGroupList.Count > 0) ? _channelGroupList[0] : null;
}
if (_channelGroupList.Count < 2)
{
_spinGroup.Visible = false;
}
}
private void RefreshAvailableChannels(ChannelGroup group)
{
_availableChannels.Clear();
if (group != null)
{
foreach (Channel channel in _allChannels)
{
if (!GroupContainsChannel(group, channel.ChannelId))
{
_availableChannels.Add(channel);
}
}
}
_channelsBindingSource.ResetBindings(false);
}
private void OnGroupChanged()
{
if (_spinGroup.Visible)
{
GUIWaitCursor.Show();
_currentGroup = _channelGroupList[_spinGroup.Value];
string guiPropertyPrefix = this.ChannelType == ChannelType.Television ? "#TV" : "#Radio";
GUIPropertyManager.SetProperty(guiPropertyPrefix + ".Guide.Group", _spinGroup.GetLabel());
FillChannelList();
GUIWaitCursor.Hide();
}
}
private bool GroupContainsChannel(ChannelGroup group, Guid channelId)
{
TreeNode groupNode = GetNodeForGroup(group);
if (groupNode != null)
{
EnsureGroupChannels(groupNode);
foreach (TreeNode childNode in groupNode.Nodes)
{
Channel channel = childNode.Tag as Channel;
if (channel.ChannelId == channelId)
{
return true;
}
}
}
return false;
}
public Channel GetChannelByNumber(ChannelType channelType, int channelNr, out ChannelGroup channelGroup)
{
channelGroup = _currentChannelGroup;
if (_navigatorChannels[channelType].ChannelsByNumber.ContainsKey(channelNr))
{
channelGroup = _navigatorChannels[channelType].GroupsByChannelNumber[channelNr];
return _navigatorChannels[channelType].ChannelsByNumber[channelNr];
}
Channel channel = null;
if (_navigatorChannels[channelType].Channels != null)
{
channel = FindChannelByNumber(_navigatorChannels[channelType].Channels, channelNr);
if (channel == null)
{
try
{
using (SchedulerServiceAgent tvSchedulerAgent = new SchedulerServiceAgent())
{
foreach (ChannelGroup group in _navigatorChannels[channelType].Groups)
{
if (group != _currentChannelGroup)
{
channel = FindChannelInGroupByNumber(tvSchedulerAgent, group.ChannelGroupId, channelNr);
if (channel != null)
{
channelGroup = group;
break;
}
}
}
}
}
catch (Exception ex)
{
Log.Error("ChannelNavigator: Error in GetChannelByNumber - {0}", ex.Message);
}
}
}
_navigatorChannels[channelType].ChannelsByNumber[channelNr] = channel;
_navigatorChannels[channelType].GroupsByChannelNumber[channelNr] = channelGroup;
return channel;
}
private TreeNode GetNodeForGroup(ChannelGroup group)
{
foreach (TreeNode node in _groupsTreeView.Nodes)
{
if (node.Tag == group)
{
return node;
}
}
return null;
}
/// <summary>
/// Changes the current channel and channelgroup after a specified delay.
/// </summary>
/// <param name="channelGroup">The channelgroup to switch to.</param>
/// <param name="channel">The channel to switch to</param>
/// <param name="useZapDelay">If true, the configured zap delay is used. Otherwise it zaps immediately.</param>
public void ZapToChannel(ChannelGroup channelGroup, Channel channel, bool useZapDelay)
{
Log.Debug("ChannelNavigator.ZapToChannel {0} - zapdelay {1}", channel.DisplayName, useZapDelay);
_zapGroup = channelGroup ?? _currentChannelGroup;
_zapChannel = channel;
if (useZapDelay)
{
_zapTime = DateTime.Now.AddMilliseconds(_zapDelayMs);
}
else
{
_zapTime = DateTime.Now;
}
}
private void LoadGroups()
{
ChannelType channelType = this.ChannelType;
if (!_channelGroups.ContainsKey(channelType))
{
try
{
using (SchedulerServiceAgent tvSchedulerAgent = new SchedulerServiceAgent())
{
List<ChannelGroup> channelGroups = new List<ChannelGroup>(tvSchedulerAgent.GetAllChannelGroups(channelType, true));
ChannelGroup allChannelsGroup = new ChannelGroup(
channelType == ChannelType.Television ? ChannelGroup.AllTvChannelsGroupId : ChannelGroup.AllRadioChannelsGroupId,
(int)channelType, "All Channels", true, 0, 0);
if (this.ShowAllChannelsOnTop)
{
channelGroups.Insert(0, allChannelsGroup);
}
else
{
channelGroups.Add(allChannelsGroup);
}
_channelGroups[channelType] = channelGroups;
}
}
catch (Exception ex)
{
MessageBox.Show(this, ex.Message, null, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
_channelGroupsComboBox.DataSource = _channelGroups[channelType];
_channelGroupsComboBox.DisplayMember = ChannelGroup.FieldName.GroupName;
_channelGroupsComboBox.ValueMember = ChannelGroup.FieldName.ChannelGroupId;
}
private void RefreshGroups(ChannelType channelType)
{
try
{
using (SchedulerServiceAgent tvSchedulerAgent = new SchedulerServiceAgent())
{
List<ChannelGroup> groups = new List<ChannelGroup>(tvSchedulerAgent.GetAllChannelGroups(channelType, true));
if (_currentChannelGroup != null
&& _currentChannelGroup.ChannelGroupId != ChannelGroup.AllTvChannelsGroupId
&& _currentChannelGroup.ChannelGroupId != ChannelGroup.AllRadioChannelsGroupId)
{
bool currentFound = false;
foreach (ChannelGroup group in groups)
{
if (group.ChannelGroupId == _currentChannelGroup.ChannelGroupId)
{
currentFound = true;
break;
}
}
if (!currentFound)
{
_currentChannelGroup = null;
}
}
bool hideAllChannelsGroup = false;
using (Settings xmlreader = new MPSettings())
{
hideAllChannelsGroup = xmlreader.GetValueAsBool("mytv", "hideAllChannelsGroup", false);
}
if (!hideAllChannelsGroup || groups.Count == 0)
{
groups.Add(new ChannelGroup(
channelType == ChannelType.Television ? ChannelGroup.AllTvChannelsGroupId : ChannelGroup.AllRadioChannelsGroupId,
(int)channelType, Utility.GetLocalizedText(TextId.AllChannels), true, int.MaxValue, 0));
}
_navigatorChannels[channelType].Groups = groups;
if (_currentChannelGroup == null && _navigatorChannels[channelType].Groups.Count > 0)
{
_currentChannelGroup = _navigatorChannels[channelType].Groups[0];
RefreshChannelsInGroup(tvSchedulerAgent, channelType);
}
}
}
catch (Exception ex)
{
Log.Error("ChannelNavigator: Error in RefreshChannelGroups - {0}", ex.Message);
}
}
private void DeleteChannelGroup(ChannelGroup group)
{
if (group != null)
{
Proxies.SchedulerService.DeleteChannelGroup(group.ChannelGroupId, true, true).Wait();
}
}
