Esempio n. 1
0
        static void Main(string[] args)
        {
            // Create a radio and its up/down command objects
            Radio radio = new Radio();

            radio.SwitchOn();
            IVoiceCommand volumeUpCommand   = new VolumeUpCommand(radio);
            IVoiceCommand volumeDownCommand = new VolumeDownCommand(radio);

            // Create an electric window and its up/down command objects
            ElectricWindow window            = new ElectricWindow();
            IVoiceCommand  windowUpCommand   = new WindowUpCommand(window);
            IVoiceCommand  windowDownCommand = new WindowDownCommand(window);

            // Create a speech recogniser object
            SpeechRecogniser speechRecogniser = new SpeechRecogniser();

            speechRecogniser.SetCommands(volumeUpCommand, volumeDownCommand);
            Console.WriteLine("Speech recognition controlling the radio");
            speechRecogniser.HearUpSpoken();
            speechRecogniser.HearUpSpoken();
            speechRecogniser.HearUpSpoken();
            speechRecogniser.HearDownSpoken();

            speechRecogniser.SetCommands(windowUpCommand, windowDownCommand);
            Console.WriteLine("Speech recognition will now control the window");
            speechRecogniser.HearDownSpoken();
            speechRecogniser.HearUpSpoken();

            Console.Read();
        }
Esempio n. 2
0
        protected async Task Handle(VolumeDownCommand command)
        {
            var volume = _volume - command.AsDouble(MessageProperties.ChangeFactor);
            var cmd    = GetKodiCommand("Application.SetVolume", new { volume = (int)volume });
            var result = await MessageBroker.QueryService <KodiCommand, JsonRpcResponse>(cmd).ConfigureAwait(false);

            _volume = await UpdateState(VolumeState.StateName, _volume, volume).ConfigureAwait(false);
        }
Esempio n. 3
0
        protected async Task Handle(VolumeDownCommand command)
        {
            var volume = _volume - command.AsDouble(MessageProperties.ChangeFactor);
            var cmd    = GetJsonCommand("audio", "setAudioVolume", new SonyAudioVolumeRequest("speaker", ((int)volume).ToString()));
            await MessageBroker.QueryJsonService <SonyJsonQuery, SonyAudioResult>(cmd);

            _volume = await UpdateState(VolumeState.StateName, _volume, volume);
        }
Esempio n. 4
0
        public void Create()
        {
            var log      = A.Fake <ILogger>();
            var radio    = A.Fake <IRadio>();
            var provider = A.Fake <IConfigurationProvider>();

            var command = new VolumeDownCommand(log, provider, radio);

            Assert.NotNull(command);
        }
Esempio n. 5
0
        public void CheckName()
        {
            var log      = A.Fake <ILogger>();
            var radio    = A.Fake <IRadio>();
            var provider = A.Fake <IConfigurationProvider>();

            var command = new VolumeDownCommand(log, provider, radio);

            Assert.Contains("-vd", command.Name);
            Assert.Contains("--volumeDown", command.Name);
            Assert.Contains("Decrease volume by 10%", command.Description);
        }
Esempio n. 6
0
        public async Task ExecuteWithoutValue()
        {
            var log      = A.Fake <ILogger>();
            var radio    = A.Fake <IRadio>();
            var provider = A.Fake <IConfigurationProvider>();

            var command = new VolumeDownCommand(log, provider, radio);

            var result = await command.Execute(new string[0]);

            A.CallTo(() => radio.VolumeDown()).MustHaveHappened();
            Assert.Equal(CommandResult.OK, result);
        }
Esempio n. 7
0
        protected async Task Handle(VolumeDownCommand command)
        {
            var volume = _volume - command.AsDouble(MessageProperties.ChangeFactor);
            var cmd    = new ComputerCommand
            {
                Address = _hostname,
                Service = "Volume",
                Message = new VolumePost {
                    Volume = volume
                }
            };
            await MessageBroker.SendToService(cmd).ConfigureAwait(false);

            _volume = await UpdateState(VolumeState.StateName, _volume, volume).ConfigureAwait(false);
        }
Esempio n. 8
0
        static void Main()
        {
            var tv = new TV();

            var turnOffCommand    = new TurnOffCommand(tv);
            var turnOnCommand     = new TurnOnCommand(tv);
            var volumeUpCommand   = new VolumeUpCommand(tv);
            var volumeDownCommand = new VolumeDownCommand(tv);

            var buttonsCount    = 5;
            var tvRemoteControl = new TVRemoteControl(buttonsCount);

            tvRemoteControl.SetButtonFunction(0, turnOffCommand);
            tvRemoteControl.SetButtonFunction(1, turnOnCommand);
            tvRemoteControl.SetButtonFunction(2, volumeUpCommand);
            tvRemoteControl.SetButtonFunction(3, volumeDownCommand);

            for (int i = 0; i < buttonsCount; i++)
            {
                tvRemoteControl.PressButton(i);
            }
        }
Esempio n. 9
0
        protected async Task Handle(VolumeDownCommand command)
        {
            if (_volume.HasValue)
            {
                var changeFactor = command.AsDouble(MessageProperties.ChangeFactor, DEFAULT_VOLUME_CHANGE_FACTOR);
                var volume       = _volume - changeFactor;
                var normalized   = NormalizeVolume(volume.Value);

                var control = new DenonControlQuery
                {
                    Command    = normalized,
                    Api        = "formiPhoneAppVolume",
                    ReturnNode = "MasterVolume",
                    Address    = _hostName,
                    Zone       = _zone.ToString()
                };

                // Results are unpredictable so we ignore them
                await MessageBroker.QueryService <DenonControlQuery, string>(control).ConfigureAwait(false);

                _volume = await UpdateState(VolumeState.StateName, _volume, volume).ConfigureAwait(false);
            }
        }
Esempio n. 10
0
        public void VoiceCommandTest()
        {
            //given
            Radio radio = new Radio();

            radio.SwitchOn();

            IVoiceCommand volumeUpCommand   = new VolumeUpCommand(radio);
            IVoiceCommand volumeDownCommand = new VolumeDownCommand(radio);

            ElectricWindow window            = new ElectricWindow();
            IVoiceCommand  windowUpCommand   = new WindowUpCommand(window);
            IVoiceCommand  windowDownCommand = new WindowDownCommand(window);

            //when
            SpeachRecogniser speeachRecogniser = new SpeachRecogniser();

            speeachRecogniser.SetCommands(volumeUpCommand, volumeDownCommand);
            System.Console.WriteLine("Speech recognition is controlling radio");
            speeachRecogniser.HearUpSproken();
            speeachRecogniser.HearUpSproken();
            speeachRecogniser.HearUpSproken();
            speeachRecogniser.HearDownSproken();
        }
Esempio n. 11
0
        protected Task Handle(VolumeDownCommand command)
        {
            var cmd = GetCommand("KEY_VOLDOWN");

            return(MessageBroker.SendToService(cmd));
        }
Esempio n. 12
0
 protected void Handle(VolumeDownCommand command)
 {
     //TODO
 }