public ControllerActionPageViewModel(
            INavigationService navigationService,
            ITranslationService translationService,
            ICreationManager creationManager,
            IDeviceManager deviceManager,
            IDialogService dialogService,
            IPreferences preferences,
            NavigationParameters parameters)
            : base(navigationService, translationService)
        {
            _creationManager = creationManager;
            _deviceManager   = deviceManager;
            _dialogService   = dialogService;
            _preferences     = preferences;

            ControllerAction = parameters.Get <ControllerAction>("controlleraction", null);
            ControllerEvent  = parameters.Get <ControllerEvent>("controllerevent", null) ?? ControllerAction?.ControllerEvent;

            var device = _deviceManager.GetDeviceById(ControllerAction?.DeviceId);

            if (ControllerAction != null && device != null)
            {
                SelectedDevice             = device;
                Action.Channel             = ControllerAction.Channel;
                Action.IsInvert            = ControllerAction.IsInvert;
                Action.ChannelOutputType   = ControllerAction.ChannelOutputType;
                Action.MaxServoAngle       = ControllerAction.MaxServoAngle;
                Action.ButtonType          = ControllerAction.ButtonType;
                Action.AxisType            = ControllerAction.AxisType;
                Action.AxisCharacteristic  = ControllerAction.AxisCharacteristic;
                Action.MaxOutputPercent    = ControllerAction.MaxOutputPercent;
                Action.AxisDeadZonePercent = ControllerAction.AxisDeadZonePercent;
                Action.ServoBaseAngle      = ControllerAction.ServoBaseAngle;
                Action.StepperAngle        = ControllerAction.StepperAngle;
                Action.SequenceName        = ControllerAction.SequenceName;
            }
            else
            {
                var lastSelectedDeviceId = _preferences.Get <string>("LastSelectedDeviceId", null, "com.scn.BrickController2.ControllerActionPage");
                SelectedDevice             = _deviceManager.GetDeviceById(lastSelectedDeviceId) ?? _deviceManager.Devices.FirstOrDefault();
                Action.Channel             = 0;
                Action.IsInvert            = false;
                Action.ChannelOutputType   = ChannelOutputType.NormalMotor;
                Action.MaxServoAngle       = 90;
                Action.ButtonType          = ControllerButtonType.Normal;
                Action.AxisType            = ControllerAxisType.Normal;
                Action.AxisCharacteristic  = ControllerAxisCharacteristic.Linear;
                Action.MaxOutputPercent    = 100;
                Action.AxisDeadZonePercent = 0;
                Action.ServoBaseAngle      = 0;
                Action.StepperAngle        = 90;
                Action.SequenceName        = string.Empty;
            }

            SaveControllerActionCommand   = new SafeCommand(async() => await SaveControllerActionAsync(), () => SelectedDevice != null);
            DeleteControllerActionCommand = new SafeCommand(async() => await DeleteControllerActionAsync());
            OpenDeviceDetailsCommand      = new SafeCommand(async() => await OpenDeviceDetailsAsync(), () => SelectedDevice != null);
            OpenChannelSetupCommand       = new SafeCommand(async() => await OpenChannelSetupAsync(), () => SelectedDevice != null);
            OpenSequenceEditorCommand     = new SafeCommand(async() => await OpenSequenceEditorAsync());
        }
示例#2
0
        public void ExecuteAsyncT_RunsOnTaskPool(string parameter)
        {
            ICommand command = new SafeCommand <string>(MockTask);

            bool   isExecuting = true;
            Thread callingThread = null, executingThread = null;

            async Task MockTask(string text)
            {
                await Task.Delay(Delay);

                executingThread = Thread.CurrentThread;
                isExecuting     = false;
            }

            var thread = new Thread(new ThreadStart(() =>
            {
                callingThread = Thread.CurrentThread;
                command.Execute(parameter);
            }));

            thread.Start();
            while (isExecuting)
            {
                Thread.Sleep(Delay / 25);
            }

            Assert.False(callingThread.IsThreadPoolThread);
            Assert.True(executingThread.IsThreadPoolThread);
        }
