public virtual void RemoveComponent(IStudioComponent component)
 {
     if (_components.Remove(component))
     {
         component.InputRemoved  -= Component_EndpointRemoved;
         component.OutputRemoved -= Component_EndpointRemoved;
         var foundConnections = new List <StudioConnection>();
         if (component.Inputs != null)
         {
             foreach (var input in component.Inputs)
             {
                 foreach (var connection in _connections.Where(c => c.Input == input).ToList())
                 {
                     RemoveConnection(connection);
                 }
             }
         }
         if (component.Outputs != null)
         {
             foreach (var output in component.Outputs)
             {
                 foreach (var connection in _connections.Where(c => c.Output == output).ToList())
                 {
                     RemoveConnection(connection);
                 }
             }
         }
         ComponentRemoved?.Invoke(this, component);
     }
 }
        public virtual IStudioComponent AddComponent(IStudioComponent component)
        {
            if (_components.Contains(component))
            {
                return(null);
            }
            IStudioComponent newComponent = null;

            if (ComponentRepository.Contains(component))
            {
                if (component is PlaceholderStudioComponent placeholderComponent)
                {
                    newComponent = ComponentRepository.GetPlaceholderClone(placeholderComponent);
                }
                else
                {
                    newComponent = component;
                }
                _components.Add(newComponent);
                newComponent.InputRemoved  += Component_EndpointRemoved;
                newComponent.OutputRemoved += Component_EndpointRemoved;
                ComponentAdded?.Invoke(this, newComponent);
            }
            return(newComponent);
        }
 public virtual void RemoveClient(IStudioComponent client)
 {
     if (_clients.Remove(client))
     {
         ClientRemoved?.Invoke(this, client);
     }
 }
        public void TestInit()
        {
            var virtualStudio = new VirtualStudioWithArrangement();

            // Create a placeholder and add it to ComponentRepository and add a copy to the VirtualStudio's components.
            placeholderInRepository = new PlaceholderStudioComponent();
            placeholderInRepository.SetName("Placeholder 1");
            placeholderInRepository.AddInput("Input 1", Shared.DataKind.Audio, "WebRTC");
            placeholderInRepository.AddOutput("Output 1", Shared.DataKind.Audio, "WebRTC");
            virtualStudio.ComponentRepository.AddPlaceholder(placeholderInRepository);
            placeholderInComponents = virtualStudio.AddComponent(placeholderInRepository);

            // Create a component mock and add it to ComponentRepository AND the VirtualStudio.
            client1Mock = new Mock <IStudioComponent>();
            client1Mock.Setup(m => m.SetId(It.IsAny <int>())).Callback <int>((value) => client1Id = value);
            client1Mock.SetupGet(m => m.Id).Returns(() => client1Id);
            virtualStudio.ComponentRepository.AddClient(client1Mock.Object);
            virtualStudio.AddComponent(client1Mock.Object);

            // Create a component mock and add it only to ComponentRepository.
            client2Mock = new Mock <IStudioComponent>();
            client2Mock.Setup(m => m.SetId(It.IsAny <int>())).Callback <int>((value) => client2Id = value);
            client2Mock.SetupGet(m => m.Id).Returns(() => client2Id);
            virtualStudio.ComponentRepository.AddClient(client2Mock.Object);

            this.virtualStudio = virtualStudio;

            operationHandlerMock        = new Mock <IVirtualStudioUpdateListener>();
            virtualStudioEventProcessor = new VirtualStudioEventProcessor(virtualStudio, virtualStudioName, operationHandlerMock.Object);
        }
 private void DetachComponentEventHandlers(IStudioComponent component)
 {
     component.PropertyChanged -= Component_PropertyChanged;
     component.InputAdded      -= Component_InputAdded;
     component.InputRemoved    -= Component_InputRemoved;
     component.OutputAdded     -= Component_OutputAdded;
     component.OutputRemoved   -= Component_OutputRemoved;
 }
 public virtual bool AddClient(IStudioComponent client)
 {
     if (AddClientStudioComponent(client))
     {
         ClientAdded?.Invoke(this, client);
         return(true);
     }
     return(false);
 }
        public void Init()
        {
            virtualStudio = new VirtualStudio();
            var placeholderComponent = new PlaceholderStudioComponent();

            placeholderComponent.SetName("New Placeholder");
            virtualStudio.ComponentRepository.AddPlaceholder(placeholderComponent);
            component           = virtualStudio.AddComponent(placeholderComponent);
            repositoryComponent = placeholderComponent;
        }
        protected virtual bool AddClientStudioComponent(IStudioComponent component)
        {
            if (!PrepareAddComponent(component))
            {
                return(false);
            }

            _clients.Add(component);
            return(true);
        }
 public override void RemoveComponent(IStudioComponent component)
 {
     if (_components.Contains(component))
     {
         var node = _componentNodes.Single(c => c.Component == component);
         _componentNodes.Remove(node);
         node.PositionChanged -= ComponentNode_PositionChanged;
         base.RemoveComponent(component);
     }
 }
 public static StudioComponentDto ToDto(this IStudioComponent component)
 {
     return(new StudioComponentDto
     {
         IsPlaceholder = component is PlaceholderStudioComponent,
         Id = component.Id,
         Name = component.Name,
         Inputs = component.Inputs?.ToDto(),
         Outputs = component.Outputs?.ToDto()
     });
 }
 private void VirtualStudio_ComponentAdded(object sender, IStudioComponent component)
 {
     if (component is PlaceholderStudioComponent)
     {
         AttachComponentEventHandlers(component);
         operationHandler.AddPlaceholder(VirtualStudioName, component.ToDto());
     }
     else
     {
         operationHandler.AddComponent(VirtualStudioName, component.Id);
     }
 }
