void InitDevice(IIsActive <BassItem> Device)
        {
            _devices.Add(Device.Item.Id, new RecordingItem
            {
                DeviceId = Device.Item.Id
            });

            Device.PropertyChanged += (S, E) =>
            {
                if (E.PropertyName == nameof(Device.IsActive))
                {
                    if (Device.IsActive)
                    {
                        AddDevice(Device);
                    }
                    else
                    {
                        RemoveDevice(Device);
                    }
                }
            };

            if (Device.IsActive)
            {
                AddDevice(Device);
            }
        }
Exemple #2
0
        public static void SetIsActive(this IIsActive isActive, bool active)
        {
            if (isActive == null)
            {
                return;
            }

            isActive.IsActive           = active;
            isActive.ActiveInactiveDate = DateTime.Now;
        }
Exemple #3
0
        public override Task <int> SaveChangesAsync(CancellationToken cancellationToken = default)
        {
            this.ChangeTracker.DetectChanges();
            #region added
            var AllEntities = ChangeTracker.Entries().Where(x => x.State == EntityState.Added).Select(x => x.Entity);

            foreach (var item in AllEntities)
            {
                if (item.GetType().GetInterface(nameof(IBase)) != null)
                {
                    IBase basicFile = item as IBase;
                    basicFile.IsActive    = false;
                    basicFile.PublishDate = DateTime.Now;
                }
                else if (item.GetType().GetInterface(nameof(IIsActive)) != null)
                {
                    IIsActive ISAct = item as IIsActive;
                    ISAct.IsActive = false;
                }
            }


            #endregion



            #region modified
            var Modifiedobject = ChangeTracker.Entries()
                                 .Where(x => x.State == EntityState.Modified)
                                 .Select(x => x.Entity).ToArray();

            foreach (var item in Modifiedobject)
            {
                if (item.GetType().Name == nameof(EntityModels.Entities.Posts.Post))
                {
                    var SourceObject = item as Post;
                    SourceObject.Slug = SourceObject.Title.Trim().Replace(" ", "-");
                }
                else if (item.GetType().Name == nameof(EntityModels.Entities.Products.Product))
                {
                    var SourceObject = item as Product;
                    SourceObject.Slug = SourceObject.Name.Trim().Replace(" ", "-");
                }
            }


            #endregion

            return(base.SaveChangesAsync(cancellationToken));
        }
        void AddDevice(IIsActive <BassItem> Device)
        {
            lock (_syncLock)
            {
                var id = Device.Item.Id;

                if (_devices[id].RecordingHandle != 0)
                {
                    return;
                }

                Bass.RecordInit(id);

                var devInfo = Bass.RecordGetDeviceInfo(id);

                if (devInfo.IsLoopback)
                {
                    var playbackDevice = FindPlaybackDevice(devInfo);

                    if (playbackDevice != -1)
                    {
                        Bass.Init(playbackDevice);
                        Bass.CurrentDevice = playbackDevice;

                        var silence = Bass.CreateStream(44100, 2, BassFlags.Default, Extensions.SilenceStreamProcedure);

                        Bass.ChannelSetAttribute(silence, ChannelAttribute.Volume, 0);

                        _devices[id].SilenceHandle = silence;
                    }
                }

                Bass.CurrentRecordingDevice = id;

                var info = Bass.RecordingInfo;

                var handle = Bass.RecordStart(info.Frequency, info.Channels, BassFlags.RecordPause, null);

                _devices[id].RecordingHandle = handle;

                BassMix.MixerAddChannel(_mixer, handle, BassFlags.MixerDownMix | BassFlags.MixerLimit);

                if (_running)
                {
                    Bass.ChannelPlay(handle);
                }
            }
        }
        void RemoveDevice(IIsActive <BassItem> Device)
        {
            lock (_syncLock)
            {
                var id = Device.Item.Id;

                if (_devices[id].RecordingHandle == 0)
                {
                    return;
                }

                var handle = _devices[id].RecordingHandle;

                BassMix.MixerRemoveChannel(handle);

                Bass.StreamFree(handle);

                _devices[id].RecordingHandle = 0;

                Bass.StreamFree(_devices[id].SilenceHandle);

                _devices[id].SilenceHandle = 0;
            }
        }