示例#3
0
        public void AsyncCommand_CanExecuteChanged_Test()
        {
            //Arrange
            bool canCommandExecute       = false;
            bool didCanExecuteChangeFire = false;

            SafeCommand command = new SafeCommand(NoParameterTask, canExecute: commandCanExecute);

            command.CanExecuteChanged += handleCanExecuteChanged;

            void handleCanExecuteChanged(object sender, EventArgs e) => didCanExecuteChangeFire = true;
            bool commandCanExecute() => canCommandExecute;

            Assert.False(command.CanExecute(null));

            //Act
            canCommandExecute = true;

            //Assert
            Assert.True(command.CanExecute(null));
            Assert.False(didCanExecuteChangeFire);

            //Act
            command.RaiseCanExecuteChanged();

            //Assert
            Assert.True(didCanExecuteChangeFire);
            Assert.True(command.CanExecute(null));
        }
        public CreationPageViewModel(
            INavigationService navigationService,
            ITranslationService translationService,
            ICreationManager creationManager,
            IDialogService dialogService,
            ISharedFileStorageService sharedFileStorageService,
            IPlayLogic playLogic,
            NavigationParameters parameters)
            : base(navigationService, translationService)
        {
            _creationManager         = creationManager;
            _dialogService           = dialogService;
            SharedFileStorageService = sharedFileStorageService;
            _playLogic = playLogic;

            Creation = parameters.Get <Creation>("creation");

            ImportControllerProfileCommand = new SafeCommand(async() => await ImportControllerProfileAsync(), () => SharedFileStorageService.IsSharedStorageAvailable);
            ExportCreationCommand          = new SafeCommand(async() => await ExportCreationAsync(), () => SharedFileStorageService.IsSharedStorageAvailable);
            RenameCreationCommand          = new SafeCommand(async() => await RenameCreationAsync());
            PlayCommand = new SafeCommand(async() => await PlayAsync());
            AddControllerProfileCommand    = new SafeCommand(async() => await AddControllerProfileAsync());
            ControllerProfileTappedCommand = new SafeCommand <ControllerProfile>(async controllerProfile => await NavigationService.NavigateToAsync <ControllerProfilePageViewModel>(new NavigationParameters(("controllerprofile", controllerProfile))));
            DeleteControllerProfileCommand = new SafeCommand <ControllerProfile>(async controllerProfile => await DeleteControllerProfileAsync(controllerProfile));
        }
示例#5
0
        public void ExecuteAsync_RunsOnNewThread()
        {
            ICommand command = new SafeCommand(MockTask);

            bool   isExecuting = true;
            Thread callingThread = null, executingThread = null;

            async Task MockTask()
            {
                await Task.Delay(Delay);

                executingThread = Thread.CurrentThread;
                isExecuting     = false;
            }

            var thread = new Thread(new ThreadStart(() =>
            {
                callingThread = Thread.CurrentThread;
                command.Execute(null);
            }));

            thread.Start();
            while (isExecuting)
            {
                Thread.Sleep(Delay / 25);
            }

            Assert.NotEqual(callingThread.ManagedThreadId, executingThread.ManagedThreadId);
        }
