public static Task ShutdownChannelAsync( IEventExecutorGroup bossExecutor, IEventExecutorGroup workerExecutor, IChannelGroup allChannels, TimeSpan timeSpan) { timeSpan = timeSpan.TotalSeconds <= 2 ? TimeSpan.FromSeconds(3) : timeSpan; List <Task> tasks = new List <Task>(); // Close all channels if (allChannels != null) { tasks.Add(allChannels.CloseAsync()); } // Stop boss threads if (bossExecutor != null) { tasks.Add(bossExecutor.ShutdownGracefullyAsync(TimeSpan.FromSeconds(2), timeSpan)); } // Finally stop I/O workers if (workerExecutor != null) { tasks.Add(workerExecutor.ShutdownGracefullyAsync(TimeSpan.FromSeconds(2), timeSpan)); } return(Task.WhenAll(tasks.ToArray())); }
public IndisposableChannelGroup(IChannelGroup inner) { if (inner == null) throw new ArgumentNullException("inner"); this.inner = inner; }
public override void ChannelActive(IChannelHandlerContext contex) { IChannelGroup g = _group; if (g == null) { lock (this) { if (_group == null) { g = _group = new DefaultChannelGroup(contex.Executor); } } } g?.Add(contex.Channel); _poker.Player += 1; _poker.AddPlayer(_poker.Player, contex.Channel.RemoteAddress.ToString()); //contex.WriteAndFlushAsync(g.Count); if (_poker.Player == 4) { contex.WriteAndFlushAsync("Welcome to the game!\n"); _group.WriteAndFlushAsync("Welcome to the game\n", new EveryOneBut(contex.Channel.Id)); _poker.IsGameStarted = true; } Console.WriteLine(_poker.Player); }
public void OnChannelGroupReady(IChannelGroup channelGroup, string appSecret) { MobileCenterLog.Warn(MobileCenterLog.LogTag, "Crashes service is not yet supported on this platform."); try { #if REFERENCE #else WatsonRegistrationManager.Start(appSecret); #pragma warning disable CS0612 // Type or member is obsolete MobileCenter.CorrelationIdChanged += (s, id) => { WatsonRegistrationManager.SetCorrelationId(id.ToString()); }; // Checking for null and setting id needs to be atomic to avoid // overwriting Guid newId = Guid.NewGuid(); MobileCenter.TestAndSetCorrelationId(Guid.Empty, ref newId); #pragma warning restore CS0612 // Type or member is obsolete #endif } catch (Exception e) { #if DEBUG throw new MobileCenterException("Failed to register crashes with Watson", e); #endif } }
public void OnChannelGroupReady(IChannelGroup channelGroup, string appSecret) { try { #if REFERENCE #else WatsonRegistrationManager.Start(appSecret); #pragma warning disable CS0612 // Type or member is obsolete AppCenter.CorrelationIdChanged += (s, id) => { WatsonRegistrationManager.SetCorrelationId(id.ToString()); }; // Checking for null and setting id needs to be atomic to avoid // overwriting Guid newId = Guid.NewGuid(); AppCenter.TestAndSetCorrelationId(Guid.Empty, ref newId); #pragma warning restore CS0612 // Type or member is obsolete #endif } catch (Exception e) { AppCenterLog.Error(AppCenterLog.LogTag, "Failed to register crashes with Watson", e); } }
public void ProcessReplacing(IChannelGroup inputs, IChannelGroup outputs, int sampleFrames) { SMALL_NUMBER = -SMALL_NUMBER; for (int sampleIndex = 0; sampleIndex < sampleFrames; sampleIndex++) { float leftOut = 0f; float rightOut = 0f; float leftIn = inputs.GetChannel(0)[sampleIndex]; float rightIn = inputs.GetChannel(1)[sampleIndex]; float summedInput = Undenormalise((leftIn + rightIn) * fixedGain); // Accumulate comb filters in parallel for (int i = 0; i < combCount; i++) { leftOut += leftCombs[i].Process(summedInput); rightOut += rightCombs[i].Process(summedInput); } // Feed through allpasses in series for (int i = 0; i < allPassCount; i++) { leftOut = leftAllPasses[i].Process(leftOut); rightOut = rightAllPasses[i].Process(rightOut); } outputs.GetChannel(0)[sampleIndex] = leftOut * wet1 + rightOut * wet2 + leftIn * dry; outputs.GetChannel(1)[sampleIndex] = rightOut * wet1 + leftOut * wet2 + rightIn * dry; } }
public PipelineDispatcherHook( IMessagingHost messagingHost) { _messagingHost = messagingHost; _channelGroup = _messagingHost.Initialize(); _messageChannel = _channelGroup.OpenChannel(); }
public async Task <AsyncResult <IList <IChannel> > > GetChannelsAsync(IChannelGroup group) { var channels = new List <IChannel>(); ChannelGroup indexGroup = group as ChannelGroup; if (indexGroup == null || !CheckConnection(indexGroup.ServerIndex)) { return(new AsyncResult <IList <IChannel> >(false, null)); } try { IList <WebChannelBasic> tvChannels = TvServer(indexGroup.ServerIndex).GetChannelsBasic(group.ChannelGroupId); foreach (WebChannelBasic webChannel in tvChannels) { channels.Add(new Channel { ChannelId = webChannel.Id, Name = webChannel.Title, ServerIndex = indexGroup.ServerIndex }); } return(new AsyncResult <IList <IChannel> >(true, channels)); } catch (Exception ex) { ServiceRegistration.Get <ILogger>().Error(ex.Message); return(new AsyncResult <IList <IChannel> >(false, null)); } }
/// <summary> /// Tries to get a list of programs for all channels of the given <paramref name="channelGroup"/> and time range. /// </summary> /// <param name="channelGroup">Channel group</param> /// <param name="from">Time from</param> /// <param name="to">Time to</param> /// <returns><c>true</c> if at least one program could be found</returns> public async Task <AsyncResult <IList <IProgram> > > GetProgramsGroupAsync(IChannelGroup channelGroup, DateTime from, DateTime to) { ChannelGroup indexGroup = channelGroup as ChannelGroup; if (indexGroup == null || !CheckConnection(indexGroup.ServerIndex)) { return(new AsyncResult <IList <IProgram> >(false, null)); } var programs = new List <IProgram>(); try { IList <WebChannelPrograms <WebProgramDetailed> > tvPrograms = TvServer(indexGroup.ServerIndex).GetProgramsDetailedForGroup(channelGroup.ChannelGroupId, from, to); foreach (WebProgramDetailed webProgramDetailed in tvPrograms.SelectMany(webPrograms => webPrograms.Programs)) { programs.Add(new Program(webProgramDetailed, indexGroup.ServerIndex)); } } catch (Exception ex) { ServiceRegistration.Get <ILogger>().Error(ex.Message); return(new AsyncResult <IList <IProgram> >(false, null)); } return(new AsyncResult <IList <IProgram> >(programs.Count > 0, programs)); }
public SessionTracker(IChannelGroup channelGroup, IChannelUnit channel, IApplicationSettings applicationSettings) { // Need to lock in constructor because of the event handler being set for channelGroup. lock (_lockObject) { _channel = channel; _applicationSettings = applicationSettings; channelGroup.EnqueuingLog += HandleEnqueuingLog; var sessionsString = _applicationSettings.GetValue <string>(StorageKey, null); if (sessionsString == null) { return; } _sessions = SessionsFromString(sessionsString); // Re-write sessions in storage in case of any invalid strings _applicationSettings.SetValue(StorageKey, SessionsAsString()); if (_sessions.Count == 0) { return; } var loadedSessionsString = _sessions.Values.Aggregate("Loaded stored sessions:\n", (current, session) => current + ("\t" + session + "\n")); MobileCenterLog.Debug(Analytics.Instance.LogTag, loadedSessionsString); } }
//--------------------------------------------------------------------- public Task Start(IPAddress ip_address, int port) { var builder = new ContainerBuilder(); builder.RegisterModule(new ConfigurationSettingsReader("autofac")); this.GatewaySessionListenerContainer = builder.Build(); var gatewaySessionFactory = new GatewaySessionFactory(); this.timer = new System.Timers.Timer(); this.timer.Interval = 3000; this.timer.Elapsed += (obj, evt) => { int count = 0; IChannelGroup g = this.ChannelGroup; if (g != null) { count = g.Count; } string title = Gateway.Instance.ConsoleTitle; string version = Gateway.Instance.Version; Console.Title = string.Format("{0} {1} ConnectionCount={2}", title, version, count); }; this.timer.Start(); return(this.gatewayRunner.Start(ip_address, port, gatewaySessionFactory)); }
protected async Task InitChannels(IChannelGroup channelGroup) { _channels = new List <IChannel>(); Channel = null; if (channelGroup == null) { return; } var result = await _tvHandler.ChannelAndGroupInfo.GetChannelsAsync(channelGroup); if (result.Success) { _channels = result.Result; } IChannel channel = Channel; if (channel != null) { channel = _channels?.FirstOrDefault(c => c.ChannelId == channel.ChannelId); } if (channel == null) { channel = _channels?.FirstOrDefault(); } Channel = channel; return; }
protected override void UpdateChannels() { base.UpdateChannels(); if (_webChannelGroupIndex < _channelGroups.Count) { IChannelGroup currentGroup = _channelGroups[_webChannelGroupIndex]; CurrentGroupName = currentGroup.Name; } _channelList.Clear(); if (_channels == null) { return; } foreach (IChannel channel in _channels) { // Use local variable, otherwise delegate argument is not fixed IChannel currentChannel = channel; ChannelProgramListItem item = new ChannelProgramListItem(currentChannel, GetNowAndNextProgramsList(currentChannel)) { Command = new MethodDelegateCommand(() => Tune(currentChannel)) }; item.AdditionalProperties["CHANNEL"] = channel; _channelList.Add(item); } CurrentGroupChannels.FireChange(); }
public override void ChannelActive(IChannelHandlerContext ctx) { IChannelGroup g = Group; if (g == null) { lock (this) { if (Group == null) { Group = g = new DefaultChannelGroup(ctx.Executor); } } } // Detect when client disconnects ctx.Channel.CloseCompletion.ContinueWith((x) => { Logger.Warn("Channel Closed"); g?.Remove(ctx.Channel); OnChannelInactive?.Invoke(ctx.Channel); }); // Add to channels list g.Add(ctx.Channel); // Send event upstream OnChannelActive?.Invoke(ctx.Channel); }
public override void ChannelActive(IChannelHandlerContext contex) { IChannelGroup g = Group; if (g == null) { lock (this) { g = Group ?? (Group = new DefaultChannelGroup(contex.Executor)); } } base.ChannelActive(contex); string msg = $"欢迎 to {0} secure chat server! { Dns.GetHostName()}\n"; ReplyContent <string> reply = new ReplyContent <string>() { ConnectionId = $"{contex.Channel.Id}", Cmd = 0, Scope = 0, Message = msg }; contex.WriteAndFlushAsync(reply.ToString()); g.Add(contex.Channel); }
//public bool GetChannels(IChannelGroup group, out IList<IChannel> channels) public async Task <AsyncResult <IList <IChannel> > > GetChannelsAsync(IChannelGroup group) { try { CpAction action = GetAction(Consts.ACTION_GET_CHANNELS); IList <object> inParameters = new List <object> { group.ChannelGroupId }; IList <object> outParameters = await action.InvokeAsync(inParameters); bool success = (bool)outParameters[0]; IList <Channel> channelList = (IList <Channel>)outParameters[1]; if (success) { var channels = channelList.Cast <IChannel>().ToList(); foreach (var channel in channels) { _channelCache[channel.ChannelId] = channel; } return(new AsyncResult <IList <IChannel> >(true, channels)); } } catch (Exception ex) { NotifyException(ex); } return(new AsyncResult <IList <IChannel> >(false, null)); }
protected void GetNowAndNextProgramsList() { IChannelGroup currentChannelGroup = CurrentChannelGroup; if (_tvHandler.ProgramInfo == null || currentChannelGroup == null) { return; } IDictionary <int, IProgram[]> programs; _tvHandler.ProgramInfo.GetNowAndNextForChannelGroup(currentChannelGroup, out programs); lock (CurrentGroupChannels.SyncRoot) foreach (ChannelProgramListItem channelItem in CurrentGroupChannels) { IProgram[] nowNext; IProgram currentProgram = null; IProgram nextProgram = null; IChannel channel = channelItem.Channel; if (programs != null && programs.TryGetValue(channel.ChannelId, out nowNext)) { currentProgram = nowNext.Length > 0 ? nowNext[0] : null; nextProgram = nowNext.Length > 1 ? nowNext[1] : null; } CreateProgramListItem(currentProgram, channelItem.Programs[0], channel); CreateProgramListItem(nextProgram, channelItem.Programs[1], channel, currentProgram); } }
public override void ChannelRegistered(IChannelHandlerContext context) { var group = _group; if (group == null) { lock (_channel) { if (_group == null) { group = _group = new DefaultChannelGroup(context.Executor); } } } EndPoint = _channel.RemoteAddress as IPEndPoint; group.Add(context.Channel); _log = new SessionLogger(typeof(WorldTcpHandler), $"([{EndPoint?.Address}]:{EndPoint?.Port}) "); if (!SessionManager.RegisterAsync(this).Result) { SendPacket(new SessionLoginResponse { SessionLoginResponseType = SessionLoginResponseType.MaxConnectionsReached }); _log.Debug("Client has reached maximum connections per Ip, disconnecting!"); Disconnect(); return; } _log.Debug("Client has been accepted"); }
public async Task <AsyncResult <IList <IProgram> > > GetProgramsGroupAsync(IChannelGroup channelGroup, DateTime from, DateTime to) { try { CpAction action = GetAction(Consts.ACTION_GET_PROGRAMS_GROUP); IList <object> inParameters = new List <object> { channelGroup.ChannelGroupId, from, to }; IList <object> outParameters = await action.InvokeAsync(inParameters); bool success = (bool)outParameters[0]; if (success) { IList <Program> programList = (IList <Program>)outParameters[1]; IList <IProgram> programs = programList.Distinct(ProgramComparer.Instance).ToList(); return(new AsyncResult <IList <IProgram> >(true, programs)); } } catch (Exception ex) { NotifyException(ex); } return(new AsyncResult <IList <IProgram> >(false, null)); }
public bool GetProgramsGroup(IChannelGroup channelGroup, DateTime from, DateTime to, out IList <IProgram> programs) { programs = null; try { CpAction action = GetAction(Consts.ACTION_GET_PROGRAMS_GROUP); IList <object> inParameters = new List <object> { channelGroup.ChannelGroupId, from, to }; IList <object> outParameters = action.InvokeAction(inParameters); bool success = (bool)outParameters[0]; if (success) { IList <Program> programList = (IList <Program>)outParameters[1]; programs = programList.Distinct(ProgramComparer.Instance).ToList(); // Using custom comparer to filter out duplicated programs. return(true); } } catch (Exception ex) { NotifyException(ex); } return(false); }
public bool GetNowAndNextForChannelGroup(IChannelGroup channelGroup, out IDictionary <int, IProgram[]> nowNextPrograms) { var result = GetNowAndNextForChannelGroupAsync(channelGroup).Result; nowNextPrograms = result.Result; return(result.Success); }
public bool GetChannels(IChannelGroup group, out IList <IChannel> channels) { channels = new List <IChannel>(); ChannelGroup indexGroup = group as ChannelGroup; if (indexGroup == null) { return(false); } if (!CheckConnection(indexGroup.ServerIndex)) { return(false); } try { IList <WebChannelBasic> tvChannels = TvServer(indexGroup.ServerIndex).GetChannelsBasic(group.ChannelGroupId); foreach (WebChannelBasic webChannel in tvChannels) { channels.Add(new Channel { ChannelId = webChannel.Id, Name = webChannel.Title, ServerIndex = indexGroup.ServerIndex }); } return(true); } catch (Exception ex) { ServiceRegistration.Get <ILogger>().Error(ex.Message); return(false); } }
/// <summary> /// Tries to get a list of programs for all channels of the given <paramref name="channelGroup"/> and time range. /// </summary> /// <param name="channelGroup">Channel group</param> /// <param name="from">Time from</param> /// <param name="to">Time to</param> /// <param name="programs">Returns programs</param> /// <returns><c>true</c> if at least one program could be found</returns> public bool GetProgramsGroup(IChannelGroup channelGroup, DateTime @from, DateTime to, out IList <IProgram> programs) { programs = null; ChannelGroup indexGroup = channelGroup as ChannelGroup; if (indexGroup == null) { return(false); } if (!CheckConnection(indexGroup.ServerIndex)) { return(false); } programs = new List <IProgram>(); try { IList <WebChannelPrograms <WebProgramDetailed> > tvPrograms = TvServer(indexGroup.ServerIndex).GetProgramsDetailedForGroup(channelGroup.ChannelGroupId, from, to); foreach (WebProgramDetailed webProgramDetailed in tvPrograms.SelectMany(webPrograms => webPrograms.Programs)) { programs.Add(new Program(webProgramDetailed, indexGroup.ServerIndex)); } } catch (Exception ex) { ServiceRegistration.Get <ILogger>().Error(ex.Message); return(false); } return(programs.Count > 0); }
public override void OnChannelGroupReady(IChannelGroup channelGroup, string appSecret) { lock (_serviceLock) { base.OnChannelGroupReady(channelGroup, appSecret); if (ApplicationLifecycleHelper == null) { // If it isn't null, that likely means that a test provided its own lifecycle helper ApplicationLifecycleHelper = new ApplicationLifecycleHelper(); } ApplyEnabledState(InstanceEnabled); if (ApplicationLifecycleHelper.HasShownWindow && !ApplicationLifecycleHelper.IsSuspended) { SessionTracker?.Resume(); _hasStarted = true; } else { ApplicationLifecycleHelper.ApplicationStarted += (sender, e) => { SessionTracker?.Resume(); _hasStarted = true; }; } ApplicationLifecycleHelper.ApplicationResuming += (sender, e) => SessionTracker?.Resume(); ApplicationLifecycleHelper.ApplicationSuspended += (sender, e) => SessionTracker?.Pause(); } }
protected async Task GetNowAndNextProgramsList_Async() { IChannelGroup currentChannelGroup = CurrentChannelGroup; if (_tvHandler.ProgramInfo == null || currentChannelGroup == null) { return; } var result = await _tvHandler.ProgramInfo.GetNowAndNextForChannelGroupAsync(currentChannelGroup); if (!result.Success) { return; } var programs = result.Result; lock (CurrentGroupChannels.SyncRoot) foreach (ChannelProgramListItem channelItem in CurrentGroupChannels) { IProgram[] nowNext; IProgram currentProgram = null; IProgram nextProgram = null; IChannel channel = channelItem.Channel; if (programs != null && programs.TryGetValue(channel.ChannelId, out nowNext)) { currentProgram = nowNext.Length > 0 ? nowNext[0] : null; nextProgram = nowNext.Length > 1 ? nowNext[1] : null; } CreateProgramListItem(currentProgram, channelItem.Programs[0], channel); CreateProgramListItem(nextProgram, channelItem.Programs[1], channel, currentProgram); } }
public bool GetChannels(IChannelGroup group, out IList <IChannel> channels) { channels = null; try { CpAction action = GetAction(Consts.ACTION_GET_CHANNELS); IList <object> inParameters = new List <object> { group.ChannelGroupId }; IList <object> outParameters = action.InvokeAction(inParameters); bool success = (bool)outParameters[0]; IList <Channel> channelList = (IList <Channel>)outParameters[1]; if (success) { channels = channelList.Cast <IChannel>().ToList(); foreach (var channel in channels) { _channelCache[channel.ChannelId] = channel; } return(true); } return(false); } catch (Exception ex) { NotifyException(ex); return(false); } }
public override void ProcessReplacing(IChannelGroup inputs, IChannelGroup outputs, int sampleFrames) { for(int i = 0; i < sampleFrames; i++) { outputs.GetChannel(0)[i] = gain.Process(inputs.GetChannel(0)[i]); } }
public bool GetProgramsGroup(IChannelGroup channelGroup, DateTime from, DateTime to, out IList <IProgram> programs) { var result = GetProgramsGroupAsync(channelGroup, from, to).Result; programs = result.Result; return(result.Success); }
protected override void UpdateChannels() { base.UpdateChannels(); if (_webChannelGroupIndex < _channelGroups.Count) { IChannelGroup currentGroup = _channelGroups[_webChannelGroupIndex]; CurrentGroupName = currentGroup.Name; } _channelList.Clear(); if (_channels == null) { return; } foreach (IChannel channel in _channels) { // Use local variable, otherwise delegate argument is not fixed IChannel currentChannel = channel; ChannelProgramListItem item = new ChannelProgramListItem(currentChannel, null) { Programs = new ItemsList { GetNoProgramPlaceholder(), GetNoProgramPlaceholder() }, Command = new MethodDelegateCommand(() => Tune(currentChannel)) }; item.AdditionalProperties["CHANNEL"] = channel; // Load programs asynchronously, this increases performance of list building GetNowAndNextProgramsList(item, currentChannel); _channelList.Add(item); } CurrentGroupChannels.FireChange(); }
protected virtual void AddChannelGroup(string name, IChannelGroup group) { Log.Debug(group.DispatchOnly ? "Adding dispatch-only channel group '{0}'." : "Adding full-duplex channel group '{0}'", name); group.Initialize(); this.groups[name] = group; }
/// <summary> /// Method that is called to signal start of the Push service. /// </summary> /// <param name="channelGroup"></param> /// <param name="appSecret"></param> public override void OnChannelGroupReady(IChannelGroup channelGroup, string appSecret) { using (_mutex.GetLock()) { base.OnChannelGroupReady(channelGroup, appSecret); ApplyEnabledState(IsEnabledAsync().Result); } }
protected virtual void AddChannelGroup(string name, IChannelGroup group) { Log.Debug(group.DispatchOnly ? "Adding dispatch-only channel group '{0}'." : "Adding full-duplex channel group '{0}'", name); group.Initialize(); this.groups[name] = group; }
public override void OnChannelGroupReady(IChannelGroup channelGroup, string appSecret) { lock (_serviceLock) { base.OnChannelGroupReady(channelGroup, appSecret); ApplyEnabledState(InstanceEnabled); } }
protected void SetGroupName() { if (_webChannelGroupIndex < _channelGroups.Count) { IChannelGroup group = _channelGroups[_webChannelGroupIndex]; GroupName = group.Name; } }
public override void ProcessReplacing(IChannelGroup inputs, IChannelGroup outputs, int sampleFrames) { for(int i = 0; i < sampleFrames; i++) { float level = GetLevel(i, sampleFrames, inputs.GetChannel(0), inputs.GetChannel(1)); SideChain(level); outputs.GetChannel(0)[i] = inputs.GetChannel(0)[i] * gain; outputs.GetChannel(1)[i] = inputs.GetChannel(1)[i] * gain; } }
public override void ProcessReplacing(IChannelGroup inputs, IChannelGroup outputs, int sampleFrames) { for(int frame = 0; frame < sampleFrames; frame++) { while (events.HasEvent(frame)) { MidiEvent midiEvent = events.Next(); if (midiEvent.Status == MidiStatus.NoteOn) { noteOn = true; } else if (midiEvent.Status == MidiStatus.NoteOff) { noteOn = false; } } if (noteOn) { outputs.GetChannel(0)[frame] = (float) random.NextDouble()*volume; } } }
public bool GetProgramsGroup(IChannelGroup channelGroup, DateTime from, DateTime to, out IList<IProgram> programs) { #if TVE3 programs = new List<IProgram>(); foreach (var channel in _tvBusiness.GetTVGuideChannelsForGroup(channelGroup.ChannelGroupId)) CollectionUtils.AddAll(programs, _tvBusiness.GetPrograms(TvDatabase.Channel.Retrieve(channel.IdChannel), from, to).Select(p => p.ToProgram())); #else IProgramService programService = GlobalServiceProvider.Instance.Get<IProgramService>(); IChannelGroupService channelGroupService = GlobalServiceProvider.Instance.Get<IChannelGroupService>(); var channels = channelGroupService.GetChannelGroup(channelGroup.ChannelGroupId).GroupMaps.Select(groupMap => groupMap.Channel); IDictionary<int, IList<Program>> programEntities = programService.GetProgramsForAllChannels(from, to, channels); programs = programEntities.Values.SelectMany(x => x).Select(p => p.ToProgram()).Distinct(ProgramComparer.Instance).ToList(); #endif return programs.Count > 0; }
public bool GetChannels(IChannelGroup group, out IList<IChannel> channels) { #if TVE3 channels = _tvBusiness.GetChannelsInGroup(TvDatabase.ChannelGroup.Retrieve(group.ChannelGroupId)) // Bug? SortOrder contains logical channel number, not the group sort order? // .OrderBy(c => c.SortOrder) .Where(c=> c.VisibleInGuide) .Select(c => c.ToChannel()) .ToList(); #else IChannelGroupService channelGroupService = GlobalServiceProvider.Instance.Get<IChannelGroupService>(); channels = channelGroupService.GetChannelGroup(group.ChannelGroupId).GroupMaps .Where(groupMap => groupMap.Channel.VisibleInGuide) .OrderBy(groupMap => groupMap.SortOrder) .Select(groupMap => groupMap.Channel.ToChannel()) .ToList(); #endif return true; }
public bool GetChannels(IChannelGroup group, out IList<IChannel> channels) { channels = new List<IChannel>(); ChannelGroup indexGroup = group as ChannelGroup; if (indexGroup == null) return false; if (!CheckConnection(indexGroup.ServerIndex)) return false; try { IList<WebChannelBasic> tvChannels = TvServer(indexGroup.ServerIndex).GetChannelsBasic(group.ChannelGroupId); foreach (WebChannelBasic webChannel in tvChannels) { channels.Add(new Channel { ChannelId = webChannel.Id, Name = webChannel.DisplayName, ServerIndex = indexGroup.ServerIndex }); } return true; } catch (Exception ex) { ServiceRegistration.Get<ILogger>().Error(ex.Message); return false; } }
public bool GetProgramsGroup(IChannelGroup channelGroup, DateTime from, DateTime to, out IList<IProgram> programs) { programs = null; try { CpAction action = GetAction(Consts.ACTION_GET_PROGRAMS_GROUP); IList<object> inParameters = new List<object> { channelGroup.ChannelGroupId, from, to }; IList<object> outParameters = action.InvokeAction(inParameters); bool success = (bool)outParameters[0]; if (success) { IList<Program> programList = (IList<Program>)outParameters[1]; programs = programList.Distinct(ProgramComparer.Instance).ToList(); // Using custom comparer to filter out duplicated programs. return true; } } catch (Exception ex) { NotifyException(ex); } return false; }
public bool GetChannels(IChannelGroup group, out IList<IChannel> channels) { channels = null; try { CpAction action = GetAction(Consts.ACTION_GET_CHANNELS); IList<object> inParameters = new List<object> { group.ChannelGroupId }; IList<object> outParameters = action.InvokeAction(inParameters); bool success = (bool)outParameters[0]; IList<Channel> channelList = (IList<Channel>)outParameters[1]; if (success) { channels = channelList.Cast<IChannel>().ToList(); return true; } return false; } catch (Exception ex) { NotifyException(ex); return false; } }
/// <summary> /// Method to open and maintain outstanding channels /// to the publish and subscribe lists /// </summary> protected void SetupGroupChannels() { Logger.Debug ("SetupGroupChannels - called"); string[] pubArgs = {"publish"}; string[] subArgs = {"subscribe"}; string[] blockedArgs = {"deny"}; ObjectPath objectPath; try { // First setup a channel to the publish list uint[] pubHandles = tlpConnection.RequestHandles (HandleType.List, pubArgs); objectPath = tlpConnection.RequestChannel ( org.freedesktop.Telepathy.ChannelType.ContactList, HandleType.List, pubHandles[0], true); publishGroup = Bus.Session.GetObject<IChannelGroup> (connInfo.BusName, objectPath); publishGroup.MembersChanged += OnPublishedMembersChanged; uint groupFlags = publishGroup.GroupFlags; Logger.Debug ("Group Flags: {0}", groupFlags); if ((((uint) groupFlags & (uint) ChannelGroupFlag.CanAdd) == (uint) ChannelGroupFlag.CanAdd)) Logger.Debug (" can add"); if (((uint) groupFlags & (uint) ChannelGroupFlag.CanRemove) == (uint) ChannelGroupFlag.CanRemove) Logger.Debug (" can remove"); if (((uint) groupFlags & (uint) ChannelGroupFlag.CanRescind) == (uint) ChannelGroupFlag.CanRescind) Logger.Debug (" can rescind"); if (((uint) groupFlags & (uint) ChannelGroupFlag.MessageAdd) == (uint) ChannelGroupFlag.MessageAdd) Logger.Debug (" can add messages"); if (((uint) groupFlags & (uint) ChannelGroupFlag.MessageRemove) == (uint) ChannelGroupFlag.MessageRemove) Logger.Debug (" can remove messages"); if (((uint) groupFlags & (uint) ChannelGroupFlag.MessageAccept) == (uint) ChannelGroupFlag.MessageAccept) Logger.Debug (" can accept messages"); if (((uint) groupFlags & (uint) ChannelGroupFlag.MessageReject) == (uint) ChannelGroupFlag.MessageReject) Logger.Debug (" can reject messages"); if (((uint) groupFlags & (uint) ChannelGroupFlag.MessageRescind) == (uint) ChannelGroupFlag.MessageRescind) Logger.Debug (" can rescind messages"); // Next setup a channel to the subscribe list uint[] subHandles = tlpConnection.RequestHandles (HandleType.List, subArgs); objectPath = tlpConnection.RequestChannel ( org.freedesktop.Telepathy.ChannelType.ContactList, HandleType.List, subHandles[0], true); subscribeGroup = Bus.Session.GetObject<IChannelGroup> (connInfo.BusName, objectPath); subscribeGroup.MembersChanged += OnSubscribedMembersChanged; // Next setup a channel to the blocked list uint[] blockedHandles = tlpConnection.RequestHandles (HandleType.List, blockedArgs); objectPath = tlpConnection.RequestChannel ( org.freedesktop.Telepathy.ChannelType.ContactList, HandleType.List, blockedHandles[0], true); denyGroup = Bus.Session.GetObject<IChannelGroup> (connInfo.BusName, objectPath); denyGroup.MembersChanged += OnBlockedMembersChanged; } catch (Exception sgc) { Logger.Debug ("Failed setting up group channels"); Logger.Debug (sgc.Message); Logger.Debug (sgc.StackTrace); } }
public bool GetNowAndNextForChannelGroup(IChannelGroup channelGroup, out IDictionary<int, IProgram[]> nowNextPrograms) { try { CpAction action = GetAction(Consts.ACTION_GET_NOW_NEXT_PROGRAM_FOR_GROUP); IList<object> inParameters = new List<object> { channelGroup.ChannelGroupId }; IList<object> outParameters = action.InvokeAction(inParameters); bool success = (bool)outParameters[0]; if (success) { DateTime now = DateTime.Now; nowNextPrograms = new Dictionary<int, IProgram[]>(); var programs = (IList<Program>)outParameters[1]; foreach (Program program in programs) { IProgram[] nowNext; int channelId = program.ChannelId; if (!nowNextPrograms.TryGetValue(channelId, out nowNext)) nowNext = new IProgram[2]; if (program.StartTime > now) nowNext[1] = program; else nowNext[0] = program; nowNextPrograms[channelId] = nowNext; } return true; } } catch (Exception ex) { NotifyException(ex); } nowNextPrograms = null; return false; }
/// <summary> /// Tries to get a list of programs for all channels of the given <paramref name="channelGroup"/> and time range. /// </summary> /// <param name="channelGroup">Channel group</param> /// <param name="from">Time from</param> /// <param name="to">Time to</param> /// <param name="programs">Returns programs</param> /// <returns><c>true</c> if at least one program could be found</returns> public bool GetProgramsGroup (IChannelGroup channelGroup, DateTime @from, DateTime to, out IList<IProgram> programs) { programs = null; ChannelGroup indexGroup = channelGroup as ChannelGroup; if (indexGroup == null) return false; if (!CheckConnection(indexGroup.ServerIndex)) return false; programs = new List<IProgram>(); try { IList<WebChannelPrograms<WebProgramDetailed>> tvPrograms = TvServer(indexGroup.ServerIndex).GetProgramsDetailedForGroup(channelGroup.ChannelGroupId, from, to); foreach (WebProgramDetailed webProgramDetailed in tvPrograms.SelectMany(webPrograms => webPrograms.Programs)) programs.Add(new Program(webProgramDetailed, indexGroup.ServerIndex)); } catch (Exception ex) { ServiceRegistration.Get<ILogger>().Error(ex.Message); return false; } return programs.Count > 0; }
public AsynchronousMessenger(IChannelGroup channelGroup) { this.channelGroup = channelGroup; }
public override bool GetProgramsGroup(IChannelGroup channelGroup, DateTime from, DateTime to, out IList<IProgram> programs) { IProgramService programService = GlobalServiceProvider.Instance.Get<IProgramService>(); IChannelGroupService channelGroupService = GlobalServiceProvider.Instance.Get<IChannelGroupService>(); var channels = channelGroupService.GetChannelGroup(channelGroup.ChannelGroupId).GroupMaps.Select(groupMap => groupMap.Channel); IDictionary<int, IList<Program>> programEntities = programService.GetProgramsForAllChannels(from, to, channels); programs = programEntities.Values.SelectMany(x => x).Select(p => p.ToProgram()).Distinct(ProgramComparer.Instance).ToList(); return programs.Count > 0; }
public abstract void ProcessReplacing(IChannelGroup inputs, IChannelGroup outputs, int sampleFrames);
public abstract bool GetChannels(IChannelGroup group, out IList<IChannel> channels);
public abstract bool GetProgramsGroup(IChannelGroup channelGroup, DateTime from, DateTime to, out IList<IProgram> programs);
public virtual bool GetNowAndNextForChannelGroup(IChannelGroup channelGroup, out IDictionary<int, IProgram[]> nowNextPrograms) { nowNextPrograms = new Dictionary<int, IProgram[]>(); IList<IChannel> channels; if (!GetChannels(channelGroup, out channels)) return false; foreach (IChannel channel in channels) { IProgram programNow; IProgram programNext; if (GetNowNextProgram(channel, out programNow, out programNext)) nowNextPrograms[channel.ChannelId] = new[] { programNow, programNext }; } return true; }
public override void ProcessReplacing(IChannelGroup inputs, IChannelGroup outputs, int sampleFrames) { reverb.ProcessReplacing(inputs, outputs, sampleFrames); }
public bool GetNowAndNextForChannelGroup(IChannelGroup channelGroup, out IDictionary<int, IProgram[]> programs) { programs = null; ChannelGroup indexGroup = channelGroup as ChannelGroup; if (indexGroup == null) return false; if (!CheckConnection(indexGroup.ServerIndex)) return false; programs = new Dictionary<int, IProgram[]>(); try { IList<IChannel> channels; if (!GetChannels(indexGroup, out channels)) return false; foreach (IChannel channel in channels) { IProgram[] nowNext = new IProgram[2]; IList<WebProgramDetailed> tvPrograms = TvServer(indexGroup.ServerIndex).GetNowNextWebProgramDetailedForChannel(channel.ChannelId); if (tvPrograms.Count == 0) continue; if (tvPrograms.Count > 0 && tvPrograms[0] != null) nowNext[0]= new Program(tvPrograms[0], indexGroup.ServerIndex); if (tvPrograms.Count > 1 && tvPrograms[1] != null) nowNext[1]= new Program(tvPrograms[1], indexGroup.ServerIndex); programs[channel.ChannelId] = nowNext; } } catch (Exception ex) { ServiceRegistration.Get<ILogger>().Error(ex.Message); return false; } return true; }
public override bool GetChannels(IChannelGroup group, out IList<IChannel> channels) { if (group.ChannelGroupId < 0) { var radioGroup = RadioChannelGroup.Retrieve(-group.ChannelGroupId); var radioChannels = radioGroup.ReferringRadioGroupMap().OrderBy(rgm => rgm.SortOrder).Select(rgm => rgm.ReferencedChannel()); channels = radioChannels .Where(c => c.VisibleInGuide) .Select(c => c.ToChannel()) .Where(c => c != null) .ToList(); } else { channels = _tvBusiness.GetChannelsInGroup(TvDatabase.ChannelGroup.Retrieve(group.ChannelGroupId)) // Bug? SortOrder contains logical channel number, not the group sort order? // .OrderBy(c => c.SortOrder) .Where(c => c.VisibleInGuide) .Select(c => c.ToChannel()) .Where(c => c != null) .ToList(); } return true; }
public override bool GetChannels(IChannelGroup group, out IList<IChannel> channels) { IChannelGroupService channelGroupService = GlobalServiceProvider.Instance.Get<IChannelGroupService>(); channels = channelGroupService.GetChannelGroup(group.ChannelGroupId).GroupMaps .Where(groupMap => groupMap.Channel.VisibleInGuide) .OrderBy(groupMap => groupMap.SortOrder) .Select(groupMap => groupMap.Channel.ToChannel()) .ToList(); return true; }
public override bool GetProgramsGroup(IChannelGroup channelGroup, DateTime from, DateTime to, out IList<IProgram> programs) { programs = new List<IProgram>(); if (channelGroup.ChannelGroupId < 0) { foreach (var channel in _tvBusiness.GetRadioGuideChannelsForGroup(-channelGroup.ChannelGroupId)) CollectionUtils.AddAll(programs, _tvBusiness.GetPrograms(TvDatabase.Channel.Retrieve(channel.IdChannel), from, to).Select(p => p.ToProgram())); } else { foreach (var channel in _tvBusiness.GetTVGuideChannelsForGroup(channelGroup.ChannelGroupId)) CollectionUtils.AddAll(programs, _tvBusiness.GetPrograms(TvDatabase.Channel.Retrieve(channel.IdChannel), from, to).Select(p => p.ToProgram())); } return programs.Count > 0; }
public bool GetChannels(IChannelGroup group, out IList<IChannel> channels) { IChannelGroupService channelGroupService = GlobalServiceProvider.Get<IChannelGroupService>(); channels = channelGroupService.GetChannelGroup(group.ChannelGroupId).GroupMaps .Select(groupMap => groupMap.Channel.ToChannel()) .ToList(); return true; }