public async void OnNavigatedTo(NavigationParameters parameters)
        {
            App.AppStatus = "ECGsPage";
            App.EventList.Add(Observable.FromEventPattern <PositionEventArgs>(
                                  h => CrossGeolocator.Current.PositionChanged += h, h => CrossGeolocator.Current.PositionChanged -= h)
                              .Subscribe(e => OnPositionChanged(e.Sender, e.EventArgs)));

            // DependencyService.Get<IAudio>().PlayAudioFile("broadcasting.mp3");

            if (parameters.ContainsKey(ParamCalculator))
            {
                _caluculator = parameters[ParamCalculator] as ECOLOGCalculator;
            }
            else
            {
                _caluculator = new ECOLOGCalculator();
                _caluculator.Init();
            }

            _semanticLink = parameters[ParamSemanticLink] as SemanticLink;
            _ecgModel     = ECGModel.GetECGModel(_semanticLink);

            _maximum = new double[]
            {
                _ecgModel.GraphData.Max(v => v.ConvertLoss),
                _ecgModel.GraphData.Max(v => v.AirResistance),
                _ecgModel.GraphData.Max(v => v.RollingResistance),
                _ecgModel.GraphData.Max(v => v.RegeneLoss)
            }.Max();

            PlotModelConvertLoss.Value       = CreatePlotModel("ConvertLoss");
            PlotModelAirResistance.Value     = CreatePlotModel("AirResistance");
            PlotModelRollingResistance.Value = CreatePlotModel("RollingResistance");
            PlotModelRegeneLoss.Value        = CreatePlotModel("RegeneLoss");

            AtentionText.Value = _ecgModel.AtentionText;

            /*** テストコード ***/

            /*var positions = TestPosition.TestPositions;
             * Timer = new ReactiveTimer(TimeSpan.FromMilliseconds(200));
             * Timer.Subscribe(x =>
             * {
             *                  Device.BeginInvokeOnMainThread(() =>
             *                  {
             *                          OnPositionChanged(null, new PositionEventArgs(positions[TestPosition.Index]));
             *                          TestPosition.Index++;
             *                  });
             * });
             *          Timer.Start();*/
            /*** テストコード ***/

            //CrossGeolocator.Current.PositionChanged += OnPositionChanged;
            if (CrossGeolocator.Current.IsListening == false)
            {
                CrossGeolocator.Current.DesiredAccuracy = 1;
                await CrossGeolocator.Current.StartListeningAsync(minimumTime : TimeSpan.FromMilliseconds(1000), minimumDistance : 0, includeHeading : false);
            }
        }
        public EnergyStackPageViewModel()
        {
            PlotModelChorale     = new ReactiveProperty <PlotModel>();
            PlotModelEnergyStack = new ReactiveProperty <PlotModel>();

            PlusCommand = new DelegateCommand(async() =>
            {
                var rootFolder = await FileSystem.Current.GetFolderFromPathAsync(RootFolderPath);
                var file       = await rootFolder.CreateFileAsync($"Plus_{DateTime.Now:yyyy-MM-dd}.txt",
                                                                  CreationCollisionOption.OpenIfExists);
                var writedText = await file.ReadAllTextAsync();
                await file.WriteAllTextAsync(writedText + $"{DateTime.Now},{SemanticLinkPrevious?.SemanticLinkId},{SemanticLinkPrevious?.Semantics}{System.Environment.NewLine}");
            });

            Calculator = new ECOLOGCalculator();
            Calculator.Init();

            App.EventList.Add(Observable.FromEventPattern <PositionEventArgs>(
                                  h => CrossGeolocator.Current.PositionChanged += h,
                                  h => CrossGeolocator.Current.PositionChanged -= h)
                              .Subscribe(e => OnPositionChanged(e.Sender, e.EventArgs)));

            if (CrossGeolocator.Current.IsListening == false)
            {
                CrossGeolocator.Current.DesiredAccuracy = 1;
                CrossGeolocator.Current.StartListeningAsync(minimumTime: TimeSpan.FromMilliseconds(1000), minimumDistance: 0, includeHeading: false);
            }

            LastGeoStr = new ReactiveProperty <string>();

            /*** テストコード ***/

            /*var positions = TestPosition.TestPositions;
             * Timer = new ReactiveTimer(TimeSpan.FromMilliseconds(200));
             * Timer.Subscribe(x =>
             * {
             *  Device.BeginInvokeOnMainThread(() =>
             *  {
             *      OnPositionChanged(null, new PositionEventArgs(positions[TestPosition.Index]));
             *      TestPosition.Index++;
             *      Debug.WriteLine(TestPosition.Index);
             *  });
             * });
             * Timer.Start();*/
            /*** テストコード ***/
        }