Пример #12
0
        private bool ProcessSync(VirtualStudio virtualStudio)
        {
            IStudioComponent studioComponent = virtualStudio.Components.FirstOrDefault(c => c.Id == componentId);

            if (studioComponent is null)
            {
                Error = new OperationError(ErrorType.NotFound, $"Component with ID {componentId} not found.");
                return(false);
            }
            virtualStudio.RemoveComponent(studioComponent);
            return(true);
        }
 private bool ChangeProperty(IStudioComponent component, string propertyName, object value)
 {
     switch (propertyName)
     {
     case nameof(component.Name):
         if (value is string nameString)
         {
             component.SetName(nameString);
             return(true);
         }
         break;
     }
     return(false);
 }
        public void Init()
        {
            virtualStudio = new VirtualStudio();

            var placeholder = new PlaceholderStudioComponent();

            placeholder.AddInput("Input 1", DataKind.Audio, "UDP");
            virtualStudio.ComponentRepository.AddPlaceholder(placeholder);
            componentWithUdpAudioInput = virtualStudio.AddComponent(placeholder);

            placeholder = new PlaceholderStudioComponent();
            placeholder.AddOutput("Output 1", DataKind.Audio, "UDP");
            virtualStudio.ComponentRepository.AddPlaceholder(placeholder);
            componentWithUdpAudioOutput = virtualStudio.AddComponent(placeholder);

            connection = virtualStudio.CreateConnection(componentWithUdpAudioOutput.Outputs[0], componentWithUdpAudioInput.Inputs[0]);
        }
 public ComponentNode AddComponent(IStudioComponent component, Position2D targetPosition)
 {
     if (!_components.Contains(component))
     {
         component = base.AddComponent(component);
         if (component != null)
         {
             var componentNode = new ComponentNode(component)
             {
                 Position = targetPosition
             };
             componentNode.PositionChanged += ComponentNode_PositionChanged;
             _componentNodes.Add(componentNode);
             ComponentNodeAdded?.Invoke(this, componentNode);
             return(componentNode);
         }
     }
     return(null);
 }
 private bool PrepareAddComponent(IStudioComponent component)
 {
     if (Contains(component))
     {
         return(false);
     }
     if (component.Id != 0)
     {
         if (Exists(c => c.Id == component.Id))
         {
             throw new ArgumentException("Cannot add a placeholder component with an already existing ID.");
         }
     }
     else
     {
         do
         {
             component.SetId(idGenerator.GetNewId());
         } while (Exists(c => c.Id == component.Id));
     }
     return(true);
 }