示例#6
0
        public ControllerProfilePageViewModel(
            INavigationService navigationService,
            ITranslationService translationService,
            ICreationManager creationManager,
            IDeviceManager deviceManager,
            IDialogService dialogService,
            IPlayLogic playLogic,
            NavigationParameters parameters)
            : base(navigationService, translationService)
        {
            _creationManager = creationManager;
            _deviceManager   = deviceManager;
            _dialogService   = dialogService;
            _playLogic       = playLogic;

            ControllerProfile = parameters.Get <ControllerProfile>("controllerprofile");

            RenameProfileCommand      = new SafeCommand(async() => await RenameControllerProfileAsync());
            AddControllerEventCommand = new SafeCommand(async() => await AddControllerEventAsync());
            PlayCommand = new SafeCommand(async() => await PlayAsync());
            ControllerActionTappedCommand = new SafeCommand <ControllerActionViewModel>(async controllerActionViewModel => await NavigationService.NavigateToAsync <ControllerActionPageViewModel>(new NavigationParameters(("controlleraction", controllerActionViewModel.ControllerAction))));
            DeleteControllerEventCommand  = new SafeCommand <ControllerEvent>(async controllerEvent => await DeleteControllerEventAsync(controllerEvent));
            DeleteControllerActionCommand = new SafeCommand <ControllerAction>(async controllerAction => await DeleteControllerActionAsync(controllerAction));

            PopulateControllerEvents();
        }
        public void ExecuteT_SecondCallAfterException_Executes()
        {
            int times = 0;

            async Task MockTask(string text)
            {
                await Task.Delay(Delay);

                if (times++ == 0)
                {
                    throw new Exception(); //Throws only on first try
                }
            }

            var      dts     = new DeterministicTaskScheduler(shouldThrowExceptions: false);
            ICommand command = new SafeCommand <string>(MockTask, dts, null, null);

            command.Execute("test");
            dts.RunTasksUntilIdle();

            command.Execute("test");
            dts.RunTasksUntilIdle();

            Assert.NotEmpty(dts.Exceptions);
            Assert.Equal(2, times);
        }
示例#8
0
        public void ExecuteAsync_MustRunOnCurrentSyncContextTrue_RunsOnCurrentThread()
        {
            ICommand command = new SafeCommand(MockTask, mustRunOnCurrentSyncContext: true);

            bool   isExecuting = true;
            Thread callingThread = null, executingThread = null;

            async Task MockTask()
            {
                executingThread = Thread.CurrentThread;
                await Task.Delay(Delay).ConfigureAwait(true);

                isExecuting = false;
            }

            var thread = new Thread(new ThreadStart(() =>
            {
                callingThread = Thread.CurrentThread;
                command.Execute(null);
            }));

            thread.Start();
            while (isExecuting)
            {
                Thread.Sleep(Delay / 25);
            }

            Assert.Equal(callingThread.ManagedThreadId, executingThread.ManagedThreadId);
        }
        public void ExecuteT_IBusy_CalledTwice_FiresOnceIfBusy()
        {
            int times = 0;

            async Task MockTask(string text)
            {
                await Task.Delay(Delay);

                times++;
            }

            var mockVm = new Mock <IBusy>();

            var      dts     = new DeterministicTaskScheduler(shouldThrowExceptions: false);
            ICommand command = new SafeCommand <string>(MockTask, dts, mockVm.Object);

            command.Execute("test");
            command.Execute("test");
            dts.RunTasksUntilIdle();

            Assert.Equal(1, times);
            mockVm.VerifyGet(vm => vm.IsBusy, Times.Exactly(2));
            mockVm.VerifySet(vm => vm.IsBusy = true);
            mockVm.VerifySet(vm => vm.IsBusy = false);
        }
