示例#1
0
        private void LoadLine(Line line)
        {
            JObject lineObject = lineData[line];

            List <Stop> lineStops = new List <Stop>();

            foreach (JObject stopObject in lineObject["Stops"] as JArray)
            {
                Stop stop = new Stop()
                {
                    Id       = stopObject["Id"].Value <int>(),
                    Name     = stopObject["Name"].Value <string>(),
                    Position = new Position(stopObject["Position"][0].Value <float>(), stopObject["Position"][1].Value <float>()),
                    Line     = line
                };

                lineStops.Add(stop);
            }

            line.Stops = lineStops.ToArray();

            List <Route> lineRoutes = new List <Route>();

            foreach (JObject routeObject in lineObject["Routes"] as JArray)
            {
                Route route = new Route()
                {
                    Id   = routeObject["Id"].Value <int>(),
                    Name = routeObject["Name"].Value <string>(),
                    Line = line
                };

                List <Step> routeSteps = new List <Step>();

                foreach (JObject stepObject in routeObject["Steps"] as JArray)
                {
                    int stopId = stepObject["Stop"].Value <int>();

                    Step step = new Step()
                    {
                        Stop      = line.Stops.First(s => s.Id == stopId),
                        Partial   = stepObject["Partial"].Value <bool>(),
                        Duration  = ParseTimeSpan(stepObject["Duration"].Value <string>()),
                        Direction = stepObject["Direction"].Value <string>(),
                        Speed     = ParseCurve(stepObject["Speed"].Value <string>()),
                        Route     = route
                    };

                    JArray trajectoryArray = stepObject["Trajectory"] as JArray;
                    if (trajectoryArray != null)
                    {
                        List <TrajectoryStep> stepTrajectory = new List <TrajectoryStep>();

                        foreach (JToken positionObject in stepObject["Trajectory"] as JArray)
                        {
                            stepTrajectory.Add(new TrajectoryStep()
                            {
                                Index = positionObject[0].Value <float>(), Position = new Position(positionObject[1][0].Value <float>(), positionObject[1][1].Value <float>())
                            });
                        }

                        step.Trajectory = stepTrajectory.ToArray();
                    }

                    routeSteps.Add(step);
                }

                route.Steps = routeSteps.ToArray();

                JObject timeTableObject = routeObject["TimeTable"] as JObject;
                if (timeTableObject != null)
                {
                    string[]  tableNames = new[] { "Week", "Friday", "Saturday", "Sunday", "Holiday" };
                    TimeTable timeTable  = new TimeTable()
                    {
                        Route = route
                    };

                    foreach (string tableName in tableNames)
                    {
                        JArray tableArray = timeTableObject[tableName] as JArray;
                        if (tableArray == null)
                        {
                            continue;
                        }

                        List <TimeSpan?[]> tableValues = new List <TimeSpan?[]>();
                        foreach (JArray tableLineArray in tableArray.Cast <JArray>())
                        {
                            tableValues.Add(tableLineArray.Select(j => ParseTimeSpan(j.Value <string>())).ToArray());
                        }

                        TimeSpan?[,] table = new TimeSpan?[tableValues.Count, route.Steps.Length];
                        for (int i = 0; i < tableValues.Count; i++)
                        {
                            for (int j = 0; j < route.Steps.Length; j++)
                            {
                                table[i, j] = tableValues[i][j];
                            }
                        }

                        switch (tableName)
                        {
                        case "Week": timeTable.WeekTable = table; break;

                        case "Friday": timeTable.FridayTable = table; break;

                        case "Saturday": timeTable.SaturdayTable = table; break;

                        case "Sunday": timeTable.SundayTable = table; break;

                        case "Holidays": timeTable.HolidaysTable = table; break;
                        }
                    }

                    route.TimeTable = timeTable;
                }

                // Post process each step to build the linked list
                for (int i = 0; i < route.Steps.Length; i++)
                {
                    route.Steps[i].Previous = i > 0 ? route.Steps[i - 1] : null;
                    route.Steps[i].Next     = i < route.Steps.Length - 1 ? route.Steps[i + 1] : null;
                }

                lineRoutes.Add(route);
            }

            line.Routes = lineRoutes.ToArray();
        }
示例#2
0
        public async void Refresh()
        {
            await Task.Run(() =>
            {
                TimeStep[] timeSteps;
                DateTime now = DateTime.Now;

                RunOnUiThread(OnRefreshing);

                // Online time steps
                try
                {
                    if (TramUrWayApplication.Config.OfflineMode)
                    {
                        throw new Exception();
                    }

                    /*timeSteps = App.Service.GetLiveTimeSteps()
                     *  .Where(t => t.Step.Route.Line == line)
                     *  .OrderBy(t => t.Date)
                     *  .ToArray();*/

                    timeSteps = TramUrWayApplication.Service.GetLiveTimeSteps(line)
                                .OrderBy(t => t.Date)
                                .ToArray();

                    snackbar?.Dismiss();
                }
                catch (Exception e)
                {
                    timeSteps = line.Routes.SelectMany(r =>
                    {
                        TimeTable timeTable = r.TimeTable;

                        // Offline data
                        if (timeTable != null)
                        {
                            TimeStep[] routeSteps = r.Steps.SelectMany(s => timeTable.GetStepsFromStep(s, now).Take(3)).ToArray();

                            if (snackbar == null)
                            {
                                snackbar = Snackbar.Make(viewPager, "Données hors-ligne", Snackbar.LengthIndefinite);
                                if (TramUrWayApplication.Config.OfflineMode)
                                {
                                    snackbar = snackbar.SetAction("Activer", Snackbar_Activate);
                                }
                                else
                                {
                                    snackbar = snackbar.SetAction("Réessayer", Snackbar_Retry);
                                }

                                snackbar.Show();
                            }

                            return(routeSteps);
                        }

                        // No data
                        else
                        {
                            if (snackbar == null)
                            {
                                snackbar = Snackbar.Make(viewPager, "Aucune donnée disponible", Snackbar.LengthIndefinite);
                                if (TramUrWayApplication.Config.OfflineMode)
                                {
                                    snackbar = snackbar.SetAction("Activer", Snackbar_Activate);
                                }
                                else
                                {
                                    snackbar = snackbar.SetAction("Réessayer", Snackbar_Retry);
                                }

                                snackbar.Show();
                            }

                            return(Enumerable.Empty <TimeStep>());
                        }
                    }).ToArray();
                }

                // Update transports with new data
                transports.Update(timeSteps, now);

                RunOnUiThread(() => OnRefreshed(timeSteps, transports));
            });
        }