diff --git a/app/src/main/java/it/reyboz/bustorino/fragments/LinesDetailFragment.kt b/app/src/main/java/it/reyboz/bustorino/fragments/LinesDetailFragment.kt
index f6cf0bd..00a8c88 100644
--- a/app/src/main/java/it/reyboz/bustorino/fragments/LinesDetailFragment.kt
+++ b/app/src/main/java/it/reyboz/bustorino/fragments/LinesDetailFragment.kt
@@ -1,1524 +1,1528 @@
 /*
 	BusTO  - Fragments components
     Copyright (C) 2023 Fabio Mazza
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation, either version 3 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 package it.reyboz.bustorino.fragments
 
 
 import android.Manifest
 import android.animation.ObjectAnimator
 import android.animation.ValueAnimator
 import android.annotation.SuppressLint
 import android.content.Context
 import android.content.Intent
 import android.content.SharedPreferences
 import android.location.Location
 import android.net.Uri
 import android.os.Bundle
 import android.util.Log
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import android.view.animation.LinearInterpolator
 import android.widget.*
 import androidx.activity.result.ActivityResultCallback
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.content.res.AppCompatResources
 import androidx.cardview.widget.CardView
 import androidx.core.content.ContextCompat
 import androidx.core.content.res.ResourcesCompat
 import androidx.fragment.app.viewModels
 import androidx.preference.PreferenceManager
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 import com.google.android.material.bottomsheet.BottomSheetBehavior
 import com.google.gson.JsonObject
 import it.reyboz.bustorino.R
 import it.reyboz.bustorino.adapters.NameCapitalize
 import it.reyboz.bustorino.adapters.StopAdapterListener
 import it.reyboz.bustorino.adapters.StopRecyclerAdapter
 import it.reyboz.bustorino.backend.FiveTNormalizer
 import it.reyboz.bustorino.backend.LivePositionTripPattern
 import it.reyboz.bustorino.backend.Stop
 import it.reyboz.bustorino.backend.gtfs.GtfsUtils
 import it.reyboz.bustorino.backend.gtfs.LivePositionUpdate
 import it.reyboz.bustorino.backend.gtfs.PolylineParser
 import it.reyboz.bustorino.backend.utils
 import it.reyboz.bustorino.data.MatoTripsDownloadWorker
 import it.reyboz.bustorino.data.PreferencesHolder
 import it.reyboz.bustorino.data.gtfs.MatoPatternWithStops
 import it.reyboz.bustorino.data.gtfs.TripAndPatternWithStops
 import it.reyboz.bustorino.map.*
 import it.reyboz.bustorino.middleware.LocationUtils
 import it.reyboz.bustorino.util.Permissions
 import it.reyboz.bustorino.util.ViewUtils
 import it.reyboz.bustorino.viewmodels.LinesViewModel
 import it.reyboz.bustorino.viewmodels.LivePositionsViewModel
 import kotlinx.coroutines.Runnable
 import org.maplibre.android.camera.CameraPosition
 import org.maplibre.android.camera.CameraUpdateFactory
 import org.maplibre.android.geometry.LatLng
 import org.maplibre.android.geometry.LatLngBounds
 import org.maplibre.android.location.LocationComponent
 import org.maplibre.android.location.LocationComponentOptions
 import org.maplibre.android.maps.MapLibreMap
 import org.maplibre.android.maps.Style
 import org.maplibre.android.plugins.annotation.Symbol
 import org.maplibre.android.plugins.annotation.SymbolManager
 import org.maplibre.android.plugins.annotation.SymbolOptions
 import org.maplibre.android.style.expressions.Expression
 import org.maplibre.android.style.layers.LineLayer
 import org.maplibre.android.style.layers.Property
 import org.maplibre.android.style.layers.Property.ICON_ANCHOR_CENTER
 import org.maplibre.android.style.layers.Property.ICON_ROTATION_ALIGNMENT_MAP
 import org.maplibre.android.style.layers.PropertyFactory
 import org.maplibre.android.style.layers.SymbolLayer
 import org.maplibre.android.style.sources.GeoJsonSource
 import org.maplibre.geojson.Feature
 import org.maplibre.geojson.FeatureCollection
 import org.maplibre.geojson.LineString
 import org.maplibre.geojson.Point
 import java.util.concurrent.atomic.AtomicBoolean
 
 
 class LinesDetailFragment() : GeneralMapLibreFragment() {
 
     private var lineID = ""
     private lateinit var patternsSpinner: Spinner
     private var patternsAdapter: ArrayAdapter<String>? = null
 
     //Bottom sheet behavior
     private lateinit var bottomSheetBehavior: BottomSheetBehavior<RelativeLayout>
     private var bottomLayout: RelativeLayout? = null
     private lateinit var stopTitleTextView: TextView
     private lateinit var stopNumberTextView: TextView
     private lateinit var linesPassingTextView: TextView
     private lateinit var arrivalsCard: CardView
     private lateinit var directionsCard: CardView
     private lateinit var bottomrightImage: ImageView
 
     private var isBottomSheetShowing = false
     private var shouldMapLocationBeReactivated = true
 
     private var toRunWhenMapReady : Runnable? = null
     private var mapInitialized = AtomicBoolean(false)
 
     //private var patternsSpinnerState: Parcelable? = null
 
     private lateinit var currentPatterns: List<MatoPatternWithStops>
 
     //private lateinit var map: MapView
     private var patternShown: MatoPatternWithStops? = null
 
     private val viewModel: LinesViewModel by viewModels()
     private val mapViewModel: MapViewModel by viewModels()
     private var firstInit = true
     private var pausedFragment = false
     private lateinit var switchButton: ImageButton
 
     private var favoritesButton: ImageButton? = null
     private var locationIcon: ImageButton? = null
     private var isLineInFavorite = false
     private var appContext: Context? = null
     private var isLocationPermissionOK = false
     private val lineSharedPrefMonitor = SharedPreferences.OnSharedPreferenceChangeListener { pref, keychanged ->
         if(keychanged!=PreferencesHolder.PREF_FAVORITE_LINES || lineID.isEmpty()) return@OnSharedPreferenceChangeListener
         val newFavorites = pref.getStringSet(PreferencesHolder.PREF_FAVORITE_LINES, HashSet())
         newFavorites?.let {favorites->
             isLineInFavorite = favorites.contains(lineID)
             //if the button has been intialized, change the icon accordingly
             favoritesButton?.let { button->
                 //avoid crashes if fragment not attached
                 if(context==null) return@let
                 if(isLineInFavorite) {
                     button.setImageDrawable(ResourcesCompat.getDrawable(resources, R.drawable.ic_star_filled, null))
                     appContext?.let {  Toast.makeText(it,R.string.favorites_line_add,Toast.LENGTH_SHORT).show()}
                 } else {
                     button.setImageDrawable(ResourcesCompat.getDrawable(resources, R.drawable.ic_star_outline, null))
                     appContext?.let {Toast.makeText(it,R.string.favorites_line_remove,Toast.LENGTH_SHORT).show()}
                 }
 
 
             }
         }
     }
 
     private lateinit var stopsRecyclerView: RecyclerView
     private lateinit var descripTextView: TextView
     private var stopIDFromToShow: String? = null
     //adapter for recyclerView
     private val stopAdapterListener= object : StopAdapterListener {
         override fun onTappedStop(stop: Stop?) {
 
             if(viewModel.shouldShowMessage) {
                 Toast.makeText(context, R.string.long_press_stop_4_options, Toast.LENGTH_SHORT).show()
                 viewModel.shouldShowMessage=false
             }
             stop?.let {
                 fragmentListener.requestArrivalsForStopID(it.ID)
             }
             if(stop == null){
                 Log.e(DEBUG_TAG,"Passed wrong stop")
             }
             if(fragmentListener == null){
                 Log.e(DEBUG_TAG, "Fragment listener is null")
             }
         }
 
         override fun onLongPressOnStop(stop: Stop?): Boolean {
             TODO("Not yet implemented")
         }
 
     }
     private val patternsSorter = Comparator{ p1: MatoPatternWithStops, p2: MatoPatternWithStops ->
         if(p1.pattern.directionId != p2.pattern.directionId)
             return@Comparator p1.pattern.directionId - p2.pattern.directionId
         else
             return@Comparator -1*(p1.stopsIndices.size - p2.stopsIndices.size)
 
     }
 
     //map data
     //style and sources are in GeneralMapLibreFragment
     private lateinit var locationComponent: LocationComponent
     private lateinit var polylineSource: GeoJsonSource
     private lateinit var polyArrowSource: GeoJsonSource
 
     private var savedCameraPosition: CameraPosition? = null
     private var vehShowing = ""
 
     private var stopsLayerStarted = false
     private var lastStopsSizeShown = 0
     private var lastUpdateTime:Long = -2
 
     //BUS POSITIONS
     private val updatesByVehDict = HashMap<String, LivePositionTripPattern>(5)
     private val animatorsByVeh = HashMap<String, ValueAnimator>()
 
     private var lastLocation : Location? = null
     private var enablingPositionFromClick = false
 
     private var polyline: LineString? = null
 
     private val showUserPositionRequestLauncher =
         registerForActivityResult(
             ActivityResultContracts.RequestMultiplePermissions(),
             ActivityResultCallback { result ->
                 if (result == null) {
                     Log.w(DEBUG_TAG, "Got asked permission but request is null, doing nothing?")
                 } else if (java.lang.Boolean.TRUE == result[Manifest.permission.ACCESS_COARSE_LOCATION]
                     && java.lang.Boolean.TRUE == result[Manifest.permission.ACCESS_FINE_LOCATION]) {
                     // We can use the position, restart location overlay
                     if (context == null || requireContext().getSystemService(Context.LOCATION_SERVICE) == null)
                         return@ActivityResultCallback ///@registerForActivityResult
                     setMapUserLocationEnabled(true, true, enablingPositionFromClick)
                 } else Log.w(DEBUG_TAG, "No location permission")
             })
     //private var stopPosList = ArrayList<GeoPoint>()
 
     //fragment actions
     private lateinit var fragmentListener: CommonFragmentListener
 
     private var showOnTopOfLine = false
     private var recyclerInitDone = false
 
     private var useMQTTPositions = true
 
 
 
     //position of live markers
 
     private val tripMarkersAnimators = HashMap<String, ObjectAnimator>()
 
     private val liveBusViewModel: LivePositionsViewModel by viewModels()
 
     //extra items to use the LibreMap
     private lateinit var symbolManager : SymbolManager
     private var stopActiveSymbol: Symbol? = null
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         val args = requireArguments()
         lineID = args.getString(LINEID_KEY,"")
         stopIDFromToShow = args.getString(STOPID_FROM_KEY)
     }
 
     @SuppressLint("SetTextI18n")
     override fun onCreateView(
         inflater: LayoutInflater, container: ViewGroup?,
         savedInstanceState: Bundle?
     ): View? {
         //reset statuses
         isBottomSheetShowing = false
         //stopsLayerStarted = false
         lastStopsSizeShown = 0
         mapInitialized.set(false)
 
         val rootView = inflater.inflate(R.layout.fragment_lines_detail, container, false)
         //lineID = requireArguments().getString(LINEID_KEY, "")
         arguments?.let {
             lineID = it.getString(LINEID_KEY, "")
         }
         switchButton = rootView.findViewById(R.id.switchImageButton)
         locationIcon = rootView.findViewById(R.id.locationEnableIcon)
         favoritesButton = rootView.findViewById(R.id.favoritesButton)
         stopsRecyclerView = rootView.findViewById(R.id.patternStopsRecyclerView)
         descripTextView = rootView.findViewById(R.id.lineDescripTextView)
         descripTextView.visibility = View.INVISIBLE
 
         //map stuff
         mapView = rootView.findViewById(R.id.lineMap)
         mapView.getMapAsync(this)
 
 
         //init bottom sheet
         val bottomSheet = rootView.findViewById<RelativeLayout>(R.id.bottom_sheet)
         bottomLayout = bottomSheet
         stopTitleTextView = bottomSheet.findViewById(R.id.stopTitleTextView)
         stopNumberTextView = bottomSheet.findViewById(R.id.stopNumberTextView)
         linesPassingTextView = bottomSheet.findViewById(R.id.linesPassingTextView)
         arrivalsCard = bottomSheet.findViewById(R.id.arrivalsCardButton)
         directionsCard = bottomSheet.findViewById(R.id.directionsCardButton)
         bottomrightImage = bottomSheet.findViewById(R.id.rightmostImageView)
         bottomSheetBehavior = BottomSheetBehavior.from(bottomSheet)
 
         // Setup close button
         rootView.findViewById<View>(R.id.btnClose).setOnClickListener {
             hideStopBottomSheet()
         }
 
         val titleTextView = rootView.findViewById<TextView>(R.id.titleTextView)
         titleTextView.text = getString(R.string.line)+" "+FiveTNormalizer.fixShortNameForDisplay(
             GtfsUtils.getLineNameFromGtfsID(lineID), true)
 
         favoritesButton?.isClickable = true
         favoritesButton?.setOnClickListener {
             if(lineID.isNotEmpty())
                 PreferencesHolder.addOrRemoveLineToFavorites(requireContext(),lineID,!isLineInFavorite)
         }
         val preferences = PreferencesHolder.getMainSharedPreferences(requireContext())
         val favorites = preferences.getStringSet(PreferencesHolder.PREF_FAVORITE_LINES, HashSet())
         if(favorites!=null && favorites.contains(lineID)){
             favoritesButton?.setImageDrawable(ResourcesCompat.getDrawable(resources, R.drawable.ic_star_filled, null))
             isLineInFavorite = true
         }
         appContext = requireContext().applicationContext
         preferences.registerOnSharedPreferenceChangeListener(lineSharedPrefMonitor)
 
         patternsSpinner = rootView.findViewById(R.id.patternsSpinner)
         patternsAdapter = ArrayAdapter(requireContext(), android.R.layout.simple_spinner_dropdown_item, ArrayList<String>())
         patternsSpinner.adapter = patternsAdapter
 
 
         initializeRecyclerView()
 
         switchButton.setOnClickListener{
             if(mapView.visibility == View.VISIBLE){
                 hideMapAndShowStopList()
             } else{
                hideStopListAndShowMap()
             }
         }
         locationIcon?.let {view ->
             if(!LocationUtils.isLocationEnabled(requireContext()) || !Permissions.anyLocationPermissionsGranted(requireContext()))
                 setLocationIconEnabled(false)
             //set click Listener
             view.setOnClickListener(this::onPositionIconButtonClick)
         }
         //set
         //INITIALIZE VIEW MODELS
         viewModel.setRouteIDQuery(lineID)
         liveBusViewModel.setGtfsLineToFilterPos(lineID, null)
 
         val keySourcePositions = getString(R.string.pref_positions_source)
         useMQTTPositions = PreferenceManager.getDefaultSharedPreferences(requireContext())
             .getString(keySourcePositions, "mqtt").contentEquals("mqtt")
 
         viewModel.patternsWithStopsByRouteLiveData.observe(viewLifecycleOwner){
             patterns -> savePatternsToShow(patterns)
         }
         /*
          */
         viewModel.stopsForPatternLiveData.observe(viewLifecycleOwner) { stops ->
             if(mapView.visibility ==View.VISIBLE)
                 patternShown?.let{
                     // We have the pattern and the stops here, time to display them
                     displayPatternWithStopsOnMap(it,stops, true)
                 } ?:{
                     Log.w(DEBUG_TAG, "The viewingPattern is null!")
                 }
             else{
                 if(stopsRecyclerView.visibility==View.VISIBLE)
                     showStopsInRecyclerView(stops)
             }
         }
         viewModel.gtfsRoute.observe(viewLifecycleOwner){route->
             if(route == null){
                 //need to close the fragment
                 activity?.supportFragmentManager?.popBackStack()
                 return@observe
             }
              descripTextView.text = route.longName
             descripTextView.visibility = View.VISIBLE
         }
         /*
 
          */
 
         Log.d(DEBUG_TAG,"Data ${viewModel.stopsForPatternLiveData.value}")
 
         //listeners
         patternsSpinner.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
             override fun onItemSelected(p0: AdapterView<*>?, p1: View?, position: Int, p3: Long) {
                 val currentShownPattern = patternShown?.pattern
                 val patternWithStops = currentPatterns[position]
 
                 Log.d(DEBUG_TAG, "request stops for pattern ${patternWithStops.pattern.code}")
                 setPatternAndReqStops(patternWithStops)
 
                 if(mapView.visibility == View.VISIBLE) {
                     //Clear buses if we are changing direction
                     currentShownPattern?.let { patt ->
                         if(patt.directionId != patternWithStops.pattern.directionId){
                             stopAnimations()
                             updatesByVehDict.clear()
                             updatePositionsIcons(true)
                             liveBusViewModel.retriggerPositionUpdate()
                         }
                     }
                 }
                 liveBusViewModel.setGtfsLineToFilterPos(lineID, patternWithStops.pattern)
 
             }
 
             override fun onNothingSelected(p0: AdapterView<*>?) {
             }
         }
         Log.d(DEBUG_TAG, "Views created!")
 
         return rootView
     }
 
     // ------------- UI switch stuff ---------
 
     private fun hideMapAndShowStopList(){
         mapView.visibility = View.GONE
         stopsRecyclerView.visibility = View.VISIBLE
         locationIcon?.visibility = View.GONE
 
         viewModel.setMapShowing(false)
         if(useMQTTPositions) liveBusViewModel.stopMatoUpdates()
         //map.overlayManager.remove(busPositionsOverlay)
 
         switchButton.setImageDrawable(AppCompatResources.getDrawable(requireContext(), R.drawable.ic_map_white_30))
 
         hideStopBottomSheet()
 
         if(locationComponent.isLocationComponentEnabled){
             locationComponent.isLocationComponentEnabled = false
             shouldMapLocationBeReactivated = true
         } else
             shouldMapLocationBeReactivated = false
     }
 
     private fun hideStopListAndShowMap(){
         stopsRecyclerView.visibility = View.GONE
         mapView.visibility = View.VISIBLE
         locationIcon?.visibility = View.VISIBLE
         viewModel.setMapShowing(true)
 
         //map.overlayManager.add(busPositionsOverlay)
         //map.
         if(useMQTTPositions)
             liveBusViewModel.requestMatoPosUpdates(GtfsUtils.getLineNameFromGtfsID(lineID))
         else
             liveBusViewModel.requestGTFSUpdates()
 
         switchButton.setImageDrawable(AppCompatResources.getDrawable(requireContext(), R.drawable.ic_list_30))
 
         if(shouldMapLocationBeReactivated && Permissions.bothLocationPermissionsGranted(requireContext())){
             locationComponent.isLocationComponentEnabled = true
         }
     }
 
     private fun setLocationIconEnabled(setTrue: Boolean){
         if(setTrue)
             locationIcon?.setImageDrawable(ContextCompat.getDrawable(requireContext(), R.drawable.location_circlew_red))
         else
             locationIcon?.setImageDrawable(ContextCompat.getDrawable(requireContext(), R.drawable.location_circlew_grey))
     }
 
     /**
      * Handles logic of enabling the user location on the map
      */
     @SuppressLint("MissingPermission")
     private fun setMapUserLocationEnabled(enabled: Boolean, assumePermissions: Boolean, fromClick: Boolean) {
         if (enabled) {
             val permissionOk = assumePermissions || Permissions.bothLocationPermissionsGranted(requireContext())
 
             if (permissionOk) {
                 Log.d(DEBUG_TAG, "Permission OK, starting location component, assumed: $assumePermissions")
                 locationComponent.isLocationComponentEnabled = true
                 //locationComponent.cameraMode = CameraMode.TRACKING //CameraMode.TRACKING
 
                 setLocationIconEnabled(true)
                 if (fromClick) Toast.makeText(context, R.string.location_enabled, Toast.LENGTH_SHORT).show()
             } else {
                 if (shouldShowRequestPermissionRationale(Manifest.permission.ACCESS_FINE_LOCATION)) {
                     //TODO: show dialog for permission rationale
                     Toast.makeText(activity, R.string.enable_position_message_map, Toast.LENGTH_SHORT).show()
                 }
                 Log.d(DEBUG_TAG, "Requesting permission to show user location")
                 enablingPositionFromClick = fromClick
                 showUserPositionRequestLauncher.launch(Permissions.LOCATION_PERMISSIONS)
             }
         } else{
             locationComponent.isLocationComponentEnabled = false
             setLocationIconEnabled(false)
             if (fromClick) {
                 Toast.makeText(requireContext(), R.string.location_disabled, Toast.LENGTH_SHORT).show()
                  //TODO: Cancel the request for the enablement of the position if needed
             }
         }
 
     }
 
     /**
      * Switch position icon from activ
      */
     private fun onPositionIconButtonClick(view: View){
         if(locationComponent.isLocationComponentEnabled) setMapUserLocationEnabled(false, false, true)
         else{
             setMapUserLocationEnabled(true, false, true)
         }
     }
 
     // ------------- Map Code -------------------------
     /**
      * This method sets up the map and the layers
      */
     override fun onMapReady(mapReady: MapLibreMap) {
         this.map = mapReady
 
         val context = requireContext()
         val mjson = Styles.getJsonStyleFromAsset(context, PreferencesHolder.getMapLibreStyleFile(context))        //ViewUtils.loadJsonFromAsset(requireContext(),"map_style_good.json")
 
         activity?.run {
             val builder = Style.Builder().fromJson(mjson!!)
 
             mapReady.setStyle(builder) { style ->
 
                 mapStyle = style
                 //setupLayers(style)
 
                 symbolManager = SymbolManager(mapView,mapReady,style)
                 symbolManager.iconAllowOverlap = true
                 symbolManager.textAllowOverlap = false
 
                 symbolManager.addClickListener{ _ ->
                     if (stopActiveSymbol!=null){
                         hideStopBottomSheet()
 
                         return@addClickListener true
                     } else
                         return@addClickListener false
                 }
 
                 // Start observing data
                 initMapUserLocation(style, mapReady, requireContext())
 
                 //if(!stopsLayerStarted)
                  initStopsPolyLineLayers(style, FeatureCollection.fromFeatures(ArrayList<Feature>()), null, null)
                 if(patternShown!=null){
                     viewModel.stopsForPatternLiveData.value?.let {
                         Log.d(DEBUG_TAG, "Show stops from the cache")
                         displayPatternWithStopsOnMap(patternShown!!, it, true)
                     }
                 }
                 /*if(!stopsLayerStarted) {
                     Log.d(DEBUG_TAG, "Stop layer is not started yet")
                     initStopsPolyLineLayers(style, FeatureCollection.fromFeatures(ArrayList<Feature>()), null)
                 }
 
                  */
 
 
                 setupBusLayer(style)
 
                 mapViewModel.stopShowing?.let {
                     openStopInBottomSheet(it)
                 }
                 mapViewModel.stopShowing = null
                 toRunWhenMapReady?.run()
                 toRunWhenMapReady = null
                 mapInitialized.set(true)
 
             }
 
             mapReady.addOnMapClickListener { point ->
                 val screenPoint = mapReady.projection.toScreenLocation(point)
                 val features = mapReady.queryRenderedFeatures(screenPoint, STOPS_LAYER_ID)
                 val busNearby = mapReady.queryRenderedFeatures(screenPoint, BUSES_LAYER_ID)
                 if (features.isNotEmpty()) {
                     val feature = features[0]
                     val id = feature.getStringProperty("id")
                     val name = feature.getStringProperty("name")
                     //Toast.makeText(requireContext(), "Clicked on $name ($id)", Toast.LENGTH_SHORT).show()
                     val stop = viewModel.getStopByID(id)
                     stop?.let {
                         if (isBottomSheetShowing){
                             hideStopBottomSheet()
                         }
                         openStopInBottomSheet(it)
                         isBottomSheetShowing = true
                         //move camera
                         if(it.latitude!=null && it.longitude!=null)
                             mapReady.animateCamera(CameraUpdateFactory.newLatLng(LatLng(it.latitude!!,it.longitude!!)),750)
                     }
                     return@addOnMapClickListener true
                 } else if (busNearby.isNotEmpty()){
                     val feature = busNearby[0]
                     val vehid = feature.getStringProperty("veh")
                     val route = feature.getStringProperty("line")
                     if(isBottomSheetShowing && shownStopInBottomSheet!=null)
                         hideStopBottomSheet()
                     //if(context!=null){
                      //   Toast.makeText(context, "Veh $vehid on route ${route.slice(0..route.length-2)}", Toast.LENGTH_SHORT).show()
                     //}
                     showVehicleTripInBottomSheet(vehid)
                     updatesByVehDict[vehid]?.let {
                         //if (it.posUpdate.latitude != null && it.longitude != null)
                             mapReady.animateCamera(
                                 CameraUpdateFactory.newLatLng(LatLng(it.posUpdate.latitude, it.posUpdate.longitude)),
                                 750
                             )
                     }
 
                     return@addOnMapClickListener true
                 }
                 false
             }
 
             // we start requesting the bus positions now
             observeBusPositionUpdates()
 
         }
         /*savedMapStateOnPause?.let{
             restoreMapStateFromBundle(it)
             pendingLocationActivation = false
             Log.d(DEBUG_TAG, "Restored map state from the saved bundle")
         }
 
          */
 
         val zoom = 12.0
         val latlngTarget = LatLng(MapLibreFragment.DEFAULT_CENTER_LAT, MapLibreFragment.DEFAULT_CENTER_LON)
 
         mapReady.cameraPosition = savedCameraPosition ?:CameraPosition.Builder().target(latlngTarget).zoom(zoom).build()
 
         savedCameraPosition = null
 
         if(shouldMapLocationBeReactivated) setMapUserLocationEnabled(true, false, false)
     }
 
     private fun observeBusPositionUpdates(){
         //live bus positions
         liveBusViewModel.filteredLocationUpdates.observe(viewLifecycleOwner){ updates ->
             //Log.d(DEBUG_TAG, "Received ${updates.size} updates for the positions")
 
             if(mapView.visibility == View.GONE || patternShown ==null){
                 //DO NOTHING
                 Log.w(DEBUG_TAG, "not doing anything because map is not visible")
                 return@observe
             }
             updateBusPositionsInMap(updates)
             //if not using MQTT positions
             if(!useMQTTPositions){
                 liveBusViewModel.requestDelayedGTFSUpdates(2000)
             }
         }
 
         //download missing tripIDs
         liveBusViewModel.tripsGtfsIDsToQuery.observe(viewLifecycleOwner){
             //gtfsPosViewModel.downloadTripsFromMato(dat);
             MatoTripsDownloadWorker.requestMatoTripsDownload(
                 it, requireContext().applicationContext,
                 "BusTO-MatoTripDownload"
             )
         }
     }
 
     /**
      * Initialize the map location, but do not enable the component
      */
     @SuppressLint("MissingPermission")
     private fun initMapUserLocation(style: Style, map: MapLibreMap, context: Context){
         locationComponent = map.locationComponent
         val locationComponentOptions =
             LocationComponentOptions.builder(context)
                 .pulseEnabled(false)
                 .build()
         val locationComponentActivationOptions =
             MapLibreUtils.buildLocationComponentActivationOptions(style, locationComponentOptions, context)
         locationComponent.activateLocationComponent(locationComponentActivationOptions)
         locationComponent.isLocationComponentEnabled = false
 
         lastLocation?.let {
             if (it.accuracy < 200)
                 locationComponent.forceLocationUpdate(it)
         }
     }
     /**
      * Update the bottom sheet with the stop information
      */
     override fun openStopInBottomSheet(stop: Stop){
         bottomLayout?.let {
 
             //lay.findViewById<TextView>(R.id.stopTitleTextView).text ="${stop.ID} - ${stop.stopDefaultName}"
             val stopName = stop.stopUserName ?: stop.stopDefaultName
             stopTitleTextView.text = stopName//stop.stopDefaultName
             stopNumberTextView.text = stop.ID
             stopTitleTextView.visibility = View.VISIBLE
 
             val string_show = if (stop.numRoutesStopping==0) ""
             else if (stop.numRoutesStopping <= 1)
                 requireContext().getString(R.string.line_fill, stop.routesThatStopHereToString())
             else requireContext().getString(R.string.lines_fill, stop.routesThatStopHereToString())
             linesPassingTextView.text = string_show
 
             //SET ON CLICK LISTENER
             arrivalsCard.setOnClickListener{
                 fragmentListener?.requestArrivalsForStopID(stop.ID)
             }
             arrivalsCard.visibility = View.VISIBLE
             directionsCard.setOnClickListener {
                 ViewUtils.openStopInOutsideApp(stop, context)
             }
             bottomrightImage.setImageDrawable(ResourcesCompat.getDrawable(resources, R.drawable.navigation_right,  activity?.theme))
 
         }
         //add stop marker
         if (stop.latitude!=null && stop.longitude!=null) {
             stopActiveSymbol = symbolManager.create(
                 SymbolOptions()
                     .withLatLng(LatLng(stop.latitude!!, stop.longitude!!))
                     .withIconImage(STOP_ACTIVE_IMG)
                     .withIconAnchor(ICON_ANCHOR_CENTER)
 
             )
 
         }
         shownStopInBottomSheet = stop
 
         bottomSheetBehavior.state = BottomSheetBehavior.STATE_EXPANDED
     }
     // Hide the bottom sheet and remove extra symbol
     private fun hideStopBottomSheet(){
         if (stopActiveSymbol!=null){
             symbolManager.delete(stopActiveSymbol)
             stopActiveSymbol = null
         }
         bottomSheetBehavior.state = BottomSheetBehavior.STATE_HIDDEN
         isBottomSheetShowing = false
         //remove initial stop
         //if(initialStopToShow!=null){
         //    initialStopToShow = null
         //}
 
         shownStopInBottomSheet = null
         vehShowing = ""
     }
 
     private fun showVehicleTripInBottomSheet(veh: String){
         val data = updatesByVehDict[veh]
         if(data==null) return
 
         bottomLayout?.let {
             val lineName = FiveTNormalizer.fixShortNameForDisplay(
                 GtfsUtils.getLineNameFromGtfsID(data.posUpdate.routeID), true)
             stopNumberTextView.text = requireContext().getString(R.string.line_fill, lineName)
             data.pattern?.let { pat ->
                 stopTitleTextView.text = pat.headsign
                 stopTitleTextView.visibility = View.VISIBLE
             } ?:{
                 stopTitleTextView.visibility = View.GONE
             }
             linesPassingTextView.text = data.posUpdate.vehicle
         }
         arrivalsCard.visibility=View.GONE
         bottomrightImage.setImageDrawable(ResourcesCompat.getDrawable(resources, R.drawable.ic_magnifying_glass,  activity?.theme))
         directionsCard.setOnClickListener {
             data.pattern?.let {
-                showPatternWithCode(it.code)
+
+                if(patternShown?.pattern?.code == it.code){
+                    context?.let { c->Toast.makeText(c, R.string.showing_same_direction, Toast.LENGTH_SHORT).show() }
+                }else
+                    showPatternWithCode(it.code)
             } //TODO
             // ?: {
             //    context?.let { ctx -> Toast.makeText(ctx,"") }
             //}
         }
         vehShowing = veh
         bottomSheetBehavior.state = BottomSheetBehavior.STATE_EXPANDED
 
     }
 
     // ------- MAP LAYERS INITIALIZE ----
     /**
      * Initialize the map layers for the stops
      */
     private fun initStopsPolyLineLayers(style: Style, stopFeatures:FeatureCollection, lineFeature: Feature?, arrowFeatures: FeatureCollection?){
 
         Log.d(DEBUG_TAG, "INIT STOPS CALLED")
         stopsSource = GeoJsonSource(STOPS_SOURCE_ID)
         style.addSource(stopsSource)
         //val context = requireContext()
         val stopIcon = ResourcesCompat.getDrawable(resources,R.drawable.ball, activity?.theme)!!
 
         val imgStop =  ResourcesCompat.getDrawable(resources,R.drawable.bus_stop_new, activity?.theme)!!
         val polyIconArrow = ResourcesCompat.getDrawable(resources, R.drawable.arrow_up_box_fill, activity?.theme)!!
         //set the image tint
         //DrawableCompat.setTint(imgBus,ContextCompat.getColor(context,R.color.line_drawn_poly))
 
         // add icon
         style.addImage(STOP_IMAGE_ID,stopIcon)
         style.addImage(POLY_ARROW, polyIconArrow)
         style.addImage(STOP_ACTIVE_IMG, ResourcesCompat.getDrawable(resources, R.drawable.bus_stop_new_highlight, activity?.theme)!!)
         // Stops layer
         val stopsLayer = SymbolLayer(STOPS_LAYER_ID, STOPS_SOURCE_ID)
         stopsLayer.withProperties(
             PropertyFactory.iconImage(STOP_IMAGE_ID),
             PropertyFactory.iconAllowOverlap(true),
             PropertyFactory.iconIgnorePlacement(true)
         )
 
         polylineSource = GeoJsonSource(POLYLINE_SOURCE) //lineFeature?.let { GeoJsonSource(POLYLINE_SOURCE, it) } ?: GeoJsonSource(POLYLINE_SOURCE)
         style.addSource(polylineSource)
 
         val color=ContextCompat.getColor(requireContext(),R.color.line_drawn_poly)
         //paint.style = Paint.Style.FILL_AND_STROKE
         //paint.strokeJoin = Paint.Join.ROUND
         //paint.strokeCap = Paint.Cap.ROUND
 
         val lineLayer = LineLayer(POLYLINE_LAYER, POLYLINE_SOURCE).withProperties(
             PropertyFactory.lineColor(color),
             PropertyFactory.lineWidth(5.0f), //originally 13f
             PropertyFactory.lineOpacity(1.0f),
             PropertyFactory.lineJoin(Property.LINE_JOIN_ROUND),
             PropertyFactory.lineCap(Property.LINE_CAP_ROUND)
 
         )
         polyArrowSource = GeoJsonSource(POLY_ARROWS_SOURCE, arrowFeatures)
         style.addSource(polyArrowSource)
         val arrowsLayer = SymbolLayer(POLY_ARROWS_LAYER, POLY_ARROWS_SOURCE).withProperties(
             PropertyFactory.iconImage(POLY_ARROW),
             PropertyFactory.iconRotate(Expression.get("bearing")),
             PropertyFactory.iconRotationAlignment(ICON_ROTATION_ALIGNMENT_MAP)
         )
 
         val layers = style.layers
         val lastLayers = layers.filter { l-> l.id.contains("city") }
         //Log.d(DEBUG_TAG,"Layers:\n ${style.layers.map { l -> l.id }}")
         Log.d(DEBUG_TAG, "City layers: ${lastLayers.map { l-> l.id }}")
         if(lastLayers.isNotEmpty())
             style.addLayerAbove(lineLayer,lastLayers[0].id)
         else
             style.addLayerBelow(lineLayer,"label_country_1")
         style.addLayerAbove(stopsLayer, POLYLINE_LAYER)
         style.addLayerAbove(arrowsLayer, POLYLINE_LAYER)
 
         stopsLayerStarted = true
     }
 
 
     /**
      * Setup the Map Layers
      */
     private fun setupBusLayer(style: Style) {
         // Buses source
         busesSource = GeoJsonSource(BUSES_SOURCE_ID)
         style.addSource(busesSource)
         style.addImage("bus_symbol",ResourcesCompat.getDrawable(resources, R.drawable.map_bus_position_icon, activity?.theme)!!)
 
         // Buses layer
         val busesLayer = SymbolLayer(BUSES_LAYER_ID, BUSES_SOURCE_ID).apply {
             withProperties(
                 PropertyFactory.iconImage("bus_symbol"),
                 //PropertyFactory.iconSize(1.2f),
                 PropertyFactory.iconAllowOverlap(true),
                 PropertyFactory.iconIgnorePlacement(true),
                 PropertyFactory.iconRotate(Expression.get("bearing")),
                 PropertyFactory.iconRotationAlignment(ICON_ROTATION_ALIGNMENT_MAP)
 
             )
         }
         style.addLayerAbove(busesLayer, STOPS_LAYER_ID)
 
     }
 
     override fun onAttach(context: Context) {
         super.onAttach(context)
         if(context is CommonFragmentListener){
             fragmentListener = context
         } else throw RuntimeException("$context must implement CommonFragmentListener")
 
     }
 
 
     private fun stopAnimations(){
         for(anim in animatorsByVeh.values){
             anim.cancel()
         }
     }
 
     /**
      * Save the loaded pattern data, without the stops!
      */
     private fun savePatternsToShow(patterns: List<MatoPatternWithStops>){
 
         currentPatterns = patterns.sortedWith(patternsSorter)
 
         patternsAdapter?.let {
             it.clear()
             it.addAll(currentPatterns.map { p->"${p.pattern.directionId} - ${p.pattern.headsign}" })
             it.notifyDataSetChanged()
         }
         // if we are loading from a stop, find it
         val patternToShow = stopIDFromToShow?.let { sID ->
             val stopGtfsID = "gtt:$sID"
             var p: MatoPatternWithStops? = null
             var pLength = 0
             for(patt in currentPatterns){
                 for(pstop in patt.stopsIndices){
                     if(pstop.stopGtfsId == stopGtfsID){
                         //found
                         if (patt.stopsIndices.size>pLength){
                             p = patt
                             pLength = patt.stopsIndices.size
                         }
                         //break here, we have determined this pattern has the stop we're looking for
                         break
                     }
                 }
             }
             p
         }
         if(stopIDFromToShow!=null){
             if(patternToShow==null)
                 Log.w(DEBUG_TAG, "We had to show the pattern from stop $stopIDFromToShow, but we didn't find it")
             else
                 Log.d(DEBUG_TAG, "Requesting to show pattern from stop $stopIDFromToShow, found pattern ${patternToShow.pattern.code}")
         }
         //unset the stopID to show
         if(patternToShow!=null) {
 
             //showPattern(patternToShow)
             patternShown = patternToShow
             stopIDFromToShow = null
         }
         patternShown?.let {
             showPattern(it)
         }
 
     }
 
     /**
      * Called when the position of the spinner is updated
      */
     private fun setPatternAndReqStops(patternWithStops: MatoPatternWithStops){
         Log.d(DEBUG_TAG, "Requesting stops for pattern ${patternWithStops.pattern.code}")
         viewModel.selectedPatternLiveData.value = patternWithStops
         viewModel.currentPatternStops.value =  patternWithStops.stopsIndices.sortedBy { i-> i.order }
         patternShown = patternWithStops
 
         viewModel.requestStopsForPatternWithStops(patternWithStops)
     }
     private fun showPattern(patternWs: MatoPatternWithStops){
         //Log.d(DEBUG_TAG, "Finding pattern to show: ${patternWs.pattern.code}")
         var pos = -2
         val code = patternWs.pattern.code.trim()
         for (k in currentPatterns.indices) {
             if (currentPatterns[k].pattern.code.trim() == code) {
                 pos = k
                 break
             }
         }
         Log.d(DEBUG_TAG, "Requesting stops fro pattern $code in position: $pos")
         if (pos !=-2)
             patternsSpinner.setSelection(pos)
         else
             Log.e(DEBUG_TAG, "Pattern with code $code not found!!")
         //request pattern stops from DB
         //setPatternAndReqStops(patternWs)
     }
 
     private fun zoomToCurrentPattern(){
         if(polyline==null) return
         val NULL_VALUE = -4000.0
         var maxLat = NULL_VALUE
         var minLat = NULL_VALUE
         var minLong = NULL_VALUE
         var maxLong = NULL_VALUE
 
         polyline?.let {
             for(p in it.coordinates()){
                 val lat = p.latitude()
                 val lon = p.longitude()
                 // get max latitude
                 if(maxLat == NULL_VALUE)
                     maxLat =lat
                 else if (maxLat < lat) maxLat = lat
                 // find min latitude
                 if (minLat ==NULL_VALUE)
                     minLat = lat
                 else if (minLat > lat) minLat = lat
                 if(maxLong == NULL_VALUE || maxLong < lon )
                     maxLong = lon
                 if (minLong == NULL_VALUE || minLong > lon)
                     minLong = lon
             }
             val padding = 50 // Pixel di padding intorno ai limiti
 
             Log.d(DEBUG_TAG, "Setting limits of bounding box of line: $minLat -> $maxLat, $minLong -> $maxLong")
             val bbox = LatLngBounds.from(maxLat,maxLong, minLat, minLong)
             //map.zoomToBoundingBox(BoundingBox(maxLat+del, maxLong+del, minLat-del, minLong-del), false)
             map?.animateCamera(CameraUpdateFactory.newLatLngBounds(bbox, padding))
         }
 
 
     }
 
     private fun displayPatternWithStopsOnMap(patternWs: MatoPatternWithStops, stopsToSort: List<Stop>, zoomToPattern: Boolean){
         if(!mapInitialized.get()){
             //set the runnable and do nothing else
             Log.d(DEBUG_TAG, "Delaying pattern display to when map is Ready: ${patternWs.pattern.code}")
             toRunWhenMapReady = Runnable {
                 displayPatternWithStopsOnMap(patternWs, stopsToSort, zoomToPattern)
             }
             return
         }
 
         Log.d(DEBUG_TAG, "Got the stops: ${stopsToSort.map { s->s.gtfsID }}}")
         patternShown = patternWs
         //Problem: stops are not sorted
         val stopOrderD = patternWs.stopsIndices.withIndex().associate{it.value.stopGtfsId to it.index}
         val stopsSorted = stopsToSort.sortedBy { s-> stopOrderD[s.gtfsID] }
 
         val pattern = patternWs.pattern
         val pointsList = PolylineParser.decodePolyline(pattern.patternGeometryPoly, pattern.patternGeometryLength)
 
         val pointsToShow = pointsList.map { Point.fromLngLat(it.longitude, it.latitude) }
         Log.d(DEBUG_TAG, "The polyline has ${pointsToShow.size} points to display")
         polyline = LineString.fromLngLats(pointsToShow)
         val lineFeature = Feature.fromGeometry(polyline)
         //Log.d(DEBUG_TAG, "Polyline in JSON is: ${lineFeature.toJson()}")
 
         // --- STOPS---
         val features = ArrayList<Feature>()
         for (s in stopsSorted){
             if (s.latitude!=null && s.longitude!=null) {
                 val loc = if (showOnTopOfLine) findOptimalPosition(s, pointsList)
                                 else LatLng(s.latitude!!, s.longitude!!)
                 features.add(
                     Feature.fromGeometry(
                         Point.fromLngLat(loc.longitude, loc.latitude),
                         JsonObject().apply {
                             addProperty("id", s.ID)
                             addProperty("name", s.stopDefaultName)
                             //addProperty("routes", s.routesThatStopHereToString()) // Add routes array to JSON object
                         }
                     )
                 )
             }
         }
         // -- ARROWS --
         //val splitPolyline = MapLibreUtils.splitPolyWhenDistanceTooBig(pointsList, 200.0)
         val arrowFeatures = ArrayList<Feature>()
         val pointsIndexToShowIcon = MapLibreUtils.findPointsToPutDirectionMarkers(pointsList, stopsSorted, 900.0)
 
         for (idx in pointsIndexToShowIcon){
             val pnow = pointsList[idx]
             val otherp = if(idx>1) pointsList[idx-1] else pointsList[idx+1]
             val bearing = if (idx>1) MapLibreUtils.getBearing(pointsList[idx-1], pnow) else MapLibreUtils.getBearing(pnow, pointsList[idx+1])
 
             arrowFeatures.add(Feature.fromGeometry(
                 Point.fromLngLat((pnow.longitude+otherp.longitude)/2, (pnow.latitude+otherp.latitude)/2 ), //average
                 JsonObject().apply {
                     addProperty("bearing", bearing)
                 }
             ))
         }
         Log.d(DEBUG_TAG,"Have put ${features.size} stops to display")
 
         // if the layer is already started, substitute the stops inside, otherwise start it
         if (stopsLayerStarted) {
             stopsSource.setGeoJson(FeatureCollection.fromFeatures(features))
             polylineSource.setGeoJson(lineFeature)
             polyArrowSource.setGeoJson(FeatureCollection.fromFeatures(arrowFeatures))
             lastStopsSizeShown = features.size
         } else
             map?.let {
                 Log.d(DEBUG_TAG, "Map stop layer is not started yet, init layer")
                 initStopsPolyLineLayers(mapStyle, FeatureCollection.fromFeatures(features),lineFeature, FeatureCollection.fromFeatures(arrowFeatures))
                 Log.d(DEBUG_TAG,"Started stops layer on map")
                 lastStopsSizeShown = features.size
                 stopsLayerStarted = true
             } ?:{
                 Log.e(DEBUG_TAG, "Stops layer is not started!!")
             }
 
         /* OLD CODE
         for(s in stops){
             val gp =
 
             val marker = MarkerUtils.makeMarker(
                 gp, s.ID, s.stopDefaultName,
                 s.routesThatStopHereToString(),
                 map,stopTouchResponder, stopIcon,
                 R.layout.linedetail_stop_infowindow,
                 R.color.line_drawn_poly
             )
             marker.setAnchor(Marker.ANCHOR_CENTER, Marker.ANCHOR_CENTER)
             stopsOverlay.add(marker)
         }
          */
         //POINTS LIST IS NOT IN ORDER ANY MORE
         //if(!map.overlayManager.contains(stopsOverlay)){
         //    map.overlayManager.add(stopsOverlay)
         //}
         if(zoomToPattern) zoomToCurrentPattern()
         //map.invalidate()
     }
 
     private fun initializeRecyclerView(){
         val llManager = LinearLayoutManager(context)
         llManager.orientation = LinearLayoutManager.VERTICAL
 
         stopsRecyclerView.layoutManager = llManager
     }
     private fun showStopsInRecyclerView(stops: List<Stop>){
 
         Log.d(DEBUG_TAG, "Setting stops from: "+viewModel.currentPatternStops.value)
         val orderBy = viewModel.currentPatternStops.value!!.withIndex().associate{it.value.stopGtfsId to it.index}
         val stopsSorted = stops.sortedBy { s -> orderBy[s.gtfsID] }
         val numStops = stopsSorted.size
         Log.d(DEBUG_TAG, "RecyclerView adapter is: ${stopsRecyclerView.adapter}")
 
         val setNewAdapter = true
         if(setNewAdapter){
             stopsRecyclerView.adapter = StopRecyclerAdapter(
                 stopsSorted, stopAdapterListener, StopRecyclerAdapter.Use.LINES,
                 NameCapitalize.FIRST
             )
 
         }
 
     }
 
     /**
      * This method fixes the display of the pattern, to be used when clicking on a bus
      */
     private fun showPatternWithCode(patternId: String){
         //var index = 0
         Log.d(DEBUG_TAG, "Showing pattern with code $patternId ")
         for (i in currentPatterns.indices){
             val pattStop = currentPatterns[i]
             if(pattStop.pattern.code == patternId){
                 Log.d(DEBUG_TAG, "Pattern found in position $i")
                 //setPatternAndReqStops(pattStop)
                 patternsSpinner.setSelection(i)
                 break
             }
         }
     }
 
     /**
      * Update function for the bus positions
      * Takes the processed updates and saves them accordingly
      * Copied from MapLibreFragment, removing the labels
      */
     private fun updateBusPositionsInMap(incomingData: HashMap<String, Pair<LivePositionUpdate,TripAndPatternWithStops?>>){
         val vehsNew = HashSet(incomingData.values.map { up -> up.first.vehicle })
         val vehsOld = HashSet(updatesByVehDict.keys)
         Log.d(DEBUG_TAG, "In fragment, have ${incomingData.size} updates to show")
 
         var countUpds = 0
         //val symbolsToUpdate = ArrayList<Symbol>()
         for (upsWithTrp in incomingData.values){
             val pos = upsWithTrp.first
             val patternStops = upsWithTrp.second
             val vehID = pos.vehicle
             var animate = false
             if (vehsOld.contains(vehID)){
                 //update position only if the starting or the stopping position of the animation are in the view
                 val oldPos = updatesByVehDict[vehID]?.posUpdate
                 var avoidShowingUpdateBecauseIsImpossible = false
                 oldPos?.let{
 
                     if(it.routeID!=pos.routeID) {
                         val dist = LatLng(it.latitude, it.longitude).distanceTo(LatLng(pos.latitude, pos.longitude))
                         val speed = dist*3.6 / (pos.timestamp - it.timestamp) //this should be in km/h
                         Log.w(DEBUG_TAG, "Vehicle $vehID changed route from ${oldPos.routeID} to ${pos.routeID}, distance: $dist, speed: $speed")
                         if (speed > 120 || speed < 0){
                             avoidShowingUpdateBecauseIsImpossible = true
                         }
                     }
                 }
                 if (avoidShowingUpdateBecauseIsImpossible){
                     // DO NOT SHOW THIS SHIT
                     Log.w(DEBUG_TAG, "Update for vehicle $vehID skipped")
                     continue
                 }
 
                 val samePosition = oldPos?.let { (it.latitude==pos.latitude)&&(it.longitude == pos.longitude) }?:false
                 if(!samePosition) {
                     //val isPositionInBounds = isInsideVisibleRegion(
                     //    pos.latitude, pos.longitude, true
                     //) || (oldPos?.let { isInsideVisibleRegion(it.latitude,it.longitude,true) } ?: false)
                     val skip = true
                     if (skip) {
                         //animate = true
                         //this moves both the icon and the label
                         moveVehicleToNewPosition(pos)
                     } else {
                         //update
                         updatesByVehDict[vehID] = LivePositionTripPattern(pos,patternStops?.pattern)
                         /*busLabelSymbolsByVeh[vehID]?.let {
                             it.latLng = LatLng(pos.latitude, pos.longitude)
                             symbolsToUpdate.add(it)
                         }*/
                         //if(vehShowing==vehID)
                         //    map?.animateCamera(CameraUpdateFactory.newLatLng(LatLng(pos.latitude, pos.longitude)),500)
                         //TODO: Follow the vehicle
                     }
                 }
                 countUpds++
             }
             else{
                 //not inside
                 // update it simply
                 updatesByVehDict[vehID] = LivePositionTripPattern(pos, patternStops?.pattern)
                 //createLabelForVehicle(pos)
                 //if(vehShowing==vehID)
                 //    map?.animateCamera(CameraUpdateFactory.newLatLng(LatLng(pos.latitude, pos.longitude)),500)
             }
             if (vehID == vehShowing){
                 //update the data
                 showVehicleTripInBottomSheet(vehID)
             }
         }
         //symbolManager.update(symbolsToUpdate)
         //remove old positions
         Log.d(DEBUG_TAG, "Updated $countUpds vehicles")
         vehsOld.removeAll(vehsNew)
         //now vehsOld contains the vehicles id for those that have NOT been updated
         val currentTimeStamp = System.currentTimeMillis() /1000
         for(vehID in vehsOld){
             //remove after 2 minutes of inactivity
             if (updatesByVehDict[vehID]!!.posUpdate.timestamp - currentTimeStamp > 2*60){
                 updatesByVehDict.remove(vehID)
                 //removeVehicleLabel(vehID)
             }
         }
         //update UI
         updatePositionsIcons(false)
     }
 
     /**
      * This is the tricky part, animating the transitions
      * Basically, we need to set the new positions with the data and redraw them all
      */
     private fun moveVehicleToNewPosition(positionUpdate: LivePositionUpdate){
         if (positionUpdate.vehicle !in updatesByVehDict.keys)
             return
         val vehID = positionUpdate.vehicle
         val currentUpdate = updatesByVehDict[positionUpdate.vehicle]
         currentUpdate?.let { it ->
             //cancel current animation on vehicle
             animatorsByVeh[vehID]?.cancel()
             val posUp = it.posUpdate
 
             val currentPos = LatLng(posUp.latitude, posUp.longitude)
             val newPos = LatLng(positionUpdate.latitude, positionUpdate.longitude)
             val valueAnimator = ValueAnimator.ofObject(MapLibreUtils.LatLngEvaluator(), currentPos, newPos)
             valueAnimator.addUpdateListener(object : ValueAnimator.AnimatorUpdateListener {
                 private var latLng: LatLng? = null
                 override fun onAnimationUpdate(animation: ValueAnimator) {
                     latLng = animation.animatedValue as LatLng
                     //update position on animation
                     val update = updatesByVehDict[positionUpdate.vehicle]!!
                     latLng?.let { ll->
                         update.posUpdate.latitude = ll.latitude
                         update.posUpdate.longitude = ll.longitude
                         updatePositionsIcons(false)
                     }
                 }
             })
             /*valueAnimator.addListener(object : AnimatorListenerAdapter() {
                 override fun onAnimationStart(animation: Animator) {
                     super.onAnimationStart(animation)
                     //val update = positionsByVehDict[positionUpdate.vehicle]!!
                     //remove the label at the start of the animation
                     //removeVehicleLabel(vehID)
                     val annot = busLabelSymbolsByVeh[vehID]
                     annot?.let { sym ->
                         sym.textOpacity = 0.0f
                         symbolsToUpdate.add(sym)
                     }
                 }
 
                 override fun onAnimationEnd(animation: Animator) {
                     super.onAnimationEnd(animation)
                     /*val annot = busLabelSymbolsByVeh[vehID]
                     annot?.let { sym ->
                         sym.textOpacity = 1.0f
                         sym.latLng = newPos //LatLng(newPos)
                         symbolsToUpdate.add(sym)
                     }
 
                      */
                 }
             })
              */
             animatorsByVeh[vehID]?.cancel()
             //set the new position as the current one but with the old lat and lng
             positionUpdate.latitude = posUp.latitude
             positionUpdate.longitude = posUp.longitude
             updatesByVehDict[vehID]!!.posUpdate = positionUpdate
             valueAnimator.duration = 300
             valueAnimator.interpolator = LinearInterpolator()
             valueAnimator.start()
 
             animatorsByVeh[vehID] = valueAnimator
 
         } ?: {
             Log.e(DEBUG_TAG, "Have to run animation for veh ${positionUpdate.vehicle} but not in the dict, adding")
             //updatesByVehDict[positionUpdate.vehicle] = positionUpdate
         }
     }
 
     /**
      * Update the bus positions displayed on the map, from the existing data
      */
     private fun updatePositionsIcons(forced: Boolean){
         //avoid frequent updates
         val currentTime = System.currentTimeMillis()
         if(!forced && currentTime - lastUpdateTime < 60){
             //DO NOT UPDATE THE MAP
             return
         }
 
         val features = ArrayList<Feature>()//stops.mapNotNull { stop ->
         //stop.latitude?.let { lat ->
         //    stop.longitude?.let { lon ->
         for (dat in updatesByVehDict.values){
             //if (s.latitude!=null && s.longitude!=null)
             val pos = dat.posUpdate
             val point = Point.fromLngLat(pos.longitude, pos.latitude)
             features.add(
                 Feature.fromGeometry(
                     point,
                     JsonObject().apply {
                         addProperty("veh", pos.vehicle)
                         addProperty("trip", pos.tripID)
                         addProperty("bearing", pos.bearing ?:0.0f)
                         addProperty("line", pos.routeID)
                     }
                 )
             )
             /*busLabelSymbolsByVeh[pos.vehicle]?.let {
                 it.latLng = LatLng(pos.latitude, pos.longitude)
                 symbolsToUpdate.add(it)
             }
 
              */
         }
         busesSource.setGeoJson(FeatureCollection.fromFeatures(features))
         //update labels, clear cache to be used
         //symbolManager.update(symbolsToUpdate)
         //symbolsToUpdate.clear()
         lastUpdateTime = System.currentTimeMillis()
     }
 
 
     override fun onResume() {
         super.onResume()
         Log.d(DEBUG_TAG, "Resetting paused from onResume")
         mapView.onResume()
         pausedFragment = false
 
         val keySourcePositions = getString(R.string.pref_positions_source)
         useMQTTPositions = PreferenceManager.getDefaultSharedPreferences(requireContext())
             .getString(keySourcePositions, "mqtt").contentEquals("mqtt")
 
         //separate paths
         if(useMQTTPositions)
             liveBusViewModel.requestMatoPosUpdates(GtfsUtils.getLineNameFromGtfsID(lineID))
         else
             liveBusViewModel.requestGTFSUpdates()
 
 
         if(mapViewModel.currentLat.value!=MapViewModel.INVALID) {
             Log.d(DEBUG_TAG, "mapViewModel posi: ${mapViewModel.currentLat.value}, ${mapViewModel.currentLong.value}"+
                     " zoom ${mapViewModel.currentZoom.value}")
             //THIS WAS A FIX FOR THE OLD OSMDROID MAP
             /*val controller = map.controller
             viewLifecycleOwner.lifecycleScope.launch {
                 delay(100)
                 Log.d(DEBUG_TAG, "zooming back to point")
                 controller.animateTo(GeoPoint(mapViewModel.currentLat.value!!, mapViewModel.currentLong.value!!),
                     mapViewModel.currentZoom.value!!,null,null)
                 //controller.setCenter(GeoPoint(mapViewModel.currentLat.value!!, mapViewModel.currentLong.value!!))
                 //controller.setZoom(mapViewModel.currentZoom.value!!)
             }
              */
         }
         //initialize GUI here
         fragmentListener.readyGUIfor(FragmentKind.LINES)
 
     }
 
     override fun onPause() {
         super.onPause()
         mapView.onPause()
         if(useMQTTPositions) liveBusViewModel.stopMatoUpdates()
         pausedFragment = true
         //save map
         val camera = map?.cameraPosition
         camera?.let {cam->
             mapViewModel.currentLat.value = cam.target?.latitude ?: -400.0
             mapViewModel.currentLong.value = cam.target?.longitude ?: -400.0
             mapViewModel.currentZoom.value = cam.zoom
         }
 
     }
 
     override fun onStart() {
         super.onStart()
         mapView.onStart()
     }
 
     override fun onDestroy() {
         super.onDestroy()
         mapView.onDestroy()
     }
 
     override fun onStop() {
         super.onStop()
         mapView.onStop()
         shownStopInBottomSheet?.let {
             mapViewModel.stopShowing = it
         }
         shouldMapLocationBeReactivated = locationComponent.isLocationComponentEnabled
     }
 
     override fun onDestroyView() {
         map?.run {
             Log.d(DEBUG_TAG, "Saving camera position")
             savedCameraPosition = cameraPosition
         }
 
         super.onDestroyView()
         Log.d(DEBUG_TAG, "Destroying the views")
 
         /*mapStyle.removeLayer(STOPS_LAYER_ID)
 
         mapStyle?.removeSource(STOPS_SOURCE_ID)
 
         mapStyle.removeLayer(POLYLINE_LAYER)
         mapStyle.removeSource(POLYLINE_SOURCE)
          */
         //stopsLayerStarted = false
     }
 
     override fun onMapDestroy() {
         mapStyle.removeLayer(STOPS_LAYER_ID)
 
         mapStyle.removeSource(STOPS_SOURCE_ID)
 
         mapStyle.removeLayer(POLYLINE_LAYER)
         mapStyle.removeSource(POLYLINE_SOURCE)
         mapStyle.removeLayer(BUSES_LAYER_ID)
         mapStyle.removeSource(BUSES_SOURCE_ID)
 
 
         map?.locationComponent?.isLocationComponentEnabled = false
     }
 
     override fun getBaseViewForSnackBar(): View? {
         return null
     }
 
     companion object {
         private const val LINEID_KEY="lineID"
         private const val STOPID_FROM_KEY="stopID"
         private const val STOPS_SOURCE_ID = "stops-source"
         private const val STOPS_LAYER_ID = "stops-layer"
         private const val STOP_ACTIVE_IMG = "stop_active_img"
         private const val STOP_IMAGE_ID = "stop-img"
         private const val POLYLINE_LAYER = "polyline-layer"
         private const val POLYLINE_SOURCE = "polyline-source"
 
         private const val POLY_ARROWS_LAYER = "arrows-layer"
         private const val POLY_ARROWS_SOURCE = "arrows-source"
         private const val POLY_ARROW ="poly-arrow-img"
 
         private const val DEBUG_TAG="BusTO-LineDetailFragment"
 
         fun makeArgs(lineID: String, stopIDFrom: String?): Bundle{
             val b = Bundle()
             b.putString(LINEID_KEY, lineID)
             b.putString(STOPID_FROM_KEY, stopIDFrom)
             return b
         }
         fun newInstance(lineID: String?, stopIDFrom: String?) = LinesDetailFragment().apply {
             lineID?.let { arguments = makeArgs(it, stopIDFrom) }
         }
         @JvmStatic
         private fun findOptimalPosition(stop: Stop, pointsList: MutableList<LatLng>): LatLng{
             if(stop.latitude==null || stop.longitude ==null|| pointsList.isEmpty())
                 throw IllegalArgumentException()
             val sLat = stop.latitude!!
             val sLong = stop.longitude!!
             if(pointsList.size < 2)
                 return  pointsList[0]
             pointsList.sortBy { utils.measuredistanceBetween(sLat, sLong, it.latitude, it.longitude) }
 
             val p1 = pointsList[0]
             val p2 = pointsList[1]
             if (p1.longitude == p2.longitude){
                 //Log.e(DEBUG_TAG, "Same longitude")
                 return LatLng(sLat, p1.longitude)
             } else if (p1.latitude == p2.latitude){
                 //Log.d(DEBUG_TAG, "Same latitude")
                 return LatLng(p2.latitude,sLong)
             }
 
             val m = (p1.latitude - p2.latitude) / (p1.longitude - p2.longitude)
             val minv = (p1.longitude-p2.longitude)/(p1.latitude - p2.latitude)
             val cR = p1.latitude - p1.longitude * m
 
             val longNew = (minv * sLong + sLat -cR ) / (m+minv)
             val latNew = (m*longNew + cR)
             //Log.d(DEBUG_TAG,"Stop ${stop.ID} old pos: ($sLat, $sLong), new pos ($latNew,$longNew)")
             return LatLng(latNew,longNew)
         }
 
         private const val DEFAULT_CENTER_LAT = 45.12
         private const val DEFAULT_CENTER_LON = 7.6858
     }
 
     enum class BottomShowing{
         STOP, VEHICLE
     }
 }