示例#10
0
        public void ExecuteAsync_MustRunOnCurrentSyncContextTrue_NotRunOnTaskPool()
        {
            ICommand command = new SafeCommand(MockTask, mustRunOnCurrentSyncContext: true);

            bool   isExecuting = true;
            Thread callingThread = null, executingThread = null;

            async Task MockTask()
            {
                executingThread = Thread.CurrentThread;
                await Task.Delay(Delay);

                isExecuting = false;
            }

            var thread = new Thread(new ThreadStart(() =>
            {
                callingThread = Thread.CurrentThread;
                command.Execute(null);
            }));

            thread.Start();
            while (isExecuting)
            {
                Thread.Sleep(Delay / 25);
            }

            Assert.False(executingThread.IsThreadPoolThread);
            Assert.False(callingThread.IsThreadPoolThread);
        }
        protected PageViewModelBase(INavigationService navigationService, ITranslationService translationService)
        {
            NavigationService  = navigationService;
            TranslationService = translationService;

            BackCommand = new SafeCommand(() => NavigationService.NavigateBackAsync());
        }
        public void Execute_SecondCallAfterException_Executes()
        {
            SafeExecutionHelpers.RevertToDefaultImplementation();
            var mockHelpers = new Mock <ISafeExecutionHelpers>();

            SafeExecutionHelpers.Implementation = mockHelpers.Object;

            Exception exception = new Exception();

            int times = 0;

            void MockTask(string text)
            {
                if (times++ == 0)
                {
                    throw exception;                     //Throws only on first try
                }
            }

            ICommand command = new SafeCommand <string>(MockTask);

            //Assert.Throws<Exception>(()=>command.Execute("test"));

            //First run
            command.Execute("test");
            mockHelpers.Verify(h => h.HandleException <Exception>(exception, null));

            //Second run
            command.Execute("test");
            Assert.Equal(2, times);

            SafeExecutionHelpers.RevertToDefaultImplementation();
        }
        public SequenceEditorPageViewModel(
            INavigationService navigationService,
            ITranslationService translationService,
            IDialogService dialogService,
            ICreationManager creationManager,
            NavigationParameters parameters) :
            base(navigationService, translationService)
        {
            _dialogService   = dialogService;
            _creationManager = creationManager;

            OriginalSequence = parameters.Get <Sequence>("sequence");

            Sequence = new Sequence
            {
                Name          = OriginalSequence.Name,
                Loop          = OriginalSequence.Loop,
                Interpolate   = OriginalSequence.Interpolate,
                ControlPoints = new ObservableCollection <SequenceControlPoint>(OriginalSequence.ControlPoints.Select(cp => new SequenceControlPoint {
                    Value = cp.Value, DurationMs = cp.DurationMs
                }).ToArray())
            };

            RenameSequenceCommand             = new SafeCommand(async() => await RenameSequenceAsync());
            AddControlPointCommand            = new SafeCommand(() => AddControlPoint());
            DeleteControlPointCommand         = new SafeCommand <SequenceControlPoint>(async(controlPoint) => await DeleteControlPointAsync(controlPoint));
            SaveSequenceCommand               = new SafeCommand(async() => await SaveSequenceAsync(), () => !_dialogService.IsDialogOpen);
            ChangeControlPointDurationCommand = new SafeCommand <SequenceControlPoint>(async(controlPoint) => await ChangeControlPointDurationAsync(controlPoint));
        }
        public void Execute_ParameterIsWrongValueType_ThrowsInvalidCommandParameterException()
        {
            int executions = 0;
            var Command    = new SafeCommand <int>(executeAction: context => executions += 1);

            Assert.Throws <InvalidCommandParameterException>(() => Command.Execute(10.5));
            Assert.True(executions == 0);            // "the Command should not have executed");
        }
        public void Execute_ParameterIsWrongReferenceType_ThrowsInvalidCommandParameterException()
        {
            int executions = 0;
            var Command    = new SafeCommand <FakeChildContext>(executeAction: context => executions += 1);

            Assert.Throws <InvalidCommandParameterException>(() => Command.Execute(new FakeParentContext()));
            Assert.True(executions == 0);             //, "the Command should not have executed");
        }
        public void GenericExecuteWithCanExecute()
        {
            string result = null;
            var    cmd    = new SafeCommand <string>(s => result = s, canExecute: s => true);

            cmd.Execute("Foo");
            Assert.Equal("Foo", result);
        }
        public void Execute_ValueTypeAndSetToNull_ThrowsInvalidCommandParameterException()
        {
            int executions = 0;
            var Command    = new SafeCommand <int>(executeAction: context => executions += 1);

            Assert.Throws <InvalidCommandParameterException>(() => Command.Execute(null));
            Assert.True(executions == 0, "the Command should not have executed");
        }
        public void ExecuteWithCanExecute()
        {
            bool executed = false;
            var  cmd      = new SafeCommand(() => executed = true, canExecute: () => true);

            cmd.Execute(null);
            Assert.True(executed);
        }
