C# DataContracts.Channel类代码示例

 /// <summary>
 /// Create a new instance of LiveStream.
 /// </summary>
 /// <param name="channel">The channel being streamed.</param>
 /// <param name="rtspUrl">The rtsp URL to the stream.</param>
 /// <param name="streamStartedTimeUtc">The date and time the stream was first started.</param>
 public LiveStream(Channel channel, string rtspUrl, DateTime streamStartedTimeUtc)
 {
     this.Channel = channel;
     this.RtspUrl = rtspUrl;
     this.StreamStartedTime = streamStartedTimeUtc.ToLocalTime();
     this.StreamLastAliveTimeUtc = streamStartedTimeUtc;
 }

 public ProgramEventArgs(GuideProgramSummary guideProgram, Channel channel, Point location)
 {
     this.GuideProgram = guideProgram;
     this.Channel = channel;
     this.Location = location;
     this.UpcomingProgramId = guideProgram.GetUniqueUpcomingProgramId(channel.ChannelId);
 }

 public static void AppendProgramDetails(StringBuilder reply, Channel channel, IProgramSummary program)
 {
     reply.AppendFormat("[{0}] {1} {2}-{3} {4}",
         channel.DisplayName,
         GetShortDayDateString(program.StartTime),
         program.StartTime.ToShortTimeString().PadLeft(5, '0'),
         program.StopTime.ToShortTimeString().PadLeft(5, '0'),
         program.CreateProgramTitle());
 }

 public IProgramSummary GetProgramAt(int number, out Channel channel, out Guid? upcomingProgramId)
 {
     if (--number >= 0)
     {
         if (_guidePrograms != null
             && number < _guidePrograms.Count)
         {
             channel = this.Channel;
             upcomingProgramId = _guidePrograms[number].GetUniqueUpcomingProgramId(channel.ChannelId);
             return _guidePrograms[number];
         }
         else if (_searchedPrograms != null
             && number < _searchedPrograms.Count)
         {
             channel = _searchedPrograms[number].Channel;
             upcomingProgramId = _searchedPrograms[number].GetUniqueUpcomingProgramId();
             return _searchedPrograms[number];
         }
         else if (_upcomingPrograms != null
             && number < _upcomingPrograms.Count)
         {
             channel = _upcomingPrograms[number].Channel;
             upcomingProgramId = _upcomingPrograms[number].UpcomingProgramId;
             return _upcomingPrograms[number];
         }
         else if (_upcomingRecordings != null
             && number < _upcomingRecordings.Count)
         {
             channel = _upcomingRecordings[number].Program.Channel;
             upcomingProgramId = _upcomingRecordings[number].Program.UpcomingProgramId;
             return _upcomingRecordings[number];
         }
     }
     channel = null;
     upcomingProgramId = null;
     return null;
 }

 public Programs(Channel channel, IList<GuideProgramSummary> guidePrograms)
 {
     _channel = channel;
     _guidePrograms = guidePrograms;
 }

 private void GetLinkedMessageAndColor(Channel channel, out string message, out Color rowColor)
 {
     bool isAutoLinked;
     bool duplicateChannelsFound;
     LinkedMediaPortalChannel linkedChannel =
        ChannelLinks.GetLinkedMediaPortalChannel(channel, out isAutoLinked, out duplicateChannelsFound);
     if (duplicateChannelsFound)
     {
         message = "More than one channel found, change name or link manually";
         rowColor = Color.Red;
     }
     else if (linkedChannel == null)
     {
         message = "Channel not linked, change name or link manually";
         rowColor = Color.Red;
     }
     else if (isAutoLinked)
     {
         message = "Linked (auto)";
         rowColor = Color.Black;
     }
     else
     {
         message = "Linked to " + linkedChannel.DisplayName;
         rowColor = Color.DarkGreen;
     }
 }

 private void MergeExtraPrograms(Channel channel, ChannelPrograms channelPrograms, DateTime fromDateTime, DateTime toDateTime)
 {
     if (toDateTime > fromDateTime)
     {
         var guidePrograms = Proxies.GuideService.GetChannelProgramsBetween(channel.GuideChannelId.Value, fromDateTime, toDateTime).Result;
         foreach (GuideProgramSummary guideProgram in guidePrograms)
         {
             channelPrograms.InsertProgram(guideProgram);
         }
     }
 }

        private string GetChannelProgramIcon(Channel channel, Guid guideProgramId, out GuideUpcomingProgram guideUpcomingProgram)
        {
            Guid upcomingProgramId = UpcomingProgram.GetUniqueUpcomingProgramId(guideProgramId, channel.ChannelId);

            guideUpcomingProgram = null;
            string recordIconImage = null;
            GuideUpcomingProgram upcoming = null;
            ScheduleType type = ScheduleType.Recording;
            if (_model.UpcomingRecordingsById.ContainsKey(upcomingProgramId))
            {
                type = ScheduleType.Recording;
                upcoming = _model.UpcomingRecordingsById[upcomingProgramId];
                guideUpcomingProgram = upcoming;
            }
            else if (_model.UpcomingAlertsById.ContainsKey(upcomingProgramId))
            {
                type = ScheduleType.Alert;
                upcoming = _model.UpcomingAlertsById[upcomingProgramId];
                guideUpcomingProgram = upcoming;
            }
            else if (_model.UpcomingSuggestionsById.ContainsKey(upcomingProgramId))
            {
                type = ScheduleType.Suggestion;
                upcoming = _model.UpcomingSuggestionsById[upcomingProgramId];
            }
            if (upcoming != null
                && upcoming.ChannelId == channel.ChannelId)
            {
                recordIconImage = Utility.GetIconImageFileName(type, upcoming);
            }
            return recordIconImage;
        }

        /// <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;
            }
        }

        /// <summary>
        /// Use this when you are sure that the livestream playback was stopped some time ago.
        /// </summary>
        public void StopLiveStream()
        {
            Log.Debug("ChannelNavigator: StopLiveStream()");
            if (_liveStream != null)
            {
                this.ControlAgent.StopLiveStream(_liveStream);
                _liveStream = null;

                if (_currentChannel != null)
                    _navigatorChannels[_currentChannel.ChannelType].PreviousChannel = _currentChannel;
            }

            if (!_doingChannelChange && !_lastChannelChangeFailed)
                _currentChannel = null;
        }

        /// <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;
        }

        /// <summary>
        /// Use this when the livestream playback just stopped.
        /// </summary>
        public void AsyncStopLiveStream()
        {
            if (_liveStream != null)
            {
                _streamToStopAsync = _liveStream;
                _liveStream = null;

                if (_currentChannel != null)
                    _navigatorChannels[_currentChannel.ChannelType].PreviousChannel = _currentChannel;

                _asyncStopLiveStreamThread = new Thread(new ThreadStart(AsyncStopLiveStreamThreadMain));
                _asyncStopLiveStreamThread.Start();
            }

            if (!_doingChannelChange && !_lastChannelChangeFailed)
                _currentChannel = null;
        }

        private void TuneLiveStream(Channel channel)
        {
            Log.Debug("ChannelNavigator: TuneLiveStream(), channel = {0}", channel.DisplayName);
            if (channel != null)
            {
                using (SchedulerServiceAgent tvSchedulerAgent = new SchedulerServiceAgent())
                {
                    LiveStream liveStream = _liveStream;
                    CurrentAndNextProgram currentAndNext = tvSchedulerAgent.GetCurrentAndNextForChannel(channel.ChannelId, true, _liveStream);//null);

                    _currentChannel = channel;
                    _doingChannelChange = true;
                    RenderBlackImage();

                    if (liveStream != null)
                    {
                        try
                        {
                            g_Player.PauseGraph();
                            g_Player.OnZapping(0x80);

                            result = this.ControlAgent.TuneLiveStream(channel, ref liveStream);
                            Log.Debug("ChannelNavigator: First try to re-tune the existing TV stream (staying on the same card), result = {0}", result);

                            if (result == LiveStreamResult.Succeeded)
                            {
                                if (_isAnalog)
                                    g_Player.OnZapping(-1);

                                double duration = g_Player.Duration;
                                if (g_Player.Duration < 0.0)
                                    result = LiveStreamResult.UnknownError;
                                else
                                {
                                    g_Player.SeekAbsolute(duration);
                                    g_Player.ContinueGraph();
                                }
                            }
                            else if (result == LiveStreamResult.NoRetunePossible)// not mapped to card, card in use by recorder or other user ---> start new stream
                            {
                                // Now re-try the new channel with a new stream.
                                Log.Debug("ChannelNavigator: Seems a re-tune has failed, stop the current stream and start a new one");
                                SilentlyStopLiveStream(liveStream);
                                result = StartAndPlayNewLiveStream(channel, liveStream);
                            }
                        }
                        catch
                        {
                            result = LiveStreamResult.UnknownError;
                            Log.Error("ChannelNavigator: TuneLiveStream error");
                        }
                    }
                    else
                    {
                        result = StartAndPlayNewLiveStream(channel,liveStream);
                    }

                    _doingChannelChange = false;
                    if (result == LiveStreamResult.Succeeded)
                    {
                        _lastChannelChangeFailed = false;
                        StopRenderBlackImage();
                    }
                    else
                    {
                        _lastChannelChangeFailed = true;
                        SilentlyStopLiveStream(liveStream);
                        ChannelTuneFailedNotifyUser(result, channel);
                    }
                }
            }
        }

        private void LoadSettings(out string currentChannelName)
        {
            using (global::MediaPortal.Profile.Settings xmlreader = new global::MediaPortal.Profile.MPSettings())
            {
                _cursorX = xmlreader.GetValueAsInt(this.SettingsSection, "ypos", 0);
                _channelOffset = xmlreader.GetValueAsInt(this.SettingsSection, "yoffset", 0);
                _byIndex = xmlreader.GetValueAsBool("mytv", "byindex", true);
                _showChannelNumber = xmlreader.GetValueAsBool("mytv", "showchannelnumber", false);
                _channelNumberMaxLength = xmlreader.GetValueAsInt("mytv", "channelnumbermaxlength", 3);
                _timePerBlock = xmlreader.GetValueAsInt(this.SettingsSection, "timeperblock", 30);
                _hdtvProgramText = xmlreader.GetValueAsString("mytv", "hdtvProgramText", "(HDTV)");
                _guideContinuousScroll = xmlreader.GetValueAsBool("mytv", "continuousScrollGuide", false);
                _loopDelay = xmlreader.GetValueAsInt("gui", "listLoopDelay", 0);
                currentChannelName = xmlreader.GetValueAsString(this.SettingsSection, "channel", String.Empty);

                _currentChannel = PluginMain.Navigator.CurrentChannel ?? PluginMain.Navigator.GetPreviousChannel(_channelType);
                if (_currentChannel != null)
                {
                    currentChannelName = _currentChannel.DisplayName;
                }

                if (_channelOffset < 0)
                {
                    _channelOffset = 0;
                }
            }
            _useNewRecordingButtonColor =
              Utils.FileExistsInCache(Path.Combine(GUIGraphicsContext.Skin, @"media\tvguide_recButton_Focus_middle.png"));
            _useNewPartialRecordingButtonColor =
              Utils.FileExistsInCache(Path.Combine(GUIGraphicsContext.Skin, @"media\tvguide_partRecButton_Focus_middle.png"));
            _useNewNotifyButtonColor =
              Utils.FileExistsInCache(Path.Combine(GUIGraphicsContext.Skin, @"media\tvguide_notifyButton_Focus_middle.png"));
            _useHdProgramIcon =
              Utils.FileExistsInCache(Path.Combine(GUIGraphicsContext.Skin, @"media\tvguide_hd_program.png"));
        }

 private void updateSingleChannelNumber()
 {
     // update selected channel
     if (!_singleChannelView)
     {
         _singleChannelNumber = _cursorX + _channelOffset;
         if (_singleChannelNumber < 0)
         {
             _singleChannelNumber = 0;
         }
         if (_singleChannelNumber >= _channelList.Count)
         {
             _singleChannelNumber -= _channelList.Count;
         }
         // instead of direct casting us "as"; else it fails for other controls!
         GUIButton3PartControl img = GetControl(_cursorX + (int)Controls.IMG_CHAN1) as GUIButton3PartControl;
         ;
         if (null != img)
         {
             _currentChannel = (Channel)img.Data;
         }
     }
 }