Esempio n. 3
0
        public async void OnNavigatedTo(NavigationParameters parameters)
        {
            App.AppStatus = "ResultPage";
            App.EventList.Add(Observable.FromEventPattern <PositionEventArgs>(
                                  h => CrossGeolocator.Current.PositionChanged += h, h => CrossGeolocator.Current.PositionChanged -= h)
                              .Subscribe(e => OnPositionChanged(e.Sender, e.EventArgs)));

            //CrossGeolocator.Current.PositionChanged += OnPositionChanged;
            if (CrossGeolocator.Current.IsListening == false)
            {
                CrossGeolocator.Current.DesiredAccuracy = 1;
                await CrossGeolocator.Current.StartListeningAsync(minimumTime : TimeSpan.FromMilliseconds(1000), minimumDistance : 0, includeHeading : false);
            }

            _calculatorParam = parameters[ParamCalculator] as ECOLOGCalculator;
            _calculatorMine  = new ECOLOGCalculator();
            _calculatorMine.Init();

            _lostEnergy  = _calculatorParam.LostEnergyList.Sum();
            _transitTime = (int)(_calculatorParam.PositionCollection.Last().Timestamp -
                                 _calculatorParam.PositionCollection.First().Timestamp).TotalSeconds;
            var semanticLink = parameters[ParamSemanticLink] as SemanticLink;

            _ecgModel = ECGModel.GetECGModel(semanticLink);

            //DependencyService.Get<IAudio>().PlayAudioFile("broadcasting.mp3");

            /*** デバッグコード ***/

            /*Debug.WriteLine("Count: " + _calculatorParam.PositionCollection.Count);
             * Debug.WriteLine("LostEnergy: " + _calculatorParam.LostEnergyList.Sum());
             * Debug.WriteLine("AirResistance: " + _calculatorParam.AirResistanceList.Sum());
             * Debug.WriteLine("Rolling: " + _calculatorParam.RollingResistanceList.Sum());
             * Debug.WriteLine("Convert: " + _calculatorParam.ConvertLossList.Sum());
             * Debug.WriteLine("Regene: " + _calculatorParam.RegeneLossList.Sum());*/
            /*** デバッグコード ***/

            PlotModel.Value = CreatePlotModel();

            var timer = new ReactiveTimer(TimeSpan.FromSeconds(1));

            timer.Subscribe(v =>
            {
                Device.BeginInvokeOnMainThread(() =>
                {
                    _count++;
                    /*** テストコード ***/
                    //OnPositionChanged(null, new PositionEventArgs(TestPosition.TestPositions[TestPosition.Index]));
                    //TestPosition.Index++;
                    /*** テストコード ***/

                    if (_count >= 10)
                    {
                        timer.Stop();
                        if (_semanticLink != null)
                        {
                            var parameter = new NavigationParameters
                            {
                                { ECGsPageViewModel.ParamCalculator, _calculatorMine },
                                { ECGsPageViewModel.ParamSemanticLink, _semanticLink }
                            };
                            _navigationService.NavigateAsync($"/{nameof(ECGsPage)}", parameter);
                        }
                        else
                        {
                            _navigationService.NavigateAsync($"/{nameof(MapPage)}");
                        }
                    }
                });
            });
            timer.Start();
        }