示例#19
0
        public void AsyncCommand_Parameter_CanExecuteFalse_Test()
        {
            //Arrange
            SafeCommand <int> command = new SafeCommand <int>(IntParameterTask, canExecute: o => CanExecuteFalse(o));

            //Act

            //Assert
            Assert.False(command.CanExecute(null));
        }
示例#20
0
        public void AsyncCommand_NoParameter_CanExecuteFalse_Test()
        {
            //Arrange
            SafeCommand command = new SafeCommand(NoParameterTask, canExecute: CanExecuteFalse);

            //Act

            //Assert
            Assert.False(command.CanExecute(null));
        }
        public void ChangeCanExecute()
        {
            bool signaled = false;
            var  cmd      = new SafeCommand(() => { });

            cmd.CanExecuteChanged += (sender, args) => signaled = true;

            cmd.RaiseCanExecuteChanged();
            Assert.True(signaled);
        }
示例#22
0
        public void CanExecuteT_NullParameterWithNonNullableValueType_False()
        {
            //Arrange
            SafeCommand <int> command = new SafeCommand <int>(IntParameterTask, canExecute: o => CanExecuteTrue(o));

            //Act

            //Assert

            Assert.False(command.CanExecute(null));
        }
示例#23
0
        public void Execute_WithIBusy_IsBusyTrueWhileRunning()
        {
            var vm = new MockViewModel();

            var command = new SafeCommand(executeAction: () => { Assert.True(vm.IsBusy); }, vm);

            Assert.False(vm.IsBusy);
            command.Execute(null);
            //see Assert in command
            Assert.False(vm.IsBusy);
        }
        public void ExecuteT_WithIViewModelBase_IsBusyTrueWhileRunning(int number)
        {
            var vm = new MockViewModel();

            var command = new SafeCommand <int>(executeAction: (i) => { Assert.True(vm.IsBusy); }, vm);

            Assert.False(vm.IsBusy);
            command.Execute(number);
            //see Assert in command
            Assert.False(vm.IsBusy);
        }
        public void GenericCanExecute(bool expected)
        {
            string result = null;
            var    cmd    = new SafeCommand <string>(s => { }, canExecute: s => {
                result = s;
                return(expected);
            });

            Assert.Equal(expected, cmd.CanExecute("Foo"));
            Assert.Equal("Foo", result);
        }
        public void ExecuteRunsIfReferenceTypeAndSetToNull()
        {
            int executions = 0;
            var Command    = new SafeCommand <FakeChildContext>(context => executions += 1);

            var exception = Record.Exception(() => Command.Execute(null));

            Assert.Null(exception);
            //"null is a valid value for a reference type");
            Assert.True(executions == 1, "the Command should have executed");
        }
        public void Execute_NullableAndSetToNull_Runs()
        {
            int executions = 0;
            var Command    = new SafeCommand <int?>(executeAction: context => executions += 1);

            var exception = Record.Exception(() => Command.Execute(null));

            //"null is a valid value for a Nullable<int> type");
            Assert.Null(exception);
            Assert.True(executions == 1);            // "the Command should have executed");
        }
        public void CanExecute(bool expected)
        {
            bool canExecuteRan = false;
            var  cmd           = new SafeCommand(() => { }, canExecute: () => {
                canExecuteRan = true;
                return(expected);
            });

            Assert.Equal(expected, cmd.CanExecute(null));
            Assert.True(canExecuteRan);
        }
        public void ExecuteParameterized()
        {
            object executed = null;
            var    cmd      = new SafeCommand <object>(executeAction: o => executed = o);

            var expected = new object();

            cmd.Execute(expected);

            Assert.Equal(expected, executed);
        }
示例#30
0
        public void AsyncCommand_ExecuteAsync_StringParameter_Test(string parameter)
        {
            //Arrange
            var      dts     = new DeterministicTaskScheduler();
            ICommand command = new SafeCommand <string>(StringParameterTask, dts, null, null);

            //Act
            command.Execute(parameter);
            dts.RunTasksUntilIdle();

            //Assert
        }