/// <summary>
        /// Appends count number of tiles to the tile builder.
        /// </summary>
        private static void AppendTrackingDataToTile(TileXMLBuilder tileBuilder, IEnumerable<TrackingData> unorderedTrackingData)
        {
            // Append 15 minutes worth of scheduled tile notifications:
            DateTime time = DateTime.Now;
            tileBuilder.EnableNotificationQueue();

            for (int i = 0; i < 15; i++)
            {
                var orderedTrackingData = (from rtd in unorderedTrackingData
                                           where !rtd.IsNoData && rtd.PredictedArrivalTime > time
                                           orderby rtd.PredictedArrivalInMinutes ascending
                                           select rtd).Take(5).ToList();
                
                foreach (TrackingData trackingData in orderedTrackingData)
                {
                    tileBuilder.AppendTileWithBlockTextAndLines(
                        time,
                        (trackingData.PredictedArrivalTime - time).Minutes.ToString(),
                        trackingData.Status,
                        string.Format("BUS {0}", trackingData.Route.ShortName.ToUpper()),
                        trackingData.TripHeadsign.ToUpper(),
                        trackingData.StopName.ToUpper(),
                        string.Format("{0} / {1}", trackingData.ScheduledArrivalTime.ToString("h:mm"), trackingData.PredictedArrivalTime.ToString("h:mm")));
                }

                time = time.AddMinutes(1);
            }
        }
        /// <summary>
        /// Runs the tile updating service.
        /// </summary>
        public static async Task UpdateTilesAsync()
        {
            try
            {
                // First update the favorites:                
                var favorites = await Model.Favorites.GetAsync();

                // Get the tracking data for favorites & filter it out by the routes:
                List<TrackingData> favoritesRealTimeData = new List<TrackingData>();
                foreach (StopAndRoutePair favorite in favorites)
                {
                    // Get tracking data for this stop:
                    var obaDataAccess = ObaDataAccess.Create();
                    TrackingData[] trackingData = await obaDataAccess.GetTrackingDataForStopAsync(favorite.Stop);

                    // Adds the tracking data to the list:
                    favoritesRealTimeData.AddRange(from data in trackingData
                                                   where string.Equals(favorite.Route, data.RouteId, StringComparison.OrdinalIgnoreCase)
                                                   select data);
                }

                // Now it's time to update the main tile with data:
                TileXMLBuilder mainTileBuilder = new TileXMLBuilder();
                AppendTrackingDataToTile(mainTileBuilder, favoritesRealTimeData);

                // And now we can update the secondary tiles!
                var pinnedStopTiles = await SecondaryTile.FindAllAsync();
                foreach (var pinnedStopTile in pinnedStopTiles)
                {
                    PageInitializationParameters parameters = null;

                    // Be safe and try this first...should never happen.
                    if (PageInitializationParameters.TryCreate(pinnedStopTile.Arguments, out parameters))
                    {
                        double lat = parameters.GetParameter<double>("lat");
                        double lon = parameters.GetParameter<double>("lon");
                        string stopId = parameters.GetParameter<string>("stopId");

                        if (!string.IsNullOrEmpty(stopId) && lat != 0 && lon != 0)
                        {
                            // Get the tracking data:
                            var obaDataAccess = ObaDataAccess.Create(lat, lon);
                            TrackingData[] trackingData = await obaDataAccess.GetTrackingDataForStopAsync(stopId);

                            TileXMLBuilder secondaryTileBuilder = new TileXMLBuilder(pinnedStopTile.TileId);

                            await secondaryTileBuilder.AppendTileWithLargePictureAndTextAsync(
                                    pinnedStopTile.TileId,
                                    lat,
                                    lon,
                                    pinnedStopTile.DisplayName);
                            
                            AppendTrackingDataToTile(secondaryTileBuilder, trackingData);
                        }
                    }
                }
            }
            catch
            {
                // Sometimes OBA will fail. What can you do?
            }
        }
        /// <summary>
        /// Updates a secondary tile.
        /// </summary>
        public async Task UpdateTileAsync(bool added)
        {
            if (added)
            {
                var busStop = this.viewModel.MapControlViewModel.SelectedBusStop;

                TileXMLBuilder builder = new TileXMLBuilder(this.TileId);
                await builder.AppendTileWithLargePictureAndTextAsync(this.TileId,
                    busStop.Latitude,
                    busStop.Longitude,
                    this.TileName);                
            }
        }