Пример #17
0
        public void Init()
        {
            virtualStudio = new VirtualStudio();

            var placeholder = new PlaceholderStudioComponent();

            placeholder.AddInput("Input 1", DataKind.Audio, "UDP");
            virtualStudio.ComponentRepository.AddPlaceholder(placeholder);
            componentWithUdpAudioInput             = virtualStudio.AddComponent(placeholder);
            componentWithUdpAudioInputInRepository = placeholder;

            placeholder = new PlaceholderStudioComponent();
            placeholder.AddInput("Input 1", DataKind.Audio, "WebRtc");
            virtualStudio.ComponentRepository.AddPlaceholder(placeholder);
            componentWithWebRtcAudioInput = virtualStudio.AddComponent(placeholder);

            placeholder = new PlaceholderStudioComponent();
            placeholder.AddInput("Input 1", DataKind.Video, "WebRtc");
            virtualStudio.ComponentRepository.AddPlaceholder(placeholder);
            componentWithWebRtcVideoInput = virtualStudio.AddComponent(placeholder);

            placeholder = new PlaceholderStudioComponent();
            placeholder.AddOutput("Output 1", DataKind.Audio, "UDP");
            virtualStudio.ComponentRepository.AddPlaceholder(placeholder);
            componentWithUdpAudioOutput = virtualStudio.AddComponent(placeholder);

            placeholder = new PlaceholderStudioComponent();
            placeholder.AddOutput("Output 1", DataKind.Audio, "WebRtc");
            virtualStudio.ComponentRepository.AddPlaceholder(placeholder);
            componentWithWebRtcAudioOutput = virtualStudio.AddComponent(placeholder);

            placeholder = new PlaceholderStudioComponent();
            placeholder.AddOutput("Output 1", DataKind.Video, "WebRtc");
            virtualStudio.ComponentRepository.AddPlaceholder(placeholder);
            componentWithWebRtcVideoOutput = virtualStudio.AddComponent(placeholder);
        }
 private void ComponentRepository_ClientAdded(object sender, IStudioComponent client)
 {
     AttachComponentEventHandlers(client);
     operationHandler.AddClientToRepository(VirtualStudioName, client.ToDto());
 }
 private void ComponentRepository_PlaceholderAdded(object sender, IStudioComponent placeholder)
 {
     AttachComponentEventHandlers(placeholder);
     operationHandler.AddPlaceholderToRepository(VirtualStudioName, placeholder.ToDto());
 }
 private void ComponentRepository_PlaceholderRemoved(object sender, IStudioComponent placeholder)
 {
     DetachComponentEventHandlers(placeholder);
     operationHandler.RemovePlaceholderFromRepository(VirtualStudioName, placeholder.Id);
 }
 private void VirtualStudio_ComponentRemoved(object sender, IStudioComponent component)
 {
     DetachComponentEventHandlers(component);
     operationHandler.RemoveComponent(VirtualStudioName, component.Id);
 }
 public ComponentNode(IStudioComponent component)
 {
     Component = component ?? throw new ArgumentNullException(nameof(component));
 }
 public void ReplaceComponent(IStudioComponent component)
 {
     throw new NotImplementedException();
 }
 public override IStudioComponent AddComponent(IStudioComponent component)
 {
     return(AddComponent(component, Position2D.Zero)?.Component);
 }
 private void ComponentRepository_ClientRemoved(object sender, IStudioComponent client)
 {
     DetachComponentEventHandlers(client);
     operationHandler.RemoveClientFromRepository(VirtualStudioName, client.Id);
 }
 public bool Contains(IStudioComponent component)
 {
     return(_clients.Contains(component) || (component is PlaceholderStudioComponent psc && _placeholders.Contains(psc)));
 }