\ No newline at end of file
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index 64838a4..9d8343f 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -1,347 +1,348 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
 
     <string name="app_name" translatable="false">BusTO</string>
     <string name="app_name_full" translatable="false">Libre BusTO</string>
     <string name="app_name_debug" translatable="false">BusTO dev</string>
     <string name="app_name_gitpull" translatable="false">BusTO git</string>
     <string name="app_description">You\'re using the latest in technology when it comes to respecting your privacy.
     </string>
     <string name="search">Search</string>
     <string name="qrcode">Scan QR Code</string>
     <string name="yes">Yes</string>
     <string name="no">No</string>
     <string name="next">Next</string>
     <string name="previous">Previous</string>
 
     <string name="title_barcode_scanner_install">Install Barcode Scanner?</string>
     <string name="message_install_barcode_scanner">This application requires an app to scan the QR codes. Would you like
         to install Barcode Scanner now?
     </string>
 
     <string name="insert_bus_stop_number">Bus stop number</string>
     <string name="insert_bus_stop_name">Bus stop name</string>
     <string name="insert_bus_stop_number_error">Insert bus stop number</string>
     <string name="insert_bus_stop_name_error">Insert bus stop name</string>
     <string name="route_towards_destination">%1$s towards %2$s</string>
     <string name="route_towards_unknown">%s (unknown destination)</string>
     <string name="network_error">Verify your Internet connection!</string>
     <string name="no_bus_stop_have_this_name">Seems that no bus stop have this name</string>
     <string name="no_arrivals_stop">No arrivals found for this stop</string>
     <string name="parsing_error">Error parsing the 5T/GTT website (damn site!)</string>
     <string name="query_too_short">Name too short, type more characters and retry
     </string> <!-- TODO: carry out experiments to determine the best wording for this message and publish a paper with the findings -->
     <string name="passages">Arrivals at: %1$s</string>
     <string name="results">Choose the bus stop…</string>
     <string name="line">Line</string>
     <string name="lines">Lines</string>
     <string name="urban_lines">Urban lines</string>
     <string name="extraurban_lines">Extra urban lines</string>
     <string name="turist_lines">Tourist lines</string>
 
     <string name="direction_duep">Destination:</string>
     <string name="lines_fill">Lines: %1$s</string>
     <string name="line_fill">Line: %1$s</string>
     <string name="no_passages">No timetable found</string>
     <string name="no_qrcode">No QR code found, try using another app to scan</string>
     <string name="internal_error">Unexpected internal error, cannot extract data from GTT/5T website</string>
     <string name="action_help">Help</string>
     <string name="action_about">About the app</string>
     <string name="action_about_more">More about</string>
     <string name="action_wiki">Contribute</string>
     <string name="hack_url">https://gitpull.it/w/librebusto/en/</string>
     <string name="action_source">Source code</string>
     <string name="action_licence">Licence</string>11
     <string name="action_author">Meet the author</string>
     <string name="added_in_favorites">Bus stop is now in your favorites</string>
     <string name="removed_from_favorites">Bus stop removed from your favorites</string>
     <string name="favorites_line_add">Added line to favorites</string>
     <string name="favorites_line_remove">Remove line from favorites</string>
     <string name="favorites_lines">Favorites</string>
     <string name="action_favorites">Favorites</string>
     <string name="title_activity_favorites">Favorites</string>
     <string name="title_activity_map">Map</string>
     <string name="tip_add_favorite">No favorites? Arghh! Press on a bus stop star to populate this list!</string>
     <string name="action_remove_from_favourites">Delete</string>
     <string name="action_rename_bus_stop_username">Rename</string>
     <string name="dialog_rename_bus_stop_username_title">Rename the bus stop</string>
     <string name="dialog_rename_bus_stop_username_reset_button">Reset</string>
     <string name="about_activity">About the app</string>
     <string name="howDoesItWork">
         <b>Tap the star</b>
         to add the bus stop to the favourites\n\n<b>How to read timelines:</b>\n<b>&#160;&#160;&#160;12:56*</b> Real-time
         arrivals\n<b>&#160;&#160;&#160;12:56</b> &#160; Scheduled arrivals\n\n<b>Pull down to refresh</b> the timetable
         \n <b>Long press on Arrivals source</b> to change the source of the arrival times
     </string>
     <string name="hint_button">GOT IT!</string>
     <string name="arrival_times">Arrival times</string>
     <string name="no_passages_title">No arrivals found for lines:</string>
     <string name="about_history_top">
         <![CDATA[
         <h1>Welcome!</h1>
 
         <p>Thanks for using BusTO, an <b>open source</b> and <b>independent</b> app useful to move around Torino using a <b>Free/Libre software</b>.</p>
         <br>
         <p>Why use this app?</p>
 		<p>
         - You\'ll never be <b>tracked</b><br>
         - You\'ll never see boring <b>ads</b><br>
         - We\'ll always respect your <b>privacy</b><br>
         - Moreover, it\'s lightweight!<br>
         </p>
         <br>
         <h2>Introductory tutorial</h2>
         <p>If you want to see the introduction again, use the button below:</p>
         ]]></string>
     <string name="about_channel">
         <![CDATA[
     <h2>News and Updates</h2>
     <p>On the Telegram channel, you can find information about the latest app updates</p>
     ]]></string>
     <string name="about_how">
         <![CDATA[
     <h2>How does it work?</h2>
         <p>This app is able to do all the amazing things it does by pulling data from <b>www.gtt.to.it</b>, <b>www.5t.torino.it</b> or <b>muoversiatorino.it</b> "for personal use", along with open data from the AperTO (aperto.comune.torino.it) website.</p>
         <br>
 		<p>The work of several people is behind this app, in particular:<br>
 		- <b>Fabio Mazza</b>, current senior rockstar developer.<br>
         - <b>Andrea Ugo</b>, current junior rockstar developer.<br>
 		- <b>Silviu Chiriac</b>, designer of the 2021 logo.<br>
 		- <b>Marco M</b>, rockstar tester and bug hunter.<br>
 		- <b>Ludovico Pavesi</b>, previous senior rockstar developer (asd).<br>
 		- <b>Valerio Bozzolan</b>, maintainer and infrastructure (sponsor).<br>
 		- <b>Marco Gagino</b>, contributor and first icon creator.<br>
 		- <b>JSoup</b> web scraper library.<br>
 		- <b>makovkastar</b> floating buttons.<br>
         - <b>Google</b> for icons and support and design libraries.<br>
         - Other icons from <b>Bootstrap</b>, <b>Feather</b>, and <b>Hero Icons</b>.<br>
 		- All the contributors, and the beta testers, too!
 		</p>
 		<br>
 		 If you want more technical information or to contribute to development, use the buttons below!</b>
     ]]></string>
     <string name="about_history_bottom">
         <![CDATA[
 		<h2>Licenses</h2>
 		<p>The app and the related source code are released by Valerio Bozzolan and the other authors under the terms of the <i>GNU General Public License v3+</i>).
 		So everyone is allowed to use, to study, to improve and to share this app by <b>any kind of means</b> and for <b>any purpose</b>: under the conditions of maintaining this rights and of attributing the original work to Valerio Bozzolan.</p>
         <br>
 		<h2>Notes</h2>
 		<p>This app has been developed with the <b>hope to be useful to everyone</b>, but comes without ANY warranty of any kind.</p>
 		<p>The data used by the app comes <b>directly</b> from GTT and other public agencies: if you find any errors, please take it up to them, not to us.</p>
 		<p>This translation is kindly provided by Riccardo Caniato, Marco Gagino and Fabio Mazza.</p>
 		<p>Now you can hack public transport, too! :)</p>
     ]]>
     </string>
 
     <string name="cant_add_to_favorites">Cannot add to favorites (storage full or corrupted database?)!</string>
     <string name="action_view_on_map">View on a map</string>
     <string name="cannot_show_on_map_no_activity">Cannot find any application to show it in</string>
     <string name="cannot_show_on_map_no_position">Cannot find the position of the stop</string>
 
     <string name="list_fragment_debug" translatable="false">ListFragment - BusTO</string>
     <string name="mainSharedPreferences" translatable="false">it.reyboz.bustorino.preferences</string>
     <string name="databaseUpdatingPref" translatable="false">db_is_updating</string>
     <!-- Settings -->
     <string name="nearby_stops_message">Nearby stops</string>
     <string name="nearby_arrivals_message">Nearby connections</string>
     <string name="app_version">App version</string>
     <string name="num_stops_nearby_not_number">The number of stops to show in the recent stops is invalid</string>
     <string name="invalid_number">Invalid value, put a valid number</string>
 
     <string name="position_searching_message">Finding location</string>
     <string name="no_stops_nearby">No stops nearby</string>
     <string name="pref_num_elements">Minimum number of stops</string>
     <string name="main_menu_pref">Preferences</string>
     <string name="title_activity_settings">Settings</string>
     <string name="action_settings">Settings</string>
     <string name="general_settings">General</string>
     <string name="settings_experimental">Experimental features</string>
     <string name="settings_search_radius">Maximum distance (meters)</string>
     <string name="pref_recents_group_title">Recent stops</string>
     <string name="settings_group_general">General settings</string>
     <string name="settings_group_database">Database management</string>
     <string name="settings_reset_database">Launch manual database update</string>
 
     <string name="enable_position_message_map">Allow access to location to show it on the map</string>
     <string name="enable_position_message_nearby">Allow access to location to show stops nearby</string>
     <string name="enableGpsText">Please enable location on the device</string>
     <string name="database_update_msg_inapp">Database update in progress&#8230;</string>
     <string name="database_update_msg_notif">Updating the database</string>
     <string name="database_update_req">Force database update</string>
     <string name="database_update_req_descr">Touch to update the app database now</string>
     <string name="bus_arriving_at">is arriving at</string>
     <string name="arrivals_card_at_the_stop">at the stop</string>
     <string name="two_strings_format" translatable="false">%1$s - %2$s</string>
     <string name="show_arrivals">Show arrivals</string>
     <string name="show_stops">Show stops</string>
     <!--
     Mixed button strings
     !-->
     <string name="open_telegram">Join Telegram channel</string>
     <string name="show_introduction">Show introduction</string>
     <!--
    Map view buttons strings
    !-->
     <string name="bt_center_map_description">Center on my location</string>
     <string name="bt_follow_me_description">Follow me</string>
     <string name="enable_position">Enable or disable location</string>
     <string name="location_enabled">Location enabled</string>
     <string name="location_disabled">Location disabled</string>
     <string name="map_location_disabled_device">Location is disabled on device</string>
 
     <!--
     Arrival times sources
     !-->
     <string name="times_source_fmt">Arrivals source: %1$s</string>
     <string name="fivetapifetcher">GTT App</string>
     <string name="gttjsonfetcher">GTT Website</string>
     <string name="fivetscraper">5T Torino website</string>
     <string name="source_mato">Muoversi a Torino app</string>
     <string name="undetermined_source">Undetermined</string>
     <string name="arrival_source_changing">Changing arrival times source…</string>
     <string name="change_arrivals_source_message">Long press to change the source of arrivals</string>
     <string-array name="arrival_times_source_list">
         <item>@string/source_mato</item>
         <item>@string/fivetapifetcher</item>
         <item>@string/gttjsonfetcher</item>
         <item>@string/fivetscraper</item>
     </string-array>
     <string name="arrival_times_choice_title">Sources of arrival times</string>
     <string name="arrival_times_choice_explanation">Select which sources of arrival times to use</string>
 
 
     <!--
     Notifications
     -->
     <string name="default_notification_channel" translatable="false">Default</string>
     <string name="default_notification_channel_description">Default channel for notifications</string>
     <string name="database_notification_channel">Database operations</string>
     <string name="database_notification_channel_desc">Updates of the app database</string>
     <string name="live_position_service_name">BusTO - live position service</string>
     <string name="live_positions_notification_channel">Live positions</string>
     <string name="live_positions_notification_channel_desc">Showing activity related to the live positions service</string>
     <string name="mqtt_notification_text">MaTO live bus positions service is running</string>
 
     <string name="db_trips_download_message">Downloading trips from MaTO server</string>
 
     <string name="too_many_permission_asks">Asked for %1$s permission too many times</string>
     <string name="permission_storage_maps_msg">Cannot use the map with the storage permission!</string>
     <string name="storage_permission">storage</string>
     <string name="message_crash">The application has crashed because you encountered a bug.
         \nIf you want, you can help the developers by sending the crash report via email.
         \nNote that no sensitive data is contained in the report, just small bits of info on your phone and app
         configuration/state.
     </string>
     <string name="acra_email_message">The application crashed and the crash report is in the attachments. Please
         describe what you were doing before the crash: \n
     </string>
     <string name="nav_arrivals_text">Arrivals</string>
     <string name="nav_map_text">Map</string>
     <string name="nav_favorites_text">Favorites</string>
     <string name="drawer_open">Open navigation drawer</string>
     <string name="drawer_close">Close navigation drawer</string>
     <string name="experiments">Experiments</string>
     <string name="donate_now">Buy us a coffee</string>
     <string name="map">Map</string>
     <string name="stop_search_view_title">Search by stop</string>
     <string name="requesting_db_update">Launching database update</string>
     <string name="downloading_data_mato">Downloading data from MaTO server</string>
 
     <!-- preferences -->
     <string name="pref_directions_capitalize">Capitalize directions</string>
     <string-array name="directions_capitalize">
         <item>Do not change arrivals directions</item>
         <item>Capitalize everything</item>
         <item>Capitalize only first letter</item>
     </string-array>
     <array name="directions_capitalize_keys">
         <item>KEEP</item>
         <item>CAPITALIZE_ALL</item>
         <item>CAPITALIZE_FIRST</item>
 
     </array>
     <string name="pref_shown_startup">Section to show on startup</string>
     <string name="pref_shown_startup_def_desc">Touch to change it</string>
     <string name="pref_lines_click_msg">Show arrivals touching on stop</string>
     <string name="pref_experimental_msg">Enable experiments</string>
 
 
     <!-- lines -->
     <string name="long_press_stop_4_options">Long press the stop for options</string>
 
     <array name="first_screen_shown">
         <item>@string/nav_arrivals_text</item>
         <item>@string/nav_favorites_text</item>
         <item>@string/nav_map_text</item>
         <item>@string/lines</item>
     </array>
 
     <string name="positions_source_pref_title">Source of real time positions for buses and trams</string>
     <array name="positions_source_sel">
         <item>MaTO (updated more frequently, might be offline)</item>
         <item>GTFS RT (more stable, less frequently updated)</item>
     </array>
     <string name="map_style_pref_title">Style of the map</string>
     <string name="map_style_osm_bright" translatable="false">OSM Bright</string>
     <string name="map_style_versatiles" translatable="false">Versatiles</string>
     <array name="map_style_pref_categories">
         <item>@string/map_style_versatiles</item>
         <item>@string/map_style_osm_bright</item>
     </array>
 
     <string name="remove_all_trips">Remove trips data (free up space)</string>
     <string name="all_trips_removed">All GTFS trips have been removed from the database</string>
 
     <!-- Tutorial strings -->
     <string name="tutorial_action">Show tutorial</string>
     <string name="tutorial_first">
         <![CDATA[Thank you for installing BusTO, the free and <b>open source</b> app for Turin public transport. This is an <b>independent</b> app, with no ads and no tracking whatsoever.]]> </string>
     <string name="tutorial_search"> <![CDATA[You can search for the arrival times at a bus stop by inserting the number in the top, or scanning a QR code when you are at the stop
         touching the icon on the left ]]>
     </string>
     <string name="tutorial_arrivals">
         <![CDATA[Once you have found a bus stop, you can save it in the <b>favorites</b> by touching the star next to its name]]>
     </string>
     <string name="tutorial_stops">
         <![CDATA[You can see the stops near your position directly in the main screen...]]>
     </string>
 
     <string name="tutorial_map">
         <![CDATA[...or you can find them in the map, along with the real-time positions of the buses running in the city (in <font color="#2F59CC">blue</font>)]]>
     </string>
     <string name="tutorial_line">
         <![CDATA[You can also look at the line you want and see where the stops are, together with the vehicles serving the line at the moment. Remember to choose the direction you\'re interested in!]]>
     </string>
     <string name="tutorial_menu">
         <![CDATA[You can find all of this from the lateral menu.
 Look in the <b>Settings</b> to customize the app behaviour, and in the <b>About the app</b> section if you want to know more about the app and the developers.]]>
     </string>
     <string name="tutorial_permissions">
         <![CDATA[The app needs the <b>Notifications</b> permission to show the information about background processing.
          Press the button below to grant it]]>
     </string>
     <string name="grant_location_permission">Grant location permission</string>
     <string name="location_permission_granted">Location permission granted</string>
     <string name="location_permission_not_granted">Location permission has not been granted</string>
 
     <string name="close_tutorial">OK, close the tutorial</string>
     <string name="close_tutorial_short">Close the tutorial</string>
     <string name="grant_notification_permission">Enable notifications</string>
     <string name="notification_permission_granted">Notifications enabled</string>
     <!-- BACKUP -->
     <string name="backup_restore">Backup and restore</string>
     <string name="backup_activity">Import/export preferences</string>
     <string name="saved_data">Data saved</string>
     <string name="btn_backup_message">Backup to file</string>
     <string name="btn_load_backup_message">Import data from backup</string>
     <string name="data_imported_backup">Backup has been imported</string>
     <string name="message_check_at_least_one">Check at least one item to import!</string>
     <string name="load_file_favorites">Import favorites from backup</string>
     <string name="load_preferences">Import preferences from backup</string>
     <!-- TODO: Remove or change this placeholder text -->
     <string name="hello_blank_fragment">Hello blank fragment</string>
 
     <string name="no_map_app_to_show_stop">No map app present to show the stop!</string>
+    <string name="showing_same_direction">Direction is already shown</string>
 
 </resources>