diff --git a/app/src/main/java/it/reyboz/bustorino/fragments/AlertsDialogFragment.kt b/app/src/main/java/it/reyboz/bustorino/fragments/AlertsDialogFragment.kt
index 00a0801..585af4e 100644
--- a/app/src/main/java/it/reyboz/bustorino/fragments/AlertsDialogFragment.kt
+++ b/app/src/main/java/it/reyboz/bustorino/fragments/AlertsDialogFragment.kt
@@ -1,143 +1,160 @@
+/*
+	BusTO  - Fragments components
+    Copyright (C) 2026 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.os.Bundle
 import android.util.Log
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import android.widget.ImageButton
 import android.widget.TextView
 import android.widget.Toast
 import androidx.cardview.widget.CardView
 import androidx.fragment.app.DialogFragment
 import androidx.fragment.app.activityViewModels
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 import androidx.work.ExistingWorkPolicy
 import androidx.work.WorkManager
 import it.reyboz.bustorino.R
 import it.reyboz.bustorino.adapters.AlertLineFullAdapter
 import it.reyboz.bustorino.backend.gtfs.GtfsUtils
 import it.reyboz.bustorino.data.GtfsAlertDBDownloadWorker
 import it.reyboz.bustorino.data.gtfs.AlertWithDetails
 import it.reyboz.bustorino.data.gtfs.GtfsAlertsTranslation
 import it.reyboz.bustorino.viewmodels.ServiceAlertsViewModel
 import java.util.Locale
 import kotlin.getValue
 import kotlin.collections.HashMap
 
 
 class AlertsDialogFragment(private val gtfsLineShow: String) : DialogFragment() {
 
     private lateinit var titleTextView: TextView
     private lateinit var messageTextView: TextView
     private lateinit var statusCardView: CardView
     private lateinit var recyclerView: RecyclerView
     private val alertsViewModel: ServiceAlertsViewModel by activityViewModels()
 
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         Log.d(DEBUG_TAG, "created DialogFragment for line ${gtfsLineShow}")
     }
 
     override fun onCreateView(
         inflater: LayoutInflater, container: ViewGroup?,
         savedInstanceState: Bundle?
     ): View? {
         // Inflate the layout for this fragment
         val root = inflater.inflate(R.layout.fragment_dialog_alerts_line, container, false)
 
         titleTextView = root.findViewById<TextView>(R.id.titleTextView)
         titleTextView.setText(getString(R.string.alert_line_fill,GtfsUtils.lineNameDisplayFromGtfsID(gtfsLineShow)))
         recyclerView =  root.findViewById(R.id.alertsRecyclerView)
         recyclerView.layoutManager = LinearLayoutManager(context, RecyclerView.VERTICAL, false)
         messageTextView = root.findViewById(R.id.alertMessageTextView)
         statusCardView = root.findViewById(R.id.statusCard)
         alertsViewModel.alertsByRouteLiveData.observe(viewLifecycleOwner){ alerts ->
             showAlerts(alerts)
         }
 
         val btnClose = root.findViewById<ImageButton>(R.id.btnClose)
         btnClose.setOnClickListener {
             dismiss()
         }
 
         val btnRefresh = root.findViewById<ImageButton>(R.id.btnRefresh)
         btnRefresh.setOnClickListener {
             val name = "manualUpdateAlerts"
             val req = GtfsAlertDBDownloadWorker.makeOneTimeRequest("manualUpdate$gtfsLineShow")
             WorkManager.getInstance(requireContext()).enqueueUniqueWork(name, ExistingWorkPolicy.KEEP,req)
             Toast.makeText(context, R.string.checking_alerts_update, Toast.LENGTH_SHORT).show()
         }
         return root
     }
 
     override fun onStart() {
         super.onStart()
         dialog?.window?.setLayout(
             ViewGroup.LayoutParams.MATCH_PARENT,
             ViewGroup.LayoutParams.WRAP_CONTENT
         )
     }
 
     private fun showAlerts(alerts: List<AlertWithDetails>) {
         val currentLang = Locale.getDefault().language
         val ms =  "language : $currentLang"
         val langs_msg = HashMap<String, Int>()
         for (a in alerts) {
             for (tr in a.translations){
                 if(tr.field == GtfsAlertsTranslation.FIELD_HEADER){
                     tr.language?.let{
                         if(langs_msg.containsKey(it)){
                             langs_msg[it] = langs_msg[it]!! + 1
                         } else{
                             langs_msg[it] = 1
                         }
                     }
                     //found the title, stop
                     break
                 }
             }
         }
         Log.d(DEBUG_TAG, "Lang $currentLang, alerts: $langs_msg, of lang: ${langs_msg[currentLang]}")
         val msgInLang = langs_msg[currentLang]?: 0
         val langShow = if (msgInLang > 0){
             currentLang
         } else if("en" in langs_msg.keys){
             "en"
         } else{
             "it"
         } // if there are no messages with "it", then it's over
         val count = langs_msg[langShow] ?: 0
         if (count == 0){
             messageTextView.text = "ERROR: NO ALERTS TO SHOW"
             statusCardView.visibility = View.VISIBLE
         } else if(msgInLang == 0){
             val msgShow = if(langShow == "en") getString(R.string.english) else getString(R.string.italian)
             messageTextView.text = getString(R.string.no_alerts_in_your_language_fill, msgShow)
             statusCardView.visibility = View.VISIBLE
         }
         // put them in the adapter
         if(count>0){
             recyclerView.adapter = AlertLineFullAdapter(alerts, langShow)
         }
     }
 
     companion object {
         /**
          * Use this factory method to create a new instance of
          * this fragment using the provided parameters.
          *
          * @param gtfsLine Line To show.
          * @return A new instance of fragment LineAlertsDialogFragment.
          */
         @JvmStatic
         fun newInstance(gtfsLine: String) =
             AlertsDialogFragment(gtfsLine)
 
         private const val GTFS_LINE_ARG = "gtfsLine"
 
         private const val DEBUG_TAG = "BusTO-AlertsDialog"
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/it/reyboz/bustorino/fragments/AlertsFragment.kt b/app/src/main/java/it/reyboz/bustorino/fragments/AlertsFragment.kt
index d89341f..85234b1 100644
--- a/app/src/main/java/it/reyboz/bustorino/fragments/AlertsFragment.kt
+++ b/app/src/main/java/it/reyboz/bustorino/fragments/AlertsFragment.kt
@@ -1,156 +1,173 @@
+/*
+	BusTO  - Fragments components
+    Copyright (C) 2026 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.os.Bundle
 import android.util.Log
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import android.widget.TextView
 import androidx.cardview.widget.CardView
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.activityViewModels
 import androidx.fragment.app.viewModels
 import androidx.recyclerview.widget.RecyclerView
 import com.google.transit.realtime.GtfsRealtime
 import it.reyboz.bustorino.R
 import it.reyboz.bustorino.viewmodels.ServiceAlertsViewModel
 import java.text.SimpleDateFormat
 import java.util.Date
 import java.util.Locale
 import java.util.TimeZone
 
 
 /**
  * A simple [Fragment] subclass.
  * Use the [AlertsFragment.newInstance] factory method to
  * create an instance of this fragment.
  */
 class AlertsFragment : ScreenBaseFragment() {
 
     private val alertsViewModel: ServiceAlertsViewModel by activityViewModels()
 
     private lateinit var textView: TextView
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         arguments?.let {
             //param1 = it.getString(ARG_PARAM1)
             //param2 = it.getString(ARG_PARAM2)
         }
     }
 
     override fun onCreateView(
         inflater: LayoutInflater, container: ViewGroup?,
         savedInstanceState: Bundle?
     ): View? {
         // Inflate the layout for this fragment
         val root = inflater.inflate(R.layout.fragment_alerts, container, false)
         textView = root.findViewById(R.id.simpleTextView)
 
         alertsViewModel.allAlertsLiveData.observe(viewLifecycleOwner, { alerts ->
             val sb = StringBuilder()
             val unixTimestamp = (System.currentTimeMillis() / 1000)
             for (x in alerts) {
                sb.append(x.longPrint())
                 sb.append("----- Alert active: ").append(x.isActive(unixTimestamp)).append("\n\n")
             }
 
             textView.text = sb.toString()
         })
 
 
         alertsViewModel.setStopFilter("472")
         /*alertsViewModel.alertsForStop.observe(viewLifecycleOwner){
             Log.d(DEBUG_TAG, "Got ${it.size} alerts")
             it?.let {
                 showAlerts(it)
             }
         }
 
          */
         /*
         alertsViewModel.alertsByRouteLiveData.observe(viewLifecycleOwner) { map ->
             Log.d(DEBUG_TAG, "Alerts for routes: ${map.keys}")
             val keys = map.keys
             if(keys.isNotEmpty()){
                 val sb = StringBuilder()
                 for (key in keys.sorted()) {
                     sb.append(" ======== Route: $key =======").append("\n")
                     sb.append(makeAlertListText(map[key]!!)).append("\n")
                     Log.d(DEBUG_TAG, "Route: $key len: ${map[key]!!.size}")
                 }
 
                 textView.text = sb.toString()
             }
 
         }
 
          */
         return root
     }
 
     override fun getBaseViewForSnackBar(): View? {
         TODO("Not yet implemented")
     }
 
     private fun makeAlertListText(alerts: List<GtfsRealtime.Alert>) : String{
         val sb = StringBuilder()
         for (al in alerts) {
             sb.append("=========== Alert ===========\n")
             sb.append("Title:\n")
             for (t in al.headerText.translationList) {
                 sb.append(t.language).append(": ").append(t.text).append("\n")
             }
             sb.append("Description:\n")
             val transl = al.descriptionText.translationList
             for (t in transl) {
                 sb.append(t.language).append(": ").append(t.text).append("\n")
             }
             val infE = al.informedEntityList
             sb.append("--- Active periods count: ${al.activePeriodCount}\n")
             val timeActive = al.getActivePeriod(0)
             sb.append("Start: ").append(getTimeStampToString(timeActive.start)).append(" ")
             sb.append("End: ").append(getTimeStampToString(timeActive.end)).append("\n")
             sb.append("--- Cause:\n")
             sb.append(al.cause.name).append("\n")
             sb.append("--- Informed entities:\n")
             for (e in infE) {
                 if(e.hasTrip()){
                     sb.append("Trip: ${e.trip.tripId} for route ${e.trip.routeId}, ")
                 } else{
                     sb.append("No Trip, ")
                 }
                 sb.append("Stop: ${e.stopId}, Route: ${e.routeId}\n")
             }
             sb.append("\n")
         }
         return sb.toString()
     }
 
     companion object {
         /**
          * Use this factory method to create a new instance of
          * this fragment using the provided parameters.
          *
          * @return A new instance of fragment AlertsFragment.
          */
         @JvmStatic
         fun newInstance() =
             AlertsFragment().apply {
                 arguments = Bundle().apply {
                     //putString(ARG_PARAM1, param1)
                     //putString(ARG_PARAM2, param2)
                 }
             }
 
         fun getTimeStampToString(timestamp: Long): String? {
             val date = Date(timestamp*1000)
 
             val sdf= SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.getDefault())
             sdf.timeZone = TimeZone.getTimeZone("Europe/Rome")
 
             return sdf.format(date)
         }
 
         private const val DEBUG_TAG = "BusTO-AlertsFragment"
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/it/reyboz/bustorino/fragments/BackupImportFragment.kt b/app/src/main/java/it/reyboz/bustorino/fragments/BackupImportFragment.kt
index ed3573f..c5989c8 100644
--- a/app/src/main/java/it/reyboz/bustorino/fragments/BackupImportFragment.kt
+++ b/app/src/main/java/it/reyboz/bustorino/fragments/BackupImportFragment.kt
@@ -1,297 +1,314 @@
+/*
+	BusTO  - Fragments components
+    Copyright (C) 2024 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.app.Activity
 import android.content.Intent
 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.widget.Button
 import android.widget.CheckBox
 import android.widget.Toast
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.fragment.app.Fragment
 import de.siegmar.fastcsv.reader.CsvReader
 import de.siegmar.fastcsv.writer.CsvWriter
 import it.reyboz.bustorino.R
 import it.reyboz.bustorino.data.PreferencesHolder
 import it.reyboz.bustorino.data.UserDB
 import it.reyboz.bustorino.util.ImportExport
 import java.io.*
 import java.text.DateFormat
 import java.text.SimpleDateFormat
 import java.util.*
 import java.util.zip.ZipEntry
 import java.util.zip.ZipInputStream
 import java.util.zip.ZipOutputStream
 
 
 /**
  * A simple [Fragment] subclass.
  * Use the [BackupImportFragment.newInstance] factory method to
  * create an instance of this fragment.
  */
 class BackupImportFragment : Fragment() {
 
     private val saveFileLauncher =
         registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
             if (result.resultCode == Activity.RESULT_OK) {
                 result.data?.data?.also { uri ->
                     writeDataZip(uri)
                 }
             }
         }
 
     private val openFileLauncher =
         registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
             if (!(loadFavorites|| loadPreferences)){
                 Toast.makeText(context, R.string.message_check_at_least_one, Toast.LENGTH_SHORT).show()
             }
             else if (result.resultCode == Activity.RESULT_OK) {
                 result.data?.data?.also { uri ->
                     loadZipData(uri,loadFavorites, loadPreferences)
                 }
             }
         }
 
 
     private lateinit var saveButton: Button
     private var loadFavorites = true
     private var loadPreferences = true
     private lateinit var checkFavorites: CheckBox
     private lateinit var checkPreferences: CheckBox
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         /*arguments?.let {
             param1 = it.getString(ARG_PARAM1)
             param2 = it.getString(ARG_PARAM2)
         }*/
     }
 
 
 
     override fun onCreateView(
         inflater: LayoutInflater, container: ViewGroup?,
         savedInstanceState: Bundle?
     ): View? {
         // Inflate the layout for this fragment
         val rootview= inflater.inflate(R.layout.fragment_test_saving, container, false)
 
         saveButton = rootview.findViewById(R.id.saveButton)
         saveButton.setOnClickListener {
             startFileSaveIntent()
         }
         checkFavorites = rootview.findViewById(R.id.favoritesCheckBox)
         checkFavorites.setOnCheckedChangeListener { _, isChecked ->
             loadFavorites = isChecked
 
         }
         checkPreferences = rootview.findViewById(R.id.preferencesCheckBox)
         checkPreferences.setOnCheckedChangeListener { _, isChecked ->
             loadPreferences = isChecked
 
         }
         val readFavoritesButton = rootview.findViewById<Button>(R.id.loadDataButton)
         readFavoritesButton.setOnClickListener {
             startOpenCSVIntent()
         }
 
 
         return rootview
     }
     private fun startFileSaveIntent() {
         val intent = Intent(Intent.ACTION_CREATE_DOCUMENT).apply {
             addCategory(Intent.CATEGORY_OPENABLE)
             val day_string = getCurrentDateString()
             type = "application/zip" //"text/csv" // Set MIME type to CSV
             putExtra(Intent.EXTRA_TITLE, "busto_data_${day_string}.zip") // Default file name
             // Optionally, specify a URI for the directory that should be opened in
             // the system file picker before your app creates the document.
             //putExtra(DocumentsContract.EXTRA_INITIAL_URI, pickerInitialUri)
         }
         saveFileLauncher.launch(intent)
     }
 
     private fun writeCsv(uri: Uri){
         val context = context ?: return
         val contentResolver = context.contentResolver
         contentResolver.openOutputStream(uri)?.use {
             OutputStreamWriter(it).use {wr->
                 val csvWriter = CsvWriter.builder().build(wr)
                 val userDB = UserDB.getInstance(context)
                 userDB.writeFavoritesToCsv(csvWriter)
                 csvWriter.close()
                 Toast.makeText(context, R.string.saved_data, Toast.LENGTH_SHORT).show()
             }
 
         }
     }
     private fun writeStringToZipOS(string: String, zipOutputStream: ZipOutputStream){
         val bais = ByteArrayInputStream(string.toByteArray())
         val bytes = ByteArray(1024)
         var length: Int
         while ((bais.read(bytes).also { length = it }) >= 0) {
             zipOutputStream.write(bytes, 0, length)
         }
     }
 
     private fun readFileToString(zipInputStream: ZipInputStream): String{
         val buffer = ByteArrayOutputStream()
         val data = ByteArray(1024)
         var count: Int
         // Read the content of the specific entry into the buffer
         while (zipInputStream.read(data, 0, data.size).also { count = it } != -1) {
             buffer.write(data, 0, count)
         }
         // Convert the buffer's content to a string
         return buffer.toString()
     }
 
     private fun writeDataZip(uri: Uri){
         val context = context ?: return
         val contentResolver = context.contentResolver
         contentResolver.openOutputStream(uri)?.use {outs ->
             val bof = BufferedOutputStream(outs)
             val zipOutputStream = ZipOutputStream(bof)
 
             //write main preferences
             zipOutputStream.putNextEntry(ZipEntry(MAIN_PREF_NAME))
             var sharedPrefs = PreferencesHolder.getMainSharedPreferences(context)
             var jsonPref = ImportExport.writeSharedPreferencesIntoJSON(sharedPrefs)
             writeStringToZipOS(jsonPref.toString(2), zipOutputStream)
             zipOutputStream.closeEntry()
 
             zipOutputStream.putNextEntry(ZipEntry(APP_PREF_NAME))
             sharedPrefs = PreferencesHolder.getAppPreferences(context)
             jsonPref = ImportExport.writeSharedPreferencesIntoJSON(sharedPrefs)
             writeStringToZipOS(jsonPref.toString(2), zipOutputStream)
             zipOutputStream.closeEntry()
             //add CSV
             zipOutputStream.putNextEntry(ZipEntry(FAVORITES_NAME))
             val outWriter = OutputStreamWriter(zipOutputStream)
             val csvWriter = CsvWriter.builder().build(outWriter)
             val userDB = UserDB.getInstance(context)
             userDB.writeFavoritesToCsv(csvWriter)
             outWriter.flush()
             zipOutputStream.closeEntry()
 
             zipOutputStream.close()
 
             Toast.makeText(context, R.string.saved_data, Toast.LENGTH_SHORT).show()
         }
     }
     private fun loadZipData(uri: Uri, loadFavorites: Boolean, loadPreferences: Boolean){
         val context = context ?: return
         val contentResolver = context.contentResolver
         contentResolver.openInputStream(uri)?.use {ins->
             ZipInputStream(ins).use {zipstream->
                 var entry: ZipEntry? = zipstream.nextEntry
 
                 while (entry != null) {
                     Log.d("testSavingFragment", "read file: ${entry.name}")
                     when (entry.name){
                         FAVORITES_NAME -> if (loadFavorites) {
 
                             val reader = InputStreamReader(zipstream)
                             val csvReader = CsvReader.builder().ofCsvRecord(reader)
 
                             val userDB =  UserDB.getInstance(context)
                             val updated = userDB.insertRowsFromCSV(csvReader)
 
                             //userDB.close()
                             //csvReader.close()
                             Log.d(DEBUG_TAG, "Inserted $updated rows into UserDB - Favorites")
                         }
                         APP_PREF_NAME -> if(loadPreferences){
                             val jsonString = readFileToString(zipstream)
                             try {
                                 val pref = PreferencesHolder.getAppPreferences(context)
                                 ImportExport.importJsonToSharedPreferences(pref, jsonString, null, Regex("osmdroid\\."))
                             } catch (e: Exception){
                                 Log.e(DEBUG_TAG, "Cannot read app preferences from file")
                                 e.printStackTrace()
                             }
                         }
                         //Main preferences contains the lines favorites
                         MAIN_PREF_NAME -> if(loadFavorites){
                             val jsonString = readFileToString(zipstream)
                             try {
                                 val pref = PreferencesHolder.getMainSharedPreferences(context)
                                 //In the future, if we move the favorite lines to a different file,
                                 // We should check here if the key is in the jsonObject, and copy it to the other file
                                 ImportExport.importJsonToSharedPreferences(pref, jsonString, PreferencesHolder.IGNORE_KEYS_LOAD_MAIN, null,
                                     PreferencesHolder.KEYS_MERGE_SET)
                             } catch (e: Exception){
                                 Log.e(DEBUG_TAG, "Cannot read main preferences from file")
                                 e.printStackTrace()
                             }
                         }
                     }
                     //load new entry
                     entry = zipstream.nextEntry
                 }
 
             }
             Toast.makeText(context, R.string.data_imported_backup, Toast.LENGTH_SHORT).show()
         }
 
     }
 
     ///OPEN CSV
     private fun startOpenCSVIntent(){
         val intent= Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
             addCategory(Intent.CATEGORY_OPENABLE)
             type = "application/zip" // Set MIME type
             // Optionally, specify a URI for the directory that should be opened in
             // the system file picker before your app creates the document.
             //putExtra(DocumentsContract.EXTRA_INITIAL_URI, pickerInitialUri)
         }
         openFileLauncher.launch(intent)
     }
 
     private fun importCSVIntoFavorites(uri: Uri){
         val context = context ?: return
         val contentResolver = context.contentResolver
         contentResolver.openInputStream(uri)?.use {
             InputStreamReader(it).use { stream ->
                 val csvReader = CsvReader.builder().ofCsvRecord(stream)
 
                 val userDB =  UserDB.getInstance(context)
                 val updated = userDB.insertRowsFromCSV(csvReader)
                 Toast.makeText(context, "Read $updated favorites", Toast.LENGTH_SHORT).show()
                 //userDB.close()
                 csvReader.close()
             }
         }
     }
 
     companion object {
 
         const val FILE_SAVE = "favorites.csv"
         const val DEBUG_TAG ="BusTO-TestSave"
 
         const val FAVORITES_NAME = "favorites.csv"
         const val MAIN_PREF_NAME = "preferences_main.json"
         const val APP_PREF_NAME = "preferences_app.json"
 
         @JvmStatic
         fun newInstance() =
             BackupImportFragment().apply {
                 arguments = Bundle() /*.apply {
                     putString(ARG_PARAM1, param1)
                     putString(ARG_PARAM2, param2)
                 }
                 */
             }
 
         fun getCurrentDateString(): String{
 
             val dateFormat: DateFormat = SimpleDateFormat("yyyy-MM-dd", Locale.ITALY)
             val date = Date()
             return  dateFormat.format(date)
         }
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/it/reyboz/bustorino/fragments/GeneralMapLibreFragment.kt b/app/src/main/java/it/reyboz/bustorino/fragments/GeneralMapLibreFragment.kt
index f0e8829..b863c3a 100644
--- a/app/src/main/java/it/reyboz/bustorino/fragments/GeneralMapLibreFragment.kt
+++ b/app/src/main/java/it/reyboz/bustorino/fragments/GeneralMapLibreFragment.kt
@@ -1,955 +1,1150 @@
+/*
+	BusTO  - Fragments components
+    Copyright (C) 2025 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.ValueAnimator
 import android.annotation.SuppressLint
 import android.content.Context
 import android.content.Context.LOCATION_SERVICE
 import android.content.SharedPreferences
 import android.content.res.ColorStateList
 import android.graphics.Color
 import android.location.Location
 import android.location.LocationManager
 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.ImageButton
 import android.widget.ImageView
 import android.widget.RelativeLayout
 import android.widget.TextView
+import android.widget.Toast
+import androidx.activity.result.ActivityResultCallback
+import androidx.activity.result.contract.ActivityResultContracts
 import androidx.cardview.widget.CardView
 import androidx.core.content.ContextCompat
 import androidx.core.content.res.ResourcesCompat
 import androidx.core.view.ViewCompat
 import androidx.fragment.app.activityViewModels
 import androidx.fragment.app.viewModels
 import androidx.lifecycle.lifecycleScope
 import com.google.android.material.bottomsheet.BottomSheetBehavior
 import com.google.gson.JsonObject
+import it.reyboz.bustorino.BuildConfig
 import it.reyboz.bustorino.R
 import it.reyboz.bustorino.backend.FiveTNormalizer
 import it.reyboz.bustorino.backend.LivePositionTripPattern
 import it.reyboz.bustorino.backend.LivePositionsServiceStatus
 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.utils
 import it.reyboz.bustorino.data.PreferencesHolder
 import it.reyboz.bustorino.data.gtfs.TripAndPatternWithStops
+import it.reyboz.bustorino.map.MapLibreLocationEngine
 import it.reyboz.bustorino.map.MapLibreUtils
+import it.reyboz.bustorino.middleware.FusedNativeLocationProvider
+import it.reyboz.bustorino.util.Permissions
 import it.reyboz.bustorino.util.ViewUtils
 import it.reyboz.bustorino.viewmodels.LivePositionsViewModel
 import it.reyboz.bustorino.viewmodels.MapStateViewModel
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import org.maplibre.android.MapLibre
 import org.maplibre.android.camera.CameraPosition
 import org.maplibre.android.geometry.LatLng
 import org.maplibre.android.location.LocationComponent
-import org.maplibre.android.location.LocationComponentOptions
+import org.maplibre.android.location.LocationComponentActivationOptions
+import org.maplibre.android.location.engine.LocationEngineCallback
+import org.maplibre.android.location.engine.LocationEngineRequest
+import org.maplibre.android.location.engine.LocationEngineResult
 import org.maplibre.android.maps.MapLibreMap
 import org.maplibre.android.maps.MapView
 import org.maplibre.android.maps.OnMapReadyCallback
 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.Property.ICON_ANCHOR_CENTER
 import org.maplibre.android.style.layers.Property.ICON_ROTATION_ALIGNMENT_MAP
 import org.maplibre.android.style.layers.Property.TEXT_ANCHOR_CENTER
 import org.maplibre.android.style.layers.Property.TEXT_ROTATION_ALIGNMENT_VIEWPORT
 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.Point
+import kotlin.time.Duration.Companion.milliseconds
 
 abstract class GeneralMapLibreFragment: ScreenBaseFragment(), OnMapReadyCallback {
     protected var map: MapLibreMap? = null
     protected var shownStopInBottomSheet : Stop? = null
     //protected var savedMapStateOnPause : Bundle? = null
 
 
     protected var fragmentListener: CommonFragmentListener? = null
 
     // Declare a variable for MapView
     protected lateinit var mapView: MapView
     protected lateinit var mapStyle: Style
     protected lateinit var stopsSource: GeoJsonSource
     protected lateinit var busesSource: GeoJsonSource
     protected lateinit var selectedStopSource: GeoJsonSource
     protected lateinit var selectedBusSource: GeoJsonSource //= GeoJsonSource(SEL_BUS_SOURCE)
 
     protected lateinit var sharedPreferences: SharedPreferences
     protected lateinit var bottomSheetBehavior: BottomSheetBehavior<RelativeLayout>
 
+    protected var locationEngine: MapLibreLocationEngine? = null
+    protected lateinit var locationProvider: FusedNativeLocationProvider
+
+    protected var shownToastNoPosition = false
+
 
     private val preferenceChangeListener = SharedPreferences.OnSharedPreferenceChangeListener(){ pref, key ->
         /*when(key){
             SettingsFragment.LIBREMAP_STYLE_PREF_KEY -> reloadMap()
         }
 
          */
         if(key == SettingsFragment.LIBREMAP_STYLE_PREF_KEY){
             Log.d(DEBUG_TAG,"ASKING RELOAD OF MAP")
 
             reloadMap()
         }
     }
+
+    protected val positionRequestResponder = registerForActivityResult(
+        ActivityResultContracts.RequestMultiplePermissions(), ActivityResultCallback{ res ->
+            if(!(res.containsKey(PERM_LOC_COARSE)&&res.containsKey(PERM_LOC_FINE))){
+                Log.e(DEBUG_TAG, "Location request does not have the correct keys")
+            } else if(res[PERM_LOC_COARSE]!! && res[PERM_LOC_FINE]!!){
+                //permission OK, init map location
+                val mMap = map
+                if(mMap == null){
+                    Log.w(DEBUG_TAG, "Location request completed, but map is null!")
+                }else{
+                    initializeMapLocationComponent(mMap,requireContext(), null)
+                }
+            } else{
+                // PERMISSION DENIED
+                // TODO find better way to show the necessity of the permission
+                if(shouldShowRequestPermissionRationale(PERM_LOC_FINE))
+                    Toast.makeText(requireContext(),
+                        R.string.enable_position_message_map, Toast.LENGTH_SHORT).show()
+            }
+        }
+    )
     //Bottom sheet behavior in GeneralMapLibreFragment
     protected var bottomLayout: RelativeLayout? = null
     protected lateinit var stopTitleTextView: TextView
     protected lateinit var stopNumberTextView: TextView
     protected lateinit var linesPassingTextView: TextView
     protected lateinit var extraBottomTextView: TextView
     protected lateinit var arrivalsCard: CardView
     protected lateinit var directionsCard: CardView
     protected lateinit var bottomrightImage: ImageView
     protected lateinit var locationComponent: LocationComponent
     protected lateinit var busPositionsIconButton: ImageButton
 
     protected var lastLocation : Location? = null
 
 
     private var lastMapStyle =""
 
     //BUS POSITIONS
     protected val updatesByVehDict = HashMap<String, LivePositionTripPattern>(5)
     protected val animatorsByVeh = HashMap<String, ValueAnimator>()
     protected var vehShowing = ""
     protected var lastUpdateTime:Long = -2
 
     private val lifecycleOwnerLiveData = getViewLifecycleOwnerLiveData()
 
 
     //extra items to use the LibreMap
     protected var symbolManager : SymbolManager? = null
     protected var stopActiveSymbol: Symbol? = null
     protected var stopsLayerStarted = false
     protected val livePositionsViewModel : LivePositionsViewModel by activityViewModels()
 
     //private lateinit var symbolManager: SymbolManager
     protected val mapStateViewModel: MapStateViewModel by viewModels()
+    protected var locationInitialized = false
+    protected var mapInitialized = false
+    protected var receivedFirstLocation = false
+
+
+    //location callback to decide if to zoom to the user position
+    @SuppressLint("MissingPermission")
+    protected val mapLibreLocationCallback = object : LocationEngineCallback<LocationEngineResult> {
+        override fun onSuccess(result: LocationEngineResult) {
+            val location: Location? = result.lastLocation
+            Log.d(DEBUG_TAG, "Received location $location")
+            location?.let {
+                //check timing of the location
+                val currentTime = System.currentTimeMillis()
+                val discard = (currentTime - it.time) > 90 * 1000.0  // discard if it is Older than 60 seconds
+                if(!discard) {
+                    if (!receivedFirstLocation) {
+                        onFirstReceivedLocation(it)
+                    }
+                    receivedFirstLocation = true
+                }
+            }
 
+            if(receivedFirstLocation){
+                //remove this
+                locationEngine?.removeLocationUpdates(this)
+            }
+        }
+
+        override fun onFailure(exception: Exception) {
+            Log.e(DEBUG_TAG, "Error in getting position: ${exception.message}")
+        }
+    }
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
         //sharedPreferences = PreferenceManager.getDefaultSharedPreferences(requireContext())
         lastMapStyle = PreferencesHolder.getMapLibreStyleFile(requireContext())
 
         //init map
         MapLibre.getInstance(requireContext())
 
     }
 
     override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
         lastMapStyle = PreferencesHolder.getMapLibreStyleFile(requireContext())
         Log.d(DEBUG_TAG, "onCreateView lastMapStyle: $lastMapStyle")
         return super.onCreateView(inflater, container, savedInstanceState)
     }
 
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
         super.onViewCreated(view, savedInstanceState)
 
         //init bottom sheet
         val bottomSheet = view.findViewById<RelativeLayout>(R.id.bottom_sheet)
         bottomLayout = bottomSheet
         stopTitleTextView = view.findViewById(R.id.stopTitleTextView)
         stopNumberTextView = view.findViewById(R.id.stopNumberTextView)
         linesPassingTextView = view.findViewById(R.id.linesPassingTextView)
         arrivalsCard = view.findViewById(R.id.arrivalsCardButton)
         directionsCard = view.findViewById(R.id.directionsCardButton)
         bottomrightImage = view.findViewById(R.id.rightmostImageView)
         bottomSheetBehavior = BottomSheetBehavior.from(bottomSheet)
         extraBottomTextView = view.findViewById(R.id.extraBottomTextView)
 
         bottomSheetBehavior.state = BottomSheetBehavior.STATE_HIDDEN
     }
 
     override fun onResume() {
         mapView.onResume()
         super.onResume()
         val newMapStyle = PreferencesHolder.getMapLibreStyleFile(requireContext())
         Log.d(DEBUG_TAG, "onResume newMapStyle: $newMapStyle, lastMapStyle: $lastMapStyle")
         if(newMapStyle!=lastMapStyle){
             reloadMap()
         }
     }
 
+
+
     @Deprecated("Deprecated in Java")
     override fun onLowMemory() {
         mapView.onLowMemory()
         super.onLowMemory()
     }
 
     override fun onStart() {
         super.onStart()
         mapView.onStart()
     }
 
     override fun onDestroy() {
         mapView.onDestroy()
         Log.d(DEBUG_TAG, "Destroyed mapView Fragment!!")
         super.onDestroy()
     }
 
     override fun onDestroyView() {
         bottomLayout = null
         super.onDestroyView()
     }
 
     protected fun reloadMap(){
         /*map?.let {
             Log.d("GeneralMapFragment", "RELOADING MAP")
             //save map state
             savedMapStateOnPause = saveMapStateInBundle()
 
             onMapDestroy()
             //Destroy and recreate MAP
             mapView.onDestroy()
             mapView.onCreate(null)
             mapView.getMapAsync(this)
         }
 
          */
         //TODO figure out how to switch map safely
     }
 
     //For extra stuff to do when the map is destroyed
     abstract fun onMapDestroy()
 
     override fun onAttach(context: Context) {
         super.onAttach(context)
         if(context is CommonFragmentListener){
             fragmentListener = context
         } else throw RuntimeException("$context must implement CommonFragmentListener")
 
     }
     /*
     protected fun restoreMapStateFromBundle(bundle: Bundle): Boolean{
         val nullDouble = -10_000.0
         var boundsRestored =false
         val latCenter = bundle.getDouble("center_map_lat", nullDouble)
         val lonCenter = bundle.getDouble("center_map_lon",nullDouble)
         val zoom = bundle.getDouble("map_zoom", nullDouble)
         val bearing = bundle.getDouble("map_bearing", nullDouble)
         val tilt = bundle.getDouble("map_tilt", nullDouble)
         if(lonCenter!=nullDouble &&latCenter!=nullDouble) map?.let {
             val center = LatLng(latCenter, lonCenter)
             val newPos = CameraPosition.Builder().target(center)
             if(zoom>0) newPos.zoom(zoom)
             if(bearing!=nullDouble) newPos.bearing(bearing)
             if(tilt != nullDouble) newPos.tilt(tilt)
             it.cameraPosition=newPos.build()
 
             Log.d(DEBUG_TAG, "Restored map state from Bundle, center: $center, zoom: $zoom, bearing $bearing, tilt $tilt")
             boundsRestored =true
         } else{
             Log.d(DEBUG_TAG, "Not restoring map state, center: $latCenter,$lonCenter; zoom: $zoom, bearing: $bearing, tilt $tilt")
         }
         val mStop = bundle.getBundle("shown_stop")?.let {
             Stop.fromBundle(it)
         }
         mStop?.let { openStopInBottomSheet(it) }
         return boundsRestored
     }
 
     protected fun saveMapStateBeforePause(bundle: Bundle){
         map?.let {
             val newBbox = it.projection.visibleRegion.latLngBounds
 
 
             val cp = it.cameraPosition
             bundle.putDouble("center_map_lat", newBbox.center.latitude)
             bundle.putDouble("center_map_lon", newBbox.center.longitude)
             it.cameraPosition.zoom.let { z-> bundle.putDouble("map_zoom",z) }
             bundle.putDouble("map_bearing",cp.bearing)
             bundle.putDouble("map_tilt", cp.tilt)
 
             val locationComponent = it.locationComponent
             bundle.putBoolean(KEY_LOCATION_ENABLED,locationComponent.isLocationComponentEnabled)
             bundle.putParcelable("last_location", locationComponent.lastKnownLocation)
         }
         shownStopInBottomSheet?.let {
             bundle.putBundle("shown_stop", it.toBundle())
         }
     }
 
     protected fun saveMapStateInBundle(): Bundle {
         val b = Bundle()
         saveMapStateBeforePause(b)
         return b
     }
 
      */
 
     protected fun stopToGeoJsonFeature(s: Stop): Feature{
         return Feature.fromGeometry(
             Point.fromLngLat(s.longitude!!, s.latitude!!),
             JsonObject().apply {
                 addProperty("id", s.ID)
                 addProperty("name", s.stopDefaultName)
                 //addProperty("routes", s.routesThatStopHereToString()) // Add routes array to JSON object
             }
         )
     }
     protected fun isPointInsideVisibleRegion(p: LatLng, other: Boolean): Boolean{
         val bounds = map?.projection?.visibleRegion?.latLngBounds
         var inside = other
         bounds?.let { inside = it.contains(p) }
         return inside
     }
 
     protected fun isPointInsideVisibleRegion(lat: Double, lon: Double, other: Boolean): Boolean{
         val p = LatLng(lat, lon)
         return isPointInsideVisibleRegion(p, other)
     }
 
 
     protected fun removeVehiclesData(vehs: List<String>){
         for(v in vehs){
             if (updatesByVehDict.contains(v)) {
                 updatesByVehDict.remove(v)
                 if (animatorsByVeh.contains(v)){
                     animatorsByVeh[v]?.cancel()
                     animatorsByVeh.remove(v)
                 }
             }
             if (vehShowing==v){
                 hideStopOrBusBottomSheet()
             }
         }
     }
 
     // Hide the bottom sheet and remove extra symbol
     protected open fun hideStopOrBusBottomSheet(){
         if (stopActiveSymbol!=null){
             symbolManager?.delete(stopActiveSymbol)
             stopActiveSymbol = null
         }
         if(!showOpenStopWithSymbolLayer()){
             selectedStopSource.setGeoJson(FeatureCollection.fromFeatures(ArrayList<Feature>()))
         }
         bottomSheetBehavior.state = BottomSheetBehavior.STATE_HIDDEN
         //isBottomSheetShowing = false
 
         //reset states
         shownStopInBottomSheet = null
         if (vehShowing!=""){
             //we are hiding a vehicle
             vehShowing = ""
             updatePositionsIcons(true)
         }
         extraBottomTextView.visibility = View.GONE
 
     }
 
     protected fun initSymbolManager(mapReady: MapLibreMap , style: Style){
         val sm = SymbolManager(mapView, mapReady, style)
         sm.iconAllowOverlap = true
         sm.textAllowOverlap = false
         sm.addClickListener { _ ->
             if (stopActiveSymbol != null) {
                 hideStopOrBusBottomSheet()
                 return@addClickListener true
             } else
                 return@addClickListener false
         }
         symbolManager = sm
     }
 
     /**
      * Change the icon indicating the status of the live Positions
      */
     protected fun setBusPositionsIcon(enabled: Boolean, error: Boolean){
         val ctx = requireContext()
         if(!enabled)
             busPositionsIconButton.setImageDrawable(ContextCompat.getDrawable(ctx, R.drawable.bus_pos_circle_inactive))
         else if(error)
             busPositionsIconButton.setImageDrawable(ContextCompat.getDrawable(ctx, R.drawable.bus_pos_circle_notworking))
         else
             busPositionsIconButton.setImageDrawable(ContextCompat.getDrawable(ctx, R.drawable.bus_pos_circle_active))
 
     }
 
-    /**
-     * Initialize the map location, but do not enable the component
-     */
+
+    abstract fun onMapLocationComponentInitialized()
+
     @SuppressLint("MissingPermission")
-    protected 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
+    protected fun setLocationComponentEnabled(enabled: Boolean): Boolean{
+        var changed = false
+        map?.apply {
+            if(locationComponent.isLocationComponentEnabled !=enabled)
+            locationComponent.isLocationComponentEnabled= enabled
+        changed = true}
+
+        return changed
+    }
 
-        lastLocation?.let {
-            if (it.accuracy < 200)
-                locationComponent.forceLocationUpdate(it)
+    @SuppressLint("MissingPermission")
+    protected fun initializeMapLocationComponent(map: MapLibreMap, context: Context, style: Style?){
+        val mStyle = style ?: map.style
+        if(locationInitialized){
+            Log.w(DEBUG_TAG, "trying to initialize Location Component, but it is already done")
+            return
+        }
+        mStyle?.let{ style ->
+            locationComponent = map.locationComponent
+
+            locationProvider = FusedNativeLocationProvider(context)
+            locationEngine = MapLibreLocationEngine(locationProvider)
+            val options = LocationComponentActivationOptions.builder(context, style)
+                .useDefaultLocationEngine(false)
+                .locationEngine(locationEngine)
+                .build()
+            locationComponent.activateLocationComponent(options)
+            //locationComponent.cameraMode = CameraMode.TRACKING
+            //locationComponent.renderMode = RenderMode.COMPASS
+            locationInitialized = true
+            if(BuildConfig.DEBUG) Log.d(DEBUG_TAG, "Requesting location updates")
+            locationEngine!!.requestLocationUpdates(LocationEngineRequest.Builder(500).setDisplacement(20.0f).build(),
+                    mapLibreLocationCallback, null)
+            // signal to show user location icon as active
+            mapStateViewModel.locationActive.value = true
+            setLocationComponentEnabled(true)
+            onMapLocationComponentInitialized()
         }
     }
 
 
     /**
      * Update function for the bus positions
      * Takes the processed updates and saves them accordingly
      * Unified version that works with both fragments
      *
      * @param incomingData Map of updates with optional trip and pattern information
-     * @param checkCoordinateValidity If true, validates that coordinates are positive (default: false)
      * @param hasVehicleTracking If true, checks if vehShowing is updated and calls callback (default: true)
      * @param trackVehicleCallback Optional callback to show vehicle details when vehShowing is updated
      */
     protected fun updateBusPositionsInMap(
         incomingData: HashMap<String, Pair<LivePositionUpdate,TripAndPatternWithStops?>>,
         hasVehicleTracking: Boolean = false,
         trackVehicleCallback: ((String) -> Unit)? = null
     ) {
         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
         var createdVehs = 0
 
         for (upsWithTrp in incomingData.values) {
             val newPos = upsWithTrp.first
             val patternStops = upsWithTrp.second
             val vehID = newPos.vehicle
 
             // Validate coordinates
             if (!vehsOld.contains(vehID)) {
                 if (newPos.latitude <= 0 || newPos.longitude <= 0) {
                     Log.w(DEBUG_TAG, "Update ignored for veh $vehID on line ${newPos.routeID}, lat: ${newPos.latitude}, lon ${newPos.longitude}")
                     continue
                 }
             }
 
             if (vehsOld.contains(vehID)) {
                 // Changing the location of an existing bus
                 val oldPosData = updatesByVehDict[vehID]!!
                 val oldPos = oldPosData.posUpdate
                 val oldPattern = oldPosData.pattern
 
                 var avoidShowingUpdateBecauseIsImpossible = false
 
                 // Check for impossible route changes
                 if (oldPos.routeID != newPos.routeID) {
                     val dist = LatLng(oldPos.latitude, oldPos.longitude).distanceTo(
                         LatLng(newPos.latitude, newPos.longitude)
                     )
                     val speed = dist * 3.6 / (newPos.timestamp - oldPos.timestamp) // km/h
                     Log.w(DEBUG_TAG, "Vehicle $vehID changed route from ${oldPos.routeID} to ${newPos.routeID}, distance: $dist, speed: $speed")
                     if (speed > 120 || speed < 0) {
                         avoidShowingUpdateBecauseIsImpossible = true
                     }
                 }
 
                 if (avoidShowingUpdateBecauseIsImpossible) {
                     Log.w(DEBUG_TAG, "Update for vehicle $vehID skipped")
                     continue
                 }
 
                 // Check if position actually changed
                 val samePosition = (oldPos.latitude == newPos.latitude) &&
                         (oldPos.longitude == newPos.longitude)
 
                 val setPattern = (oldPattern == null) && (patternStops != null)
 
                 // Copy old bearing if new one is missing
                 if (newPos.bearing == null && oldPos.bearing != null) {
                     newPos.bearing = oldPos.bearing
                 }
 
                 if (!samePosition || setPattern) {
                     val newOrOldPosInBounds = isPointInsideVisibleRegion(
                         newPos.latitude, newPos.longitude, true
                     ) || isPointInsideVisibleRegion(oldPos.latitude, oldPos.longitude, true)
 
                     if (newOrOldPosInBounds) {
                         // Update pattern data if available
                         patternStops?.let {
                             updatesByVehDict[vehID]!!.pattern = it.pattern
                         }
                         // Animate the position change
                         animateNewPositionMove(newPos)
                     } else {
                         // Update position without animation
                         updatesByVehDict[vehID] = LivePositionTripPattern(
                             newPos,
                             patternStops?.pattern
                         )
                     }
                 }
                 countUpds++
             } else {
                 // New vehicle - create entry
                 updatesByVehDict[vehID] = LivePositionTripPattern(
                     newPos,
                     patternStops?.pattern
                 )
                 createdVehs++
             }
 
             // Update vehicle details if this is the shown/tracked vehicle
             if (hasVehicleTracking && vehShowing.isNotEmpty() && vehID == vehShowing) {
                 trackVehicleCallback?.invoke(vehID)
             }
         }
 
         // Remove old positions
         Log.d(DEBUG_TAG, "Updated $countUpds vehicles, created $createdVehs vehicles")
         vehsOld.removeAll(vehsNew)
 
         // Clean up stale vehicles (not updated for 2 minutes)
         val currentTimeStamp = System.currentTimeMillis() / 1000
         for (vehID in vehsOld) {
             val posData = updatesByVehDict[vehID]!!
             if (currentTimeStamp - posData.posUpdate.timestamp > 2 * 60) {
                 // Remove the bus
                 updatesByVehDict.remove(vehID)
                 // Cancel and remove animator if exists
                 animatorsByVeh[vehID]?.cancel()
                 animatorsByVeh.remove(vehID)
             }
         }
 
         // Update UI
         updatePositionsIcons(false)
     }
 
     /**
      * Shared bottom sheet setup. The [onDirectionsClick] lambda is called when
      * directionsCard is tapped; it receives the pattern code (empty string when
      * no pattern is available) so each subclass can navigate as it sees fit.
      */
     protected fun showVehicleTripInBottomSheet(
         veh: String,
         onDirectionsClick: (patternCode: String, veh: String) -> Unit
     ) {
         val data = updatesByVehDict[veh] ?: run {
             Log.w(DEBUG_TAG, "Asked to show vehicle $veh, but it's not present in the updates")
             return
         }
         bottomLayout?.let {
             val lineName = FiveTNormalizer.fixShortNameForDisplay(
                 GtfsUtils.getLineNameFromGtfsID(data.posUpdate.routeID), false
             )
             val pat = data.pattern
             if (pat != null) {
                 stopTitleTextView.text = pat.headsign
                 stopTitleTextView.visibility = View.VISIBLE
                 stopNumberTextView.text = getString(R.string.line_fill_towards, lineName)
             } else {
                 stopTitleTextView.visibility = View.GONE
                 stopNumberTextView.text = getString(R.string.line_fill, lineName)
             }
             directionsCard.setOnClickListener {
                 onDirectionsClick(pat?.code ?: "", veh)
             }
             directionsCard.visibility = View.VISIBLE
             bottomrightImage.setImageDrawable(
                 ResourcesCompat.getDrawable(resources, R.drawable.ic_magnifying_glass, activity?.theme)
             )
             val colorBlue = ResourcesCompat.getColor(resources, R.color.blue_500, activity?.theme)
             ViewCompat.setBackgroundTintList(directionsCard, ColorStateList.valueOf(colorBlue))
             linesPassingTextView.text = getString(R.string.vehicle_fill, data.posUpdate.vehicle)
             arrivalsCard.visibility = View.GONE
 
             extraBottomTextView.text = getString(R.string.updated_fill,  utils.unixTimestampToLocalTime(data.posUpdate.timestamp))
             extraBottomTextView.visibility = View.VISIBLE
         }
         vehShowing = veh
         bottomSheetBehavior.state = BottomSheetBehavior.STATE_EXPANDED
         updatePositionsIcons(true)
         Log.d(DEBUG_TAG, "Shown vehicle $veh in bottom sheet")
     }
 
     /**
      * Update the bus positions displayed on the map, from the existing data
      *
      * @param forced If true, forces immediate update ignoring the 60ms throttle
      */
     protected fun updatePositionsIcons(forced: Boolean) {
         // Avoid frequent updates - throttle to max once per 60ms
         val currentTime = System.currentTimeMillis()
         if (!forced && currentTime - lastUpdateTime < 60) {
             // Schedule delayed update
             if(lifecycleOwnerLiveData.value != null)
                 viewLifecycleOwner.lifecycleScope.launch {
-                    delay(200)
+                    delay(200.milliseconds)
                     updatePositionsIcons(forced)
                 }
             return
         }
 
         val busFeatures = ArrayList<Feature>()
         val selectedBusFeatures = ArrayList<Feature>()
 
         for (dat in updatesByVehDict.values) {
             val pos = dat.posUpdate
             val point = Point.fromLngLat(pos.longitude, pos.latitude)
 
             val newFeature = Feature.fromGeometry(
                 point,
                 JsonObject().apply {
                     addProperty("veh", pos.vehicle)
                     addProperty("trip", pos.tripID)
                     addProperty("bearing", pos.bearing ?: 0.0f)
                     addProperty("line", pos.routeID.substringBeforeLast('U'))
                 }
             )
 
             // Separate selected vehicle from others
             if (vehShowing.isNotEmpty() && vehShowing == dat.posUpdate.vehicle) {
                 selectedBusFeatures.add(newFeature)
             } else {
                 busFeatures.add(newFeature)
             }
         }
 
         busesSource.setGeoJson(FeatureCollection.fromFeatures(busFeatures))
         selectedBusSource.setGeoJson(FeatureCollection.fromFeatures(selectedBusFeatures))
 
         lastUpdateTime = System.currentTimeMillis()
     }
 
     /**
      * Animates the transition of a vehicle from its current position to a new position
      * This is the tricky part - we need to set the new positions with the data and redraw them all
      *
      * @param positionUpdate The new position update to animate to
      */
     protected fun animateNewPositionMove(positionUpdate: LivePositionUpdate) {
         val vehID = positionUpdate.vehicle
 
         // Check if vehicle exists in our tracking dictionary
         if (vehID !in updatesByVehDict.keys) {
             return
         }
 
         val currentUpdate = updatesByVehDict[vehID] ?: run {
             Log.e(DEBUG_TAG, "Have to run animation for veh $vehID but not in the dict")
             return
         }
 
         // Cancel any current animation for this vehicle
         animatorsByVeh[vehID]?.cancel()
 
         val posUp = currentUpdate.posUpdate
         val currentPos = LatLng(posUp.latitude, posUp.longitude)
         val newPos = LatLng(positionUpdate.latitude, positionUpdate.longitude)
 
         // Create animator for smooth transition
         val valueAnimator = ValueAnimator.ofObject(
             MapLibreUtils.LatLngEvaluator(),
             currentPos,
             newPos
         )
 
         valueAnimator.addUpdateListener { animation ->
             val latLng = animation.animatedValue as LatLng
 
             // Update position during animation
             updatesByVehDict[vehID]?.let { update ->
                 update.posUpdate.latitude = latLng.latitude
                 update.posUpdate.longitude = latLng.longitude
                 updatePositionsIcons(false)
             } ?: run {
                 Log.w(DEBUG_TAG, "The bus position to animate has been removed, but the animator is still running!")
             }
         }
 
         // Set the new position as current but keep old coordinates for animation start
         positionUpdate.latitude = posUp.latitude
         positionUpdate.longitude = posUp.longitude
         updatesByVehDict[vehID]!!.posUpdate = positionUpdate
 
         // Configure and start animation
         valueAnimator.duration = 300
         valueAnimator.interpolator = LinearInterpolator()
         valueAnimator.start()
 
         // Store animator for potential cancellation
         animatorsByVeh[vehID] = valueAnimator
     }
 
     /// STOP OPENING
     abstract fun showOpenStopWithSymbolLayer(): Boolean
     /**
      * Update the bottom sheet with the stop information
      */
     protected 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 = getString(R.string.stop_fill,stop.ID)
             stopTitleTextView.visibility = View.VISIBLE
 
             val string_show = if (stop.numRoutesStopping==0) ""
             else requireContext().getString(R.string.lines_fill, stop.routesThatStopHereToString())
             linesPassingTextView.text = string_show
             linesPassingTextView.visibility = View.VISIBLE
 
             //SET ON CLICK LISTENER
             arrivalsCard.setOnClickListener{
                 fragmentListener?.requestArrivalsForStopID(stop.ID)
             }
 
             arrivalsCard.visibility = View.VISIBLE
             directionsCard.visibility = View.VISIBLE
 
             directionsCard.setOnClickListener {
                 ViewUtils.openStopInOutsideApp(stop, context)
             }
             context?.let {
                 val colorIcon = ViewUtils.getColorFromTheme(it, android.R.attr.colorAccent)//ResourcesCompat.getColor(resources,R.attr.colorAccent,activity?.theme)
                 ViewCompat.setBackgroundTintList(directionsCard, ColorStateList.valueOf(colorIcon))
             }
 
             bottomrightImage.setImageDrawable(ResourcesCompat.getDrawable(resources, R.drawable.navigation_right,  activity?.theme))
 
         }
         //add stop marker
         if (stop.latitude!=null && stop.longitude!=null) {
             Log.d(DEBUG_TAG, "Showing stop: ${stop.ID}")
 
             if (showOpenStopWithSymbolLayer()) {
                 stopActiveSymbol = symbolManager?.create(
                     SymbolOptions()
                         .withLatLng(LatLng(stop.latitude!!, stop.longitude!!))
                         .withIconImage(STOP_ACTIVE_IMG)
                         .withIconAnchor(ICON_ANCHOR_CENTER)
                 )
             } else {
                 val list = ArrayList<Feature>()
                 list.add(stopToGeoJsonFeature(stop))
                 selectedStopSource.setGeoJson(
                     FeatureCollection.fromFeatures(list)
                 )
             }
 
         }
         Log.d(DEBUG_TAG, "Shown stop $stop in bottom sheet")
         shownStopInBottomSheet = stop
 
         bottomSheetBehavior.state = BottomSheetBehavior.STATE_EXPANDED
     }
 
 
 
     protected fun stopAnimations(){
         for(anim in animatorsByVeh.values){
             anim.cancel()
         }
     }
 
     protected fun addImagesStyle(style: Style){
         style.addImage(
             STOP_IMAGE_ID,
             ResourcesCompat.getDrawable(resources,R.drawable.bus_stop_new, activity?.theme)!!)
 
         style.addImage(STOP_ACTIVE_IMG, ResourcesCompat.getDrawable(resources, R.drawable.bus_stop_new_highlight, activity?.theme)!!)
         style.addImage("ball",ResourcesCompat.getDrawable(resources, R.drawable.ball, activity?.theme)!!)
         style.addImage(BUS_IMAGE_ID,ResourcesCompat.getDrawable(resources, R.drawable.map_bus_position_icon, activity?.theme)!!)
         style.addImage(BUS_SEL_IMAGE_ID, ResourcesCompat.getDrawable(resources, R.drawable.map_bus_position_icon_sel, activity?.theme)!!)
         val polyIconArrow = ResourcesCompat.getDrawable(resources, R.drawable.arrow_up_box_fill, activity?.theme)!!
         style.addImage(POLY_ARROW, polyIconArrow)
 
     }
 
     protected fun initStopsLayer(style: Style, stopsFeatures: FeatureCollection?){
         //determine default layer
         var layerAbove = ""
         if (lastMapStyle == MapLibreUtils.STYLE_OSM_RASTER){
             layerAbove = "osm-raster"
         } else if (lastMapStyle == MapLibreUtils.STYLE_VECTOR){
             layerAbove = "symbol-transit-airfield"
         }
         initStopsLayer(style, stopsFeatures, layerAbove)
     }
 
     protected fun initStopsLayer(style: Style, stopsFeatures: FeatureCollection?, stopsLayerAbove: String){
 
 
         stopsSource = GeoJsonSource(STOPS_SOURCE_ID,stopsFeatures ?: FeatureCollection.fromFeatures(ArrayList<Feature>()))
         style.addSource(stopsSource)
 
 
         // Stops layer
         val stopsLayer = SymbolLayer(STOPS_LAYER_ID, STOPS_SOURCE_ID)
         stopsLayer.withProperties(
             PropertyFactory.iconImage(STOP_IMAGE_ID),
             PropertyFactory.iconAnchor(ICON_ANCHOR_CENTER),
             PropertyFactory.iconAllowOverlap(true),
             PropertyFactory.iconIgnorePlacement(true)
             )
 
         style.addLayerAbove(stopsLayer, stopsLayerAbove ) //"label_country_1") this with OSM Bright
 
 
         selectedStopSource = GeoJsonSource(SEL_STOP_SOURCE, FeatureCollection.fromFeatures(ArrayList<Feature>()))
         style.addSource(selectedStopSource)
 
         val selStopLayer = SymbolLayer(SEL_STOP_LAYER, SEL_STOP_SOURCE)
         selStopLayer.withProperties(
             PropertyFactory.iconImage(STOP_ACTIVE_IMG),
             PropertyFactory.iconAllowOverlap(true),
             PropertyFactory.iconIgnorePlacement(true),
             PropertyFactory.iconAnchor(ICON_ANCHOR_CENTER),
 
             )
         style.addLayerAbove(selStopLayer, STOPS_LAYER_ID)
 
         stopsLayerStarted = true
     }
 
     /**
      * Setup the Map Layers
      */
     protected fun setupBusLayer(style: Style, withLabels: Boolean =false, busIconsScale: Float = 1.0f) {
         // 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)!!)
 
         selectedBusSource = GeoJsonSource(SEL_BUS_SOURCE)
         style.addSource(selectedBusSource)
 
         // Buses layer
         val busesLayer = SymbolLayer(BUSES_LAYER_ID, BUSES_SOURCE_ID).apply {
             withProperties(
                 PropertyFactory.iconImage(BUS_IMAGE_ID),
                 PropertyFactory.iconSize(busIconsScale),
                 PropertyFactory.iconAllowOverlap(true),
                 PropertyFactory.iconIgnorePlacement(true),
                 PropertyFactory.iconRotate(Expression.get("bearing")),
                 PropertyFactory.iconRotationAlignment(ICON_ROTATION_ALIGNMENT_MAP)
 
             )
             if (withLabels){
                 withProperties(PropertyFactory.textAnchor(TEXT_ANCHOR_CENTER),
                     PropertyFactory.textAllowOverlap(true),
                     PropertyFactory.textField(Expression.get("line")),
                     PropertyFactory.textColor(Color.WHITE),
                     PropertyFactory.textRotationAlignment(TEXT_ROTATION_ALIGNMENT_VIEWPORT),
                     PropertyFactory.textSize(12f),
                     PropertyFactory.textFont(arrayOf("noto_sans_regular")))
             }
         }
         style.addLayerAbove(busesLayer, STOPS_LAYER_ID)
 
         val selectedBusLayer = SymbolLayer(SEL_BUS_LAYER, SEL_BUS_SOURCE).apply {
             withProperties(
             PropertyFactory.iconImage(BUS_SEL_IMAGE_ID),
             PropertyFactory.iconSize(busIconsScale),
             PropertyFactory.iconAllowOverlap(true),
             PropertyFactory.iconIgnorePlacement(true),
             PropertyFactory.iconRotate(Expression.get("bearing")),
             PropertyFactory.iconRotationAlignment(ICON_ROTATION_ALIGNMENT_MAP)
             )
             if (withLabels){
                 withProperties(PropertyFactory.textAnchor(TEXT_ANCHOR_CENTER),
                     PropertyFactory.textAllowOverlap(true),
                     PropertyFactory.textField(Expression.get("line")),
                     PropertyFactory.textColor(Color.WHITE),
                     PropertyFactory.textRotationAlignment(TEXT_ROTATION_ALIGNMENT_VIEWPORT),
                     PropertyFactory.textSize(12f),
                     PropertyFactory.textFont(arrayOf("noto_sans_regular")))
             }
         }
 
         style.addLayerAbove(selectedBusLayer, BUSES_LAYER_ID)
 
     }
+    /**
+     * Method used for enabling / disabling the location from the buttons
+     */
+    protected fun switchUserLocationStatus(view: View?){
+        val enabled = if(locationInitialized) locationComponent.isLocationComponentEnabled else false
+        val context = context ?: return
+        if(enabled) {
+            setMapLocationEnabled(false)
+            onMapLocationEnabled(false)
+        }
+        else if(deviceHasGpsProvider()) {
+            if(Permissions.bothLocationPermissionsGranted(context)){
+                setMapLocationEnabled(true)
+                onMapLocationEnabled(true)
+            } else{
+                Log.d(DEBUG_TAG, "Requesting permissions to show location")
+                Permissions.getInstance(context).checkRequestLocationPermissions(requireActivity(), positionRequestResponder)
+            }
+        } else{
+            context.let {
+                Toast.makeText(it, R.string.no_gps_on_device, Toast.LENGTH_SHORT).show()
+            }
+        }
+
+    }
+
+    @SuppressLint("MissingPermission")
+    protected fun setMapLocationEnabled(enabled: Boolean){
+        map?.locationComponent?.isLocationComponentEnabled = enabled
+        //map?.cameraPosition =
+        mapStateViewModel.locationActive.value = enabled
+    }
+    protected fun checkInitMapLocation(mapReady: MapLibreMap,style: Style, context: Context) {
+        //enable location
+        val hasGps = deviceHasGpsProvider()
+        val permissions = Permissions.getInstance(context)
+        if(hasGps) {
+            if (Permissions.bothLocationPermissionsGranted(context)) {
+                Log.d(DEBUG_TAG, "Have got the location permission, init location component")
+                initializeMapLocationComponent(mapReady, context, style)
+            }else {
+                var req = false
+                activity?.let{
+                    req = permissions.checkRequestLocationPermissions(it, positionRequestResponder)
+                }
+                //setLocationIconEnabled(false)
+                //setFollowingUser(false)
+                if(!req) {
+                    setMapLocationEnabled(false)
+                    onMapLocationEnabled(false)
+                }
+
+            }
+        }
+    }
+
+    /**
+     * Set the UI elements showing that the user location is disabled
+     */
+    abstract fun onMapLocationEnabled(active: Boolean)
+
+    /**
+     * Helper function to actually set the icon
+     */
+    abstract fun setLocationIconEnabled(enabled: Boolean)
+
+    /**
+     * Called when we receive the first fix on the user location
+     */
+    abstract fun onFirstReceivedLocation(location: Location)
 
     protected fun isBottomSheetShowing(): Boolean {
         return bottomSheetBehavior.state == BottomSheetBehavior.STATE_EXPANDED
     }
 
     protected fun deviceHasGpsProvider(): Boolean{
         val locManager = requireContext().getSystemService(LOCATION_SERVICE) as LocationManager
         return locManager.allProviders.contains(LocationManager.GPS_PROVIDER)
     }
 
     /**
      * Update automatically the icon when the live position service changes status
      */
     protected fun observeStatusLivePositions(){
         livePositionsViewModel.serviceStatus.observe(viewLifecycleOwner){ status ->
             //if service is active, update the bus positions icon
             when(status) {
                 LivePositionsServiceStatus.OK ->
                     setBusPositionsIcon(true, error = false)
 
                 LivePositionsServiceStatus.NO_POSITIONS -> setBusPositionsIcon(true, error = true)
 
                 else -> setBusPositionsIcon( true, error = true)
             }
         }
     }
 
     /**
      * Clear all buses from the map
      */
     protected fun clearAllBusPositionsInMap(){
         for ((k, anim) in animatorsByVeh){
             anim.cancel()
         }
         animatorsByVeh.clear()
         updatesByVehDict.clear()
         updatePositionsIcons(forced = false)
     }
 
     protected fun setCameraPosition(latitude: Double, longitude: Double, zoom: Double) {
         map?.cameraPosition = CameraPosition.Builder()
             .target(LatLng(latitude, longitude))
             .zoom(zoom)
             .build()
     }
 
+    protected fun showToastLocation(enabled: Boolean){
+        val textid = if (enabled) R.string.location_enabled  else R.string.location_disabled
+        context?.let{
+            Toast.makeText(it,textid,Toast.LENGTH_SHORT).show()
+        }
+    }
+
 
     companion object{
         private const val DEBUG_TAG="GeneralMapLibreFragment"
 
         const val BUSES_SOURCE_ID = "buses-source"
         const val BUSES_LAYER_ID = "buses-layer"
 
         const val SEL_STOP_SOURCE="selected-stop-source"
         const val SEL_STOP_LAYER = "selected-stop-layer"
 
         const val SEL_BUS_SOURCE = "sel_bus_source"
         const val SEL_BUS_LAYER = "sel_bus_layer"
 
         const val KEY_LOCATION_ENABLED="location_enabled"
 
 
         protected const val STOPS_SOURCE_ID = "stops-source"
         protected const val STOPS_LAYER_ID = "stops-layer"
 
         protected const val STOP_IMAGE_ID = "stop-img"
         protected const val STOP_ACTIVE_IMG = "stop_active_img"
         protected const val BUS_IMAGE_ID = "bus_symbol"
         protected const val BUS_SEL_IMAGE_ID = "sel_bus_symbol"
 
         protected const val POLYLINE_LAYER = "polyline-layer"
         protected const val POLYLINE_SOURCE = "polyline-source"
 
         protected const val POLY_ARROWS_LAYER = "arrows-layer"
         protected const val POLY_ARROWS_SOURCE = "arrows-source"
         protected const val POLY_ARROW ="poly-arrow-img"
 
+        private const val PERM_LOC_COARSE = Manifest.permission.ACCESS_COARSE_LOCATION
+        private const val PERM_LOC_FINE = Manifest.permission.ACCESS_FINE_LOCATION
+
+        //TODO: this is hardcoded, make it modifiable by the user
+        protected const val MAX_DIST_KM = 90.0
+
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/it/reyboz/bustorino/fragments/IntroFragment.kt b/app/src/main/java/it/reyboz/bustorino/fragments/IntroFragment.kt
index f8ff1a6..f3f4d61 100644
--- a/app/src/main/java/it/reyboz/bustorino/fragments/IntroFragment.kt
+++ b/app/src/main/java/it/reyboz/bustorino/fragments/IntroFragment.kt
@@ -1,224 +1,242 @@
+/*
+	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.content.Context
 import android.graphics.*
 import android.graphics.text.LineBreaker
 import android.os.Build
 import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import android.widget.Button
 import android.widget.ImageView
 import android.widget.TextView
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.core.content.ContextCompat
 import androidx.core.content.res.ResourcesCompat
 import androidx.fragment.app.Fragment
 import it.reyboz.bustorino.R
 import it.reyboz.bustorino.backend.utils
 import it.reyboz.bustorino.util.Permissions
 import it.reyboz.bustorino.util.ViewUtils
 import java.lang.IllegalStateException
 
 
 // the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
 private const val SCREEN_INDEX = "screenindex"
 
 class IntroFragment : Fragment() {
     private var screenIndex = 1
     private lateinit var imageHolder: ImageView
     private lateinit var textView: TextView
 
     private lateinit var listener: IntroListener
     private lateinit var interactButton: Button
 
     private val locationRequestResLauncher = registerForActivityResult(ActivityResultContracts.RequestMultiplePermissions()){ res ->
         //onActivityResult(res: map<String,Boolean>)
-        if(res.get(Permissions.LOCATION_PERMISSIONS[0])==true || res.get(Permissions.LOCATION_PERMISSIONS[1])==true)
+        if(res[Permissions.LOCATION_PERMISSIONS[0]] ==true || res[Permissions.LOCATION_PERMISSIONS[1]] ==true)
             setInteractButtonState(ButtonState.LOCATION,false)
     }
     private val notificationsReqLauncher = registerForActivityResult(ActivityResultContracts.RequestPermission()) {
         if (it) setInteractButtonState(ButtonState.NOTIFICATIONS, false)
     }
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         arguments?.let {
             screenIndex = it.getInt(SCREEN_INDEX)
         }
     }
 
     override fun onAttach(context: Context) {
         super.onAttach(context)
         if(context !is IntroListener){
             throw IllegalStateException("Context must implement IntroListener")
         }
         listener = context
     }
 
     override fun onCreateView(
         inflater: LayoutInflater, container: ViewGroup?,
         savedInstanceState: Bundle?
     ): View? {
         // Inflate the layout for this fragment
         val root=  inflater.inflate(R.layout.fragment_intro, container, false)
 
         imageHolder = root.findViewById(R.id.image_tutorial)
         textView = root.findViewById(R.id.tutorialTextView)
         interactButton = root.findViewById(R.id.permissionButton)
 
         when(screenIndex){
             0 -> {
                 setImageBitmap(imageHolder, R.drawable.tuto_busto, 300f)
                 textView.text = utils.convertHtml(getString(R.string.tutorial_first))
             }
 
             1->{
                 setImageBitmap(imageHolder, R.drawable.tuto_search)
                 setTextHtmlDescription(R.string.tutorial_search)
             }
             2 ->{
                 setImageBitmap(imageHolder, R.drawable.tuto_arrivals)
                 textView.text = utils.convertHtml(getString(R.string.tutorial_arrivals))
             }
             3 ->{
                 setImageBitmap(imageHolder, R.drawable.tuto_stops)
                 textView.text = utils.convertHtml(getString(R.string.tutorial_stops))
             }
             4 ->{
                 setImageBitmap(imageHolder, R.drawable.tuto_map, 300f)
                 textView.text = utils.convertHtml(getString(R.string.tutorial_map))
                 if (Build.VERSION.SDK_INT >= 23) {
                     //only show if running on Android M or above
                     val permGranted = (Permissions.anyLocationPermissionsGranted(requireContext()))
                     setInteractButtonState(ButtonState.LOCATION, !permGranted)
                     interactButton.setOnClickListener {
                         //ask location permission
-                        locationRequestResLauncher.launch(Permissions.LOCATION_PERMISSIONS)
+                        Permissions.getInstance(requireContext()).checkRequestLocationPermissions(requireActivity(), locationRequestResLauncher)
+                        //locationRequestResLauncher.launch(Permissions.LOCATION_PERMISSIONS)
                     }
                     interactButton.visibility = View.VISIBLE
                 }
 
             }
             5 ->{
                 setImageBitmap(imageHolder, R.drawable.tuto_line_det, 300f)
                 textView.text = utils.convertHtml(getString(R.string.tutorial_line))
             }
             6-> {
                 setImageBitmap(imageHolder,R.drawable.tuto_menu)
                 setTextHtmlDescription(R.string.tutorial_menu)
                 //this is the cheapest trick ever lol
                 if(!Permissions.isNotificationPermissionNeeded()){
                     //no other screen needed
                     val button = root.findViewById<Button>(R.id.closeAllButton)
                     button.visibility = View.VISIBLE
                     button.setOnClickListener {
                         listener.closeIntroduction()
                     }
                 }
             }
             /// IMPORTANT: THIS NEEDS TO BE LAST SCREEN, ALWAYS
             7 ->{
                 imageHolder.setImageDrawable(ContextCompat.getDrawable(requireContext(),R.drawable.megaphone))
                 setTextHtmlDescription(R.string.tutorial_permissions)
                 if(Permissions.isNotificationPermissionNeeded()) {
                     val disabled = Permissions.isPermissionGranted(
                         requireContext(),
                         android.Manifest.permission.POST_NOTIFICATIONS
                     )
                     setInteractButtonState(ButtonState.NOTIFICATIONS, !disabled)
                     interactButton.setOnClickListener {
                         if (Permissions.isNotificationPermissionNeeded()) {
                             notificationsReqLauncher.launch(android.Manifest.permission.POST_NOTIFICATIONS)
                         }
                     }
                     interactButton.visibility = View.VISIBLE
                 }
                 //show the other button
                 val button = root.findViewById<Button>(R.id.closeAllButton)
                 button.setText(R.string.close_tutorial_short)
                 button.visibility = View.VISIBLE
                 button.setOnClickListener {
                     listener.closeIntroduction()
                 }
             }
         }
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
             textView.breakStrategy = LineBreaker.BREAK_STRATEGY_HIGH_QUALITY
         }
 
         return root
     }
 
     private fun setTextHtmlDescription(resId: Int){
         textView.text = utils.convertHtml(getString(resId))
     }
 
     private fun setInteractButtonState(state: ButtonState, active: Boolean){
         when(state){
             ButtonState.LOCATION ->
                 if(active) interactButton.setText(R.string.grant_location_permission)
                 else interactButton.setText(R.string.location_permission_granted)
             ButtonState.NOTIFICATIONS -> if(active)
                 interactButton.setText(R.string.grant_notification_permission)
                 else interactButton.setText(R.string.notification_permission_granted)
         }
         if(!active) {
             val color = ViewUtils.getColorFromTheme(requireContext(), R.attr.colorAccent)//ContextCompat.getColor(requireContext(), R.style.AppTheme.)
             if(Build.VERSION.SDK_INT >= 29)
                 interactButton.background.colorFilter = BlendModeColorFilter(color, BlendMode.MULTIPLY)
             else
                 interactButton.background.setColorFilter(
                     color,PorterDuff.Mode.MULTIPLY)
             interactButton.isClickable = false
         }
     }
 
     private fun setImageBitmap(imageView: ImageView, resId: Int, maxDpToScale:Float = DP_LIM_IMAGE){
         val bitmap = BitmapFactory.decodeResource(resources,resId)
         val limPix = utils.convertDipToPixels(resources, maxDpToScale)
         if (bitmap.width > limPix) {
             val rescFac = limPix/bitmap.width
             val rescaledBitmap = Bitmap.createScaledBitmap(bitmap,(limPix).toInt(), (bitmap.height*rescFac).toInt(),false)
             imageView.setImageBitmap(rescaledBitmap)
         }
         else
 
         imageView.setImageBitmap(bitmap)
 
     }
 
     companion object {
 
         const val DP_LIM_IMAGE = 1000f
         /**
          * Use this factory method to create a new instance of
          * this fragment using the provided parameters.
          *
          * @param index the screen index
          * @return A new instance of fragment IntroFragment.
          */
         @JvmStatic
         fun newInstance(index: Int) =
             IntroFragment().apply {
                 arguments = Bundle().apply {
                     putInt(SCREEN_INDEX, index)
                 }
             }
         @JvmStatic
         fun makeArguments(index: Int) = Bundle().apply {
             putInt(SCREEN_INDEX, index) }
         fun View.disable() {
             background.setColorFilter(Color.GRAY, PorterDuff.Mode.MULTIPLY)
             isClickable = false
         }
         enum class ButtonState{
             LOCATION, NOTIFICATIONS
         }
     }
 
     interface IntroListener{
         fun closeIntroduction()
     }
 }
\ No newline at end of file
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 8fa6f6d..b90649d 100644
--- a/app/src/main/java/it/reyboz/bustorino/fragments/LinesDetailFragment.kt
+++ b/app/src/main/java/it/reyboz/bustorino/fragments/LinesDetailFragment.kt
@@ -1,1205 +1,1182 @@
 /*
 	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.annotation.SuppressLint
 import android.content.Context
 import android.content.SharedPreferences
+import android.location.Location
 import android.os.Bundle
 import android.util.Log
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import android.widget.*
-import androidx.activity.result.ActivityResultCallback
-import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.content.res.AppCompatResources
 import androidx.core.content.ContextCompat
 import androidx.core.content.res.ResourcesCompat
 import androidx.fragment.app.activityViewModels
 import androidx.fragment.app.viewModels
 import androidx.preference.PreferenceManager
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 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.Stop
 import it.reyboz.bustorino.backend.gtfs.GtfsUtils
 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.map.*
-import it.reyboz.bustorino.middleware.LocationUtils
 import it.reyboz.bustorino.util.Permissions
 import it.reyboz.bustorino.viewmodels.LinesViewModel
 import it.reyboz.bustorino.viewmodels.MapStateViewModel
 import it.reyboz.bustorino.viewmodels.ServiceAlertsViewModel
 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.maps.MapLibreMap
 import org.maplibre.android.maps.Style
 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_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 = "" // the GTFS line ID (e.g. "gtt:10U")
     private lateinit var patternsSpinner: Spinner
     private var patternsAdapter: ArrayAdapter<String>? = null
 
 
     //private var isBottomSheetShowing = false
     private var shouldMapLocationBeReactivated = true
 
     private var toRunWhenMapReady : Runnable? = null
-    private var mapInitialized = AtomicBoolean(false)
+    //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 alertsViewModel: ServiceAlertsViewModel by activityViewModels()
     //private var firstInit = true
     private var pausedFragment = false
     private lateinit var switchButton: ImageButton
     private lateinit var lineInfoButton: 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 = ""
     private var patternIdToShow = ""
     //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 polylineSource: GeoJsonSource
     private lateinit var polyArrowSource: GeoJsonSource
 
     private var savedCameraPosition: CameraPosition? = null
 
     private var lastStopsSizeShown = 0
 
     //BUS POSITIONS
 
     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 var showOnTopOfLine = false
     private var recyclerInitDone = false
 
     private var usingMQTTPositions = true
     private var restoredCameraInMap = false
 
-
-
     //position of live markers
 
     private val tripMarkersAnimators = HashMap<String, ObjectAnimator>()
 
     //extra items to use the LibreMap
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         val args = requireArguments()
         lineID = args.getString(LINEID_KEY,"")
         stopIDFromToShow = args.getString(STOPID_FROM_KEY, "") //can be null
         patternIdToShow = args.getString(PATTERN_SHOW_KEY, "")
     }
 
     @SuppressLint("SetTextI18n")
     override fun onCreateView(
         inflater: LayoutInflater, container: ViewGroup?,
         savedInstanceState: Bundle?
     ): View? {
         //reset statuses
         //isBottomSheetShowing = false
         //stopsLayerStarted = false
         lastStopsSizeShown = 0
-        mapInitialized.set(false)
+        mapInitialized = false
 
         val rootView = inflater.inflate(R.layout.fragment_lines_detail, container, false)
         //lineID = requireArguments().getString(LINEID_KEY, "")
         arguments?.let {
             lineID = it.getString(LINEID_KEY, "")
             stopIDFromToShow = it.getString(STOPID_FROM_KEY, "") //can be null
             patternIdToShow = it.getString(PATTERN_SHOW_KEY, "")
             Log.d(DEBUG_TAG, "LineID selected: $lineID, stopIDFromToShow: $stopIDFromToShow, patternIdToShow: $patternIdToShow")
         }
 
         switchButton = rootView.findViewById(R.id.switchImageButton)
         locationIcon = rootView.findViewById(R.id.locationEnableIcon)
         busPositionsIconButton = rootView.findViewById(R.id.busPositionsImageButton)
         lineInfoButton = rootView.findViewById(R.id.lineInfoWarningButton)
         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)
 
 
         // Setup close button
         rootView.findViewById<View>(R.id.btnClose).setOnClickListener {
             hideStopOrBusBottomSheet()
         }
 
         val titleTextView = rootView.findViewById<TextView>(R.id.titleTextView)
         titleTextView.text = getString(R.string.line)+" "+ GtfsUtils.lineNameDisplayFromGtfsID(lineID)
 
         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)
+            view.setOnClickListener(this::switchUserLocationStatus)
         }
         busPositionsIconButton.setOnClickListener {
             LivePositionsDialogFragment().show(parentFragmentManager, "LivePositionsDialog")
         }
         //set
         //INITIALIZE VIEW MODELS
         viewModel.setRouteIDQuery(lineID)
         livePositionsViewModel.setGtfsLineToFilterPos(lineID, null)
         //observe the change, clear buses when switching position
         livePositionsViewModel.useMQTTPositionsLiveData.observe(viewLifecycleOwner){ useMQTT->
             //Log.d(DEBUG_TAG, "Changed MQTT positions, now have to use MQTT: $useMQTT")
             if (isResumed) {
                 //Log.d(DEBUG_TAG, "Deciding to switch, the current source is using MQTT: $usingMQTTPositions")
                 if(useMQTT!=usingMQTTPositions){
                     // we have to switch
                     val clearPos = PreferenceManager.getDefaultSharedPreferences(requireContext()).getBoolean("positions_clear_on_switch_pref", true)
                     livePositionsViewModel.clearOldPositionsUpdates()
                     if(useMQTT){
                         //switching to MQTT, the GTFS positions are disabled automatically
                         livePositionsViewModel.requestMatoPosUpdates(GtfsUtils.getLineNameFromGtfsID(lineID))
                     } else{
                         //switching to GTFS RT: stop Mato, launch first request
                         livePositionsViewModel.stopMatoUpdates()
                         livePositionsViewModel.requestGTFSUpdates()
                     }
                     Log.d(DEBUG_TAG, "Should clear positions: $clearPos")
                     if (clearPos) {
                         livePositionsViewModel.clearAllPositions()
                         //force clear of the viewed data
                         if(vehShowing.isNotEmpty()) hideStopOrBusBottomSheet()
                         clearAllBusPositionsInMap()
                     }
 
                 }
             }
             usingMQTTPositions = useMQTT
 
         }
 
         val keySourcePositions = getString(R.string.pref_positions_source)
         usingMQTTPositions = PreferenceManager.getDefaultSharedPreferences(requireContext())
             .getString(keySourcePositions, "mqtt").contentEquals("mqtt")
 
         viewModel.patternsWithStopsByRouteLiveData.observe(viewLifecycleOwner, this::savePatternsToShow)
         /*
          */
         viewModel.stopsForPatternLiveData.observe(viewLifecycleOwner) { stops ->
             val pattern = viewModel.selectedPatternLiveData.value
             if (pattern == null) {
                 Log.w(DEBUG_TAG, "The selectedPattern is null!")
                 return@observe
             }
             if(mapView.visibility ==View.VISIBLE) {
                 // We have the pattern and the stops here, time to display them
                 //TODO: Decide if we should follow the camera view given by the previous screen (probably the map fragment)
                 // use !restoredCameraInMap to do so
 
                // val shouldZoom = (shownStopInBottomSheet == null) //use this if we want to avoid zoom when we're keeping the stop open
                 displayPatternWithStopsOnMap(pattern, stops, true)
             } else {
                 if(stopsRecyclerView.visibility==View.VISIBLE) {
                     patternShown = pattern
                     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
         }
+        mapStateViewModel.locationActive.observe(viewLifecycleOwner) {
+            setLocationIconEnabled(it)
+        }
         // enable info button if there are alerts on the line
         alertsViewModel.setGtfsLineFilter(lineID)
         alertsViewModel.alertsByRouteLiveData.observe(viewLifecycleOwner){ list ->
             Log.d(DEBUG_TAG, "alerts for line $lineID:  ${list.size}")
 
             if(list.isNotEmpty()){
                 lineInfoButton.visibility = View.VISIBLE
                 //Log.d(DEBUG_TAG, "First alert is:\n ${list[0].longPrint()}")
             } else
                 lineInfoButton.visibility = View.GONE
         }
         lineInfoButton.setOnClickListener {
             AlertsDialogFragment(lineID).show(parentFragmentManager, "Alerts-Line$lineID")
         }
         /*
 
          */
 
         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)
                             livePositionsViewModel.retriggerPositionUpdate()
                         }
                         if (shownStopInBottomSheet!=null){
                             //check if the stop is inside the new pattern
                             /*val s = shownStopInBottomSheet!!
                             val newPatternStops = patternWithStops.stopsIndices
                             val filterPStops = newPatternStops.filter { ps -> ps.stopGtfsId == "gtt:${s.ID}" }
                             if (filterPStops.isEmpty()){
                                 hideStopOrBusBottomSheet()
                             }
                              */
                             // do another thing, just close the stop when the pattern is changed
                             if (patt.code != patternWithStops.pattern.code){
                                 hideStopOrBusBottomSheet()
                             }
                         }
                     }
                 }
                 livePositionsViewModel.setGtfsLineToFilterPos(lineID, patternWithStops.pattern)
 
             }
 
             override fun onNothingSelected(p0: AdapterView<*>?) {
             }
         }
         Log.d(DEBUG_TAG, "Views created!")
 
         observeStatusLivePositions()
 
         return rootView
     }
 
     // ------------- UI switch stuff ---------
 
     private fun hideMapAndShowStopList(){
         mapView.visibility = View.GONE
         stopsRecyclerView.visibility = View.VISIBLE
         locationIcon?.visibility = View.GONE
         busPositionsIconButton?.visibility = View.GONE
 
         viewModel.setMapShowing(false)
         if(usingMQTTPositions) livePositionsViewModel.stopMatoUpdates()
         //map.overlayManager.remove(busPositionsOverlay)
 
         switchButton.setImageDrawable(AppCompatResources.getDrawable(requireContext(), R.drawable.ic_map_white_30))
 
         hideStopOrBusBottomSheet()
 
         if(locationComponent.isLocationComponentEnabled){
-            locationComponent.isLocationComponentEnabled = false
+            setLocationComponentEnabled(false)
             shouldMapLocationBeReactivated = true
         } else
             shouldMapLocationBeReactivated = false
     }
 
     private fun hideStopListAndShowMap(){
         stopsRecyclerView.visibility = View.GONE
         mapView.visibility = View.VISIBLE
         locationIcon?.visibility = View.VISIBLE
         busPositionsIconButton.visibility = View.VISIBLE
 
         viewModel.setMapShowing(true)
 
         //map.overlayManager.add(busPositionsOverlay)
         //map.
         if(usingMQTTPositions)
             livePositionsViewModel.requestMatoPosUpdates(GtfsUtils.getLineNameFromGtfsID(lineID))
         else
             livePositionsViewModel.requestGTFSUpdates()
 
         switchButton.setImageDrawable(AppCompatResources.getDrawable(requireContext(), R.drawable.ic_list_30))
 
-        if(shouldMapLocationBeReactivated && Permissions.bothLocationPermissionsGranted(requireContext())){
-            locationComponent.isLocationComponentEnabled = true
+        if(shouldMapLocationBeReactivated){
+            setLocationComponentEnabled(Permissions.bothLocationPermissionsGranted(requireContext()))
         }
     }
 
-    private fun setLocationIconEnabled(setTrue: Boolean){
-        if(setTrue)
+    override fun setLocationIconEnabled(enabled: Boolean){
+        if(enabled) {
             locationIcon?.setImageDrawable(ContextCompat.getDrawable(requireContext(), R.drawable.location_circlew_red))
-        else
-            locationIcon?.setImageDrawable(ContextCompat.getDrawable(requireContext(), R.drawable.location_circlew_grey))
+        }
+        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())
+    override fun onMapLocationEnabled(active: Boolean) {
+        //extra thing: show the toast
+        showToastLocation(active)
+    }
 
-            if (permissionOk) {
-                Log.d(DEBUG_TAG, "Permission OK, starting location component, assumed: $assumePermissions")
-                locationComponent.isLocationComponentEnabled = true
-                //locationComponent.cameraMode = CameraMode.TRACKING //CameraMode.TRACKING
+    override fun onMapLocationComponentInitialized() {
+        //enable the position after the first fix
+        //onMapLocationEnabled(true)
+    }
 
-                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()
+    @SuppressLint("MissingPermission")
+    override fun onFirstReceivedLocation(location: Location) {
+        if(mapInitialized){
+            val center = map!!.cameraPosition.target
+            val newPos = LatLng(location.latitude, location.longitude)
+            Log.d(DEBUG_TAG, "Center of the map : $center")
+            val newStatus = if(center==null || newPos.distanceTo(center) > 20*1000){
+                Log.d(DEBUG_TAG, "Distance from center of map to location: "+center?.distanceTo(newPos))
+                if(!shownToastNoPosition) context?.let{ c->
+                    Toast.makeText(c, R.string.too_far_not_showing_location, Toast.LENGTH_LONG).show()
+                    shownToastNoPosition = true
                 }
-                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
+                false
+            } else{
+                true
             }
-        }
-
-    }
-
-    /**
-     * Switch position icon from activ
-     */
-    private fun onPositionIconButtonClick(view: View){
-        if(locationComponent.isLocationComponentEnabled) setMapUserLocationEnabled(false, false, true)
-        else{
-            setMapUserLocationEnabled(true, false, true)
+            if(!newStatus) setLocationComponentEnabled(newStatus)
+            mapStateViewModel.locationActive.value = newStatus
         }
     }
 
     // ------------- Map Code -------------------------
     /**
      * This method sets up the map and the layers
      */
     override fun onMapReady(mapReady: MapLibreMap) {
         this.map = mapReady
         var setViewAlready = false
 
         val context = requireContext()
         val mjson = MapLibreStyles.getJsonStyleFromAsset(context, PreferencesHolder.getMapLibreStyleFile(context))        //ViewUtils.loadJsonFromAsset(requireContext(),"map_style_good.json")
 
         activity?.run {
             val builder = Style.Builder().fromJson(mjson!!)
 
             mapReady.setStyle(builder) { style ->
                 addImagesStyle(style)
 
                 mapStyle = style
                 //setupLayers(style)
 
-                // Start observing data
-                initMapUserLocation(style, mapReady, requireContext())
+                //checkInitMapLocation(mapReady, style,requireContext())
 
                 //if(!stopsLayerStarted)
                 initPolylineStopsLayers(style, null)
 
                 setupBusLayer(style)
 
                 initSymbolManager(mapReady, style)
                 toRunWhenMapReady?.run()
                 toRunWhenMapReady = null
-                mapInitialized.set(true)
+                mapInitialized = true
 
                 if(patternShown!=null){
                     viewModel.stopsForPatternLiveData.value?.let {
                         Log.d(DEBUG_TAG, "Show stops from the cache")
                         displayPatternWithStopsOnMap(patternShown!!, it, true)
                         //Show stop from cache
                         mapStateViewModel.lastOpenStopID.value?.let{ sID->
                             val s= it.filter { stop -> stop.ID==sID }
                                 if (s.isEmpty()) {
                                     if(sID.isNotEmpty())
                                         Log.w(DEBUG_TAG,"Wanted to open stop $sID in map but it was not loaded!")
                                 }
                                 else openStopInBottomSheet(s[0])
 
                         }
                     }
 
 
                 }
                 var restoredMapState = mapStateViewModel.restoreMapState(mapReady)
                 arguments?.let { args ->
                     // if there is a Camera State in the arguments, set it for the new camera (doesn't work yet!)
                     if (!restoredMapState && MapCameraState.checkInBundle(args)) {
                         val initCamState = MapCameraState.fromBundle(args)
                         //map?.let{
                         MapStateViewModel.restoreMapState(mapReady, initCamState)
                         setViewAlready = true
                         restoredMapState = true
 
                     }
                 }
                 restoredCameraInMap = restoredMapState
             }
 
             mapReady.addOnMapClickListener { point ->
                 val screenPoint = mapReady.projection.toScreenLocation(point)
                 val stopsNearby = mapReady.queryRenderedFeatures(screenPoint, STOPS_LAYER_ID)
                 val busNearby = mapReady.queryRenderedFeatures(screenPoint, BUSES_LAYER_ID)
                 //Log.d(DEBUG_TAG, "onMapClick, stopsNearby: $stopsNearby \nstopShown: $shownStopInBottomSheet \nbusNearby: $busNearby,")
 
                 if (stopsNearby.isNotEmpty()) {
                     val feature = stopsNearby[0]
                     val id = feature.getStringProperty("id")
                     val stop = viewModel.getStopByID(id)
                     stop?.let {
                         if (isBottomSheetShowing() || vehShowing.isNotEmpty()) {
                             hideStopOrBusBottomSheet()
                         }
                         openStopInBottomSheet(it)
 
                         //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]
                     openBusFromMapClick(feature)
 
                     return@addOnMapClickListener true
                 }
                 false
             }
 
             // we start requesting the bus positions now
             observeBusPositionUpdates()
 
         }
 
         val zoom = 12.0
         val latlngTarget = LatLng(MapLibreFragment.DEFAULT_CENTER_LAT, MapLibreFragment.DEFAULT_CENTER_LON)
         if(!setViewAlready)
             mapReady.cameraPosition = savedCameraPosition ?:CameraPosition.Builder().target(latlngTarget).zoom(zoom).build()
 
         savedCameraPosition = null
 
-        if(shouldMapLocationBeReactivated) setMapUserLocationEnabled(true, false, false)
+        if(shouldMapLocationBeReactivated)
+            mapReady.style?.let{ checkInitMapLocation(mapReady,it, context)}
     }
 
     override fun showOpenStopWithSymbolLayer(): Boolean {
         return true
     }
 
     /**
      * Separate function to find the vehicle associated with a feature and display it
      */
     private fun openBusFromMapClick(feature: Feature){
         val vehid = feature.getStringProperty("veh")
         if(isBottomSheetShowing())
             hideStopOrBusBottomSheet()
         showVehicleTripInBottomSheet(vehid)
         updatesByVehDict[vehid]?.let {
             map?.animateCamera(
                 CameraUpdateFactory.newLatLng(LatLng(it.posUpdate.latitude, it.posUpdate.longitude)),
                 750
             )
         }
     }
 
     private fun observeBusPositionUpdates(){
         //live bus positions
         livePositionsViewModel.filteredLocationUpdates.observe(viewLifecycleOwner){ pair ->
             //Log.d(DEBUG_TAG, "Received ${updates.size} updates for the positions")
             val updates = pair.first
             val vehiclesNotOnCorrectDir = pair.second
             if(mapView.visibility == View.GONE || patternShown ==null){
                 //DO NOTHING
                 Log.w(DEBUG_TAG, "not doing anything because map is not visible")
                 return@observe
             }
             //remove vehicles not on this direction
             removeVehiclesData(vehiclesNotOnCorrectDir)
             updateBusPositionsInMap(updates, hasVehicleTracking = true) { veh->
                 showVehicleTripInBottomSheet(veh)
             }
             //if not using MQTT positions
             if(!usingMQTTPositions){
                 livePositionsViewModel.requestDelayedGTFSUpdates(2000)
             }
         }
 
         //download missing tripIDs
         livePositionsViewModel.tripsGtfsIDsToQuery.observe(viewLifecycleOwner){
             //gtfsPosViewModel.downloadTripsFromMato(dat);
             MatoTripsDownloadWorker.requestMatoTripsDownload(
                 it, requireContext().applicationContext,
                 "BusTO-MatoTripDownload"
             )
         }
     }
 
     private fun showVehicleTripInBottomSheet(veh: String) {
         super.showVehicleTripInBottomSheet(veh) { patternCode, veh ->
             //this is checked in @GeneralMapLibreFragment
             //val data = updatesByVehDict[veh] ?: return@showVehicleTripInBottomSheet
             if (patternCode.isEmpty()) return@showVehicleTripInBottomSheet
             if (patternShown?.pattern?.code == patternCode) {
                 //center view on vehicle
                 updatesByVehDict[veh]?.let { up->
                     map?.let{
                         /*
                         val c = it.cameraPosition
                         it.moveCamera(CameraUpdateFactory.CameraPositionUpdate(c.bearing,
                             LatLng(up.posUpdate.latitude, up.posUpdate.longitude),
                             c.tilt,c.zoom, c.padding)
                         )
                          */
                         it.animateCamera(CameraUpdateFactory.newLatLng(LatLng(up.posUpdate.latitude, up.posUpdate.longitude)))
                     }
                 } ?: {
                     Toast.makeText(context, R.string.showing_same_direction, Toast.LENGTH_SHORT).show()
                 }
 
             } else {
                 showPatternWithCode(patternCode)
             }
         }
     }
     // ------- MAP LAYERS INITIALIZE ----
     /**
      * Initialize the map layers for the stops
      */
     private fun initPolylineStopsLayers(style: Style, arrowFeatures: FeatureCollection?){
 
         Log.d(DEBUG_TAG, "INIT STOPS CALLED")
         stopsSource = GeoJsonSource(STOPS_SOURCE_ID)
         //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 icons
         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)!!)
 
 
         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
 
         initStopsLayer(style, null, POLY_ARROWS_LAYER)
     }
 
     private fun filterPatternFromArgs(patterns: List<MatoPatternWithStops>): MatoPatternWithStops?{
         var p: MatoPatternWithStops? = null
 
         if (patternIdToShow.isNotEmpty()){
             for (patt in patterns) {
                 if (patt.pattern.code == patternIdToShow){
                     p = patt
                 }
             }
             if(p==null)
                 Log.w(DEBUG_TAG, "We had to show the pattern with code $patternIdToShow, but we didn't find it")
             else
                 Log.d(DEBUG_TAG, "Requesting to show pattern with code $patternIdToShow, found pattern ${p.pattern.code}")
         }
         // if we are loading from a stop, find it
         else if(stopIDFromToShow.isNotEmpty()) {
             val stopGtfsID = "gtt:$stopIDFromToShow"
             var pLength = 0
             for (patt in patterns) {
                 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
                     }
                 }
             }
             if(p==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 ${p.pattern.code}")
         }
         // the flag of showing pattern is not necessary anymore, we have set the pattern
         patternIdToShow = ""
         // the flag of selecting from stop needs to be used again when displaying the pattern
         return p
     }
     /**
      * 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()
         }
         val patternToShow = filterPatternFromArgs(currentPatterns)
         if(patternToShow!=null) {
             //showPattern(patternToShow)
             patternShown = patternToShow
         }
         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 }
 
         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")
         // this triggers the showing on the map / recyclerview
         if (pos !=-2)
             patternsSpinner.setSelection(pos)
         else
             Log.e(DEBUG_TAG, "Pattern with code $code not found!!")
     }
 
     /**
      * Zoom on the map to get the pattern
      */
     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()){
+        if(!mapInitialized){
             //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, 750.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")
                 initPolylineStopsLayers(mapStyle, 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!!")
             }
 
         var reallyZoomToPattern = zoomToPattern
         if(stopIDFromToShow.isNotEmpty()){
             //open the stop
             val stopfilt = stopsSorted.filter { s -> s.ID == stopIDFromToShow }
             if (stopfilt.isEmpty()){
                 Log.e(DEBUG_TAG, "Tried to show stop but it's not in the selected pattern")
             } else{
                 val stop = stopfilt[0]
                 openStopInBottomSheet(stop)
 
                 if(stop.hasCoords()) {
                     reallyZoomToPattern = false
                     setCameraPosition(stop.latitude!!, stop.longitude!!, 13.5)
                 }
 
             }
             // Reset this to avoid checking again when showing
             stopIDFromToShow = ""
             //camera set
         }
         if(reallyZoomToPattern) zoomToCurrentPattern()
 
     }
 
     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
             }
         }
     }
 
 
     override fun onResume() {
         super.onResume()
         Log.d(DEBUG_TAG, "Resetting paused from onResume")
         pausedFragment = false
 
         val keySourcePositions = getString(R.string.pref_positions_source)
         usingMQTTPositions = PreferenceManager.getDefaultSharedPreferences(requireContext())
             .getString(keySourcePositions, "mqtt").contentEquals("mqtt")
 
         //separate paths
         if(usingMQTTPositions)
             livePositionsViewModel.requestMatoPosUpdates(GtfsUtils.getLineNameFromGtfsID(lineID))
         else
             livePositionsViewModel.requestGTFSUpdates()
 
 
         //initialize GUI here
         fragmentListener?.readyGUIfor(FragmentKind.LINES)
 
     }
 
     override fun onPause() {
         super.onPause()
         mapView.onPause()
         if(usingMQTTPositions) livePositionsViewModel.stopMatoUpdates()
         pausedFragment = true
         //save map
         map?.let{
             //if map is initialized
             mapStateViewModel.saveMapState(it)
         }
         mapStateViewModel.lastOpenStopID.postValue(shownStopInBottomSheet?.ID)
     }
 
     override fun onStop() {
         super.onStop()
         mapView.onStop()
-        shouldMapLocationBeReactivated = locationComponent.isLocationComponentEnabled
+        if(locationInitialized)
+            shouldMapLocationBeReactivated = locationComponent.isLocationComponentEnabled
+        else
+            shouldMapLocationBeReactivated = false
     }
 
     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
+        //map?.locationComponent?.isLocationComponentEnabled = false
+        setLocationComponentEnabled(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 PATTERN_SHOW_KEY ="patternIDShow"
 
 
         private const val DEBUG_TAG="BusTO-LineDetalFragment"
 
         fun makeArgs(lineID: String, stopIDFrom: String?): Bundle{
             val b = Bundle()
             b.putString(LINEID_KEY, lineID)
             b.putString(STOPID_FROM_KEY, stopIDFrom)
             return b
         }
 
         fun makeArgsPattern(lineID: String, patternShow: String?, extraArgs: Bundle?): Bundle {
 
             val b= extraArgs ?: Bundle()
             b.putString(LINEID_KEY, lineID)
             b.putString(PATTERN_SHOW_KEY, patternShow)
             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
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/it/reyboz/bustorino/fragments/LivePositionsDialogFragment.kt b/app/src/main/java/it/reyboz/bustorino/fragments/LivePositionsDialogFragment.kt
index 0d170ea..db43348 100644
--- a/app/src/main/java/it/reyboz/bustorino/fragments/LivePositionsDialogFragment.kt
+++ b/app/src/main/java/it/reyboz/bustorino/fragments/LivePositionsDialogFragment.kt
@@ -1,87 +1,104 @@
+/*
+	BusTO  - Fragments components
+    Copyright (C) 2025 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 it.reyboz.bustorino.R
 
 import android.app.Dialog
 import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import android.widget.Button
 import android.widget.ImageButton
 import android.widget.TextView
 import androidx.appcompat.app.AlertDialog
 import androidx.fragment.app.DialogFragment
 import androidx.fragment.app.activityViewModels
 import it.reyboz.bustorino.backend.LivePositionsServiceStatus
 import it.reyboz.bustorino.viewmodels.LivePositionsViewModel
 
 class LivePositionsDialogFragment : DialogFragment() {
     private val viewModel: LivePositionsViewModel by activityViewModels()
     private lateinit var providerNameTextView: TextView
     private lateinit var statusMessageTextView: TextView
 
 
     override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
         //return super.onCreateDialog(savedInstanceState)
         val builder = AlertDialog.Builder(requireContext())
         val view = layoutInflater.inflate(R.layout.fragment_dialog_buspositions, null)
 
         providerNameTextView = view.findViewById<TextView>(R.id.providerNameTextView)
         statusMessageTextView = view.findViewById<TextView>(R.id.statusMessageTextView)
         val btnSwitch = view.findViewById<Button>(R.id.btnSwitch)
         val btnClose = view.findViewById<ImageButton>(R.id.btnClose)
 
         // OBSERVE VIEWMODEL
         /*sharedViewModel.variableTitle.observe(this) {
             tvTitleVariable.text = it
         }
 
         sharedViewModel.statusMessage.observe(this) {
             tvStatusMessage.text = it
         }
 
 
 
          */
 
         btnSwitch.setOnClickListener {
             viewModel.switchPositionsSource()
         }
 
         btnClose.setOnClickListener { dismiss() }
 
         builder.setView(view)
         val res =  builder.create()
         res.window?.setBackgroundDrawableResource(R.color.grey_100)
         return res
     }
 
     override fun onCreateView(
         inflater: LayoutInflater,
         container: ViewGroup?,
         savedInstanceState: Bundle?
     ): View? {
 
         viewModel.serviceStatus.observe(this) { serviceStatus ->
             val message = when (serviceStatus) {
                 LivePositionsServiceStatus.OK -> getString(R.string.live_positions_msg_ok)
                 LivePositionsServiceStatus.NO_POSITIONS -> getString(R.string.live_positions_msg_no_positions)
                 LivePositionsServiceStatus.ERROR_CONNECTION -> getString(R.string.live_positions_msg_connection_error)
                 LivePositionsServiceStatus.ERROR_NETWORK_RESPONSE -> getString(R.string.live_positions_msg_network_error)
                 LivePositionsServiceStatus.ERROR_PARSING_RESPONSE -> getString(R.string.live_positions_msg_parsing_error)
                 LivePositionsServiceStatus.CONNECTING -> getString(R.string.live_positions_msg_connecting)
 
             }
             statusMessageTextView.text = message
         }
         viewModel.useMQTTPositionsLiveData.observe(this) { useMQTT ->
             val message = if (useMQTT) {
                 getString(R.string.positions_source_mato_short)
             } else getString(R.string.positions_source_gtfsrt_short)
             providerNameTextView.text  = message
         }
 
         return super.onCreateView(inflater, container, savedInstanceState)
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/it/reyboz/bustorino/fragments/MainScreenFragment.java b/app/src/main/java/it/reyboz/bustorino/fragments/MainScreenFragment.java
index 024d13f..512782e 100644
--- a/app/src/main/java/it/reyboz/bustorino/fragments/MainScreenFragment.java
+++ b/app/src/main/java/it/reyboz/bustorino/fragments/MainScreenFragment.java
@@ -1,890 +1,906 @@
-
+/*
+	BusTO  - Fragments components
+    Copyright (C) 2021 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.content.Context;
 import android.content.Intent;
 import android.content.pm.PackageManager;
 import android.location.Criteria;
 import android.location.Location;
 import android.net.Uri;
 import android.os.Build;
 import android.os.Bundle;
 
 import androidx.activity.result.ActivityResultCallback;
 import androidx.activity.result.ActivityResultLauncher;
 import androidx.activity.result.contract.ActivityResultContracts;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.appcompat.widget.AppCompatImageButton;
 import androidx.coordinatorlayout.widget.CoordinatorLayout;
 import androidx.core.app.ActivityCompat;
 import androidx.fragment.app.Fragment;
 import androidx.fragment.app.FragmentManager;
 import androidx.fragment.app.FragmentTransaction;
 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
 
 import android.os.Handler;
 import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.MenuItem;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.inputmethod.EditorInfo;
 import android.view.inputmethod.InputMethodManager;
 import android.widget.EditText;
 import android.widget.FrameLayout;
 import android.widget.ProgressBar;
 import android.widget.Toast;
 
 import com.google.android.material.floatingactionbutton.FloatingActionButton;
 
 import java.util.List;
 import java.util.Map;
 
 import it.reyboz.bustorino.R;
 import it.reyboz.bustorino.backend.*;
 import it.reyboz.bustorino.data.PreferencesHolder;
 import it.reyboz.bustorino.middleware.AppLocationManager;
 import it.reyboz.bustorino.middleware.AsyncArrivalsSearcher;
 import it.reyboz.bustorino.middleware.AsyncStopsSearcher;
 import it.reyboz.bustorino.middleware.BarcodeScanContract;
 import it.reyboz.bustorino.middleware.BarcodeScanOptions;
 import it.reyboz.bustorino.middleware.BarcodeScanUtils;
 import it.reyboz.bustorino.util.LocationCriteria;
 import it.reyboz.bustorino.util.Permissions;
 
 import static it.reyboz.bustorino.backend.utils.getBusStopIDFromUri;
 import static it.reyboz.bustorino.util.Permissions.LOCATION_PERMISSIONS;
 
 
 /**
  * A simple {@link Fragment} subclass.
  * Use the {@link MainScreenFragment#newInstance} factory method to
  * create an instance of this fragment.
  */
 public class MainScreenFragment extends ScreenBaseFragment implements  FragmentListenerMain{
 
 
     private static final String SAVED_FRAGMENT="saved_fragment";
 
     private static final String DEBUG_TAG = "BusTO - MainFragment";
 
     public static final String PENDING_STOP_SEARCH="PendingStopSearch";
 
     public final static String FRAGMENT_TAG = "MainScreenFragment";
 
     private FragmentHelper fragmentHelper;
     private SwipeRefreshLayout swipeRefreshLayout;
     private EditText busStopSearchByIDEditText;
     private EditText busStopSearchByNameEditText;
     private ProgressBar progressBar;
 
     private MenuItem actionHelpMenuItem;
     private FloatingActionButton floatingActionButton;
     private FrameLayout resultFrameLayout;
 
     private boolean setupOnStart = true;
     private boolean suppressArrivalsReload = false;
     //private Snackbar snackbar;
     /*
      * Search mode
      */
     private static final int SEARCH_BY_NAME = 0;
     private static final int SEARCH_BY_ID = 1;
     //private static final int SEARCH_BY_ROUTE = 2; // implement this -- DONE!
     private int searchMode;
     //private ImageButton addToFavorites;
     //// HIDDEN BUT IMPORTANT ELEMENTS ////
     FragmentManager childFragMan;
     Handler mainHandler;
     private final Runnable refreshStop = new Runnable() {
         public void run() {
             if(getContext() == null) return;
 
             if (childFragMan.findFragmentById(R.id.resultFrame) instanceof ArrivalsFragment) {
                 ArrivalsFragment fragment = (ArrivalsFragment) childFragMan.findFragmentById(R.id.resultFrame);
                 if (fragment == null){
                     //we create a new fragment, which is WRONG
                     Log.e("BusTO-RefreshStop", "Asking for refresh when there is no fragment");
                     // AsyncDataDownload(fragmentHelper, arrivalsFetchers,getContext()).execute();
                 } else{
                     //String stopName = fragment.getStopID();
 
                     //new AsyncArrivalsSearcher(fragmentHelper, fragment.getCurrentFetchersAsArray(), getContext()).execute(stopName);
                     fragment.requestArrivalsForTheFragment();
                 }
             } else { //we create a new fragment, which is WRONG
                 List<ArrivalsFetcher> fetcherList = utils.getDefaultArrivalsFetchers(getContext());
                 ArrivalsFetcher[] arrivalsFetchers = new ArrivalsFetcher[fetcherList.size()];
                 arrivalsFetchers = fetcherList.toArray(arrivalsFetchers);
                 new AsyncArrivalsSearcher(fragmentHelper, arrivalsFetchers, getContext()).execute();
             }
         }
     };
     //
     private final ActivityResultLauncher<BarcodeScanOptions> barcodeLauncher = registerForActivityResult(new BarcodeScanContract(),
             result -> {
                 if(result!=null && result.getContents()!=null) {
                     //Toast.makeText(MyActivity.this, "Cancelled", Toast.LENGTH_LONG).show();
                     Uri uri;
                     try {
                         uri = Uri.parse(result.getContents()); // this apparently prevents NullPointerException. Somehow.
                     } catch (NullPointerException e) {
                         if (getContext()!=null)
                             Toast.makeText(getContext().getApplicationContext(),
                                 R.string.no_qrcode, Toast.LENGTH_SHORT).show();
                         return;
                     }
                     String busStopID = getBusStopIDFromUri(uri);
                     busStopSearchByIDEditText.setText(busStopID);
                     requestArrivalsForStopID(busStopID);
 
                 } else {
                     //Toast.makeText(MyActivity.this, "Scanned: " + result.getContents(), Toast.LENGTH_LONG).show();
                     if (getContext()!=null)
                         Toast.makeText(getContext().getApplicationContext(),
                             R.string.no_qrcode, Toast.LENGTH_SHORT).show();
 
 
 
                 }
             });
 
     /// LOCATION STUFF ///
     boolean pendingIntroRun = false;
     boolean pendingNearbyStopsFragmentRequest = false;
     boolean locationPermissionGranted, locationPermissionAsked = false;
     AppLocationManager locationManager;
     private final ActivityResultLauncher<String[]> requestPermissionLauncher =
             registerForActivityResult(new ActivityResultContracts.RequestMultiplePermissions(), new ActivityResultCallback<Map<String, Boolean>>() {
                 @Override
                 public void onActivityResult(Map<String, Boolean> result) {
                     if(result==null) return;
 
                     if(result.get(Manifest.permission.ACCESS_COARSE_LOCATION) == null ||
                             result.get(Manifest.permission.ACCESS_FINE_LOCATION) == null)
                         return;
 
                     Log.d(DEBUG_TAG, "Permissions for location are: "+result);
                     if(Boolean.TRUE.equals(result.get(Manifest.permission.ACCESS_COARSE_LOCATION))
                             || Boolean.TRUE.equals(result.get(Manifest.permission.ACCESS_FINE_LOCATION))){
                         locationPermissionGranted = true;
                         Log.w(DEBUG_TAG, "Starting position");
                         if (mListener!= null && getContext()!=null){
                             if (locationManager==null)
                                 locationManager = AppLocationManager.getInstance(getContext());
                             locationManager.addLocationRequestFor(requester);
                         }
                         // show nearby fragment
                         //showNearbyStopsFragment();
                         Log.d(DEBUG_TAG, "We have location permission");
                         if(pendingNearbyStopsFragmentRequest){
                             showNearbyFragmentIfPossible();
                             pendingNearbyStopsFragmentRequest = false;
                         }
                     }
                     if(pendingNearbyStopsFragmentRequest) pendingNearbyStopsFragmentRequest =false;
                 }
             });
 
 
     private final LocationCriteria cr = new LocationCriteria(2000, 10000);
     //Location
     private AppLocationManager.LocationRequester requester = new AppLocationManager.LocationRequester() {
         @Override
         public void onLocationChanged(Location loc) {
 
         }
 
         @Override
         public void onLocationStatusChanged(int status) {
 
             if(status == AppLocationManager.LOCATION_GPS_AVAILABLE && !isNearbyFragmentShown() && checkLocationPermission()){
                 //request Stops
                 //pendingNearbyStopsRequest = false;
                 if (getContext()!= null && !isNearbyFragmentShown())
                     //mainHandler.post(new NearbyStopsRequester(getContext(), cr));
                     showNearbyFragmentIfPossible();
             }
         }
 
         @Override
         public long getLastUpdateTimeMillis() {
             return 50;
         }
 
         @Override
         public LocationCriteria getLocationCriteria() {
             return cr;
         }
 
         @Override
         public void onLocationProviderAvailable() {
             //Log.w(DEBUG_TAG, "pendingNearbyStopRequest: "+pendingNearbyStopsRequest);
             if(!isNearbyFragmentShown() && getContext()!=null){
                 // we should have the location permission
                 if(!checkLocationPermission())
                     Log.e(DEBUG_TAG, "Asking to show nearbystopfragment when " +
                             "we have no location permission");
                 pendingNearbyStopsFragmentRequest = true;
                 //mainHandler.post(new NearbyStopsRequester(getContext(), cr));
                 showNearbyFragmentIfPossible();
             }
         }
 
         @Override
         public void onLocationDisabled() {
 
         }
     };
 
 
 
     //// ACTIVITY ATTACHED (LISTENER ///
     private CommonFragmentListener mListener;
 
     private String pendingStopID = null;
     private CoordinatorLayout coordLayout;
 
     public MainScreenFragment() {
         // Required empty public constructor
     }
 
 
     public static MainScreenFragment newInstance() {
         return new MainScreenFragment();
     }
 
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         if (getArguments() != null) {
             //do nothing
             Log.d(DEBUG_TAG, "ARGS ARE NOT NULL: "+getArguments());
             if (getArguments().getString(PENDING_STOP_SEARCH)!=null)
                 pendingStopID = getArguments().getString(PENDING_STOP_SEARCH);
         }
     }
 
     @Override
     public View onCreateView(LayoutInflater inflater, ViewGroup container,
                              Bundle savedInstanceState) {
         // Inflate the layout for this fragment
         View root = inflater.inflate(R.layout.fragment_main_screen, container, false);
         /// UI ELEMENTS //
         busStopSearchByIDEditText = root.findViewById(R.id.busStopSearchByIDEditText);
         busStopSearchByNameEditText = root.findViewById(R.id.busStopSearchByNameEditText);
         progressBar = root.findViewById(R.id.progressBar);
 
         swipeRefreshLayout = root.findViewById(R.id.listRefreshLayout);
         floatingActionButton = root.findViewById(R.id.floatingActionButton);
         resultFrameLayout = root.findViewById(R.id.resultFrame);
         busStopSearchByIDEditText.setSelectAllOnFocus(true);
         busStopSearchByIDEditText
                 .setOnEditorActionListener((v, actionId, event) -> {
                     // IME_ACTION_SEARCH alphabetical option
                     if (actionId == EditorInfo.IME_ACTION_SEARCH) {
                         onSearchClick(v);
                         return true;
                     }
                     return false;
                 });
         busStopSearchByNameEditText
                 .setOnEditorActionListener((v, actionId, event) -> {
                     // IME_ACTION_SEARCH alphabetical option
                     if (actionId == EditorInfo.IME_ACTION_SEARCH) {
                         onSearchClick(v);
                         return true;
                     }
                     return false;
                 });
 
         swipeRefreshLayout
                 .setOnRefreshListener(() -> mainHandler.post(refreshStop));
         swipeRefreshLayout.setColorSchemeResources(R.color.blue_500, R.color.orange_500);
 
         coordLayout = root.findViewById(R.id.coord_layout);
 
         floatingActionButton.setOnClickListener((this::onToggleKeyboardLayout));
 
         AppCompatImageButton qrButton = root.findViewById(R.id.QRButton);
         qrButton.setOnClickListener(this::onQRButtonClick);
 
         AppCompatImageButton searchButton = root.findViewById(R.id.searchButton);
         searchButton.setOnClickListener(this::onSearchClick);
 
         // Fragment stuff
         childFragMan = getChildFragmentManager();
         childFragMan.addOnBackStackChangedListener(() -> Log.d("BusTO Main Fragment", "BACK STACK CHANGED"));
 
         fragmentHelper = new FragmentHelper(this, getChildFragmentManager(), getContext(), R.id.resultFrame);
         setSearchModeBusStopID();
 
 
 
         cr.setAccuracy(Criteria.ACCURACY_FINE);
         cr.setAltitudeRequired(false);
         cr.setBearingRequired(false);
         cr.setCostAllowed(true);
         cr.setPowerRequirement(Criteria.NO_REQUIREMENT);
 
         locationManager = AppLocationManager.getInstance(requireContext());
 
         Log.d(DEBUG_TAG, "OnCreateView, savedInstanceState null: "+(savedInstanceState==null));
 
 
         return root;
     }
 
     @Override
     public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
         super.onViewCreated(view, savedInstanceState);
         Log.d(DEBUG_TAG, "onViewCreated, SwipeRefreshLayout visible: "+(swipeRefreshLayout.getVisibility()==View.VISIBLE));
         Log.d(DEBUG_TAG, "Saved instance state is: "+savedInstanceState);
         //Restore instance state
         /*if (savedInstanceState!=null){
             Fragment fragment = getChildFragmentManager().getFragment(savedInstanceState, SAVED_FRAGMENT);
             if (fragment!=null){
                 getChildFragmentManager().beginTransaction().add(R.id.resultFrame, fragment).commit();
                 setupOnStart = false;
             }
         }
 
          */
         if (getChildFragmentManager().findFragmentById(R.id.resultFrame)!= null){
             swipeRefreshLayout.setVisibility(View.VISIBLE);
         }
 
     }
 
     @Override
     public void onSaveInstanceState(@NonNull Bundle outState) {
         super.onSaveInstanceState(outState);
         Log.d(DEBUG_TAG, "Saving instance state");
         Fragment fragment = getChildFragmentManager().findFragmentById(R.id.resultFrame);
         if (fragment!=null)
             getChildFragmentManager().putFragment(outState, SAVED_FRAGMENT, fragment);
         if (fragmentHelper!=null) fragmentHelper.setBlockAllActivities(true);
 
     }
 
     public void setSuppressArrivalsReload(boolean value){
        suppressArrivalsReload = value;
         // we have to suppress the reloading of the (possible) ArrivalsFragment
         /*if(value) {
             Fragment fragment = getChildFragmentManager().findFragmentById(R.id.resultFrame);
             if (fragment instanceof ArrivalsFragment) {
                 ArrivalsFragment frag = (ArrivalsFragment) fragment;
                 frag.setReloadOnResume(false);
             }
         }
 
          */
     }
 
 
     /**
      * Cancel the reload of the arrival times
      * because we are going to pop the fragment
      */
     public void cancelReloadArrivalsIfNeeded(){
         if(getContext()==null) return; //we are not attached
 
         //Fragment fr = getChildFragmentManager().findFragmentById(R.id.resultFrame);
         fragmentHelper.stopLastRequestIfNeeded(true);
         toggleSpinner(false);
     }
 
 
     @Override
     public void onAttach(@NonNull Context context) {
         super.onAttach(context);
 
         Log.d(DEBUG_TAG, "OnAttach called, setupOnAttach: "+ setupOnStart);
         mainHandler = new Handler();
         if (context instanceof CommonFragmentListener) {
             mListener = (CommonFragmentListener) context;
         } else {
             throw new RuntimeException(context
                     + " must implement CommonFragmentListener");
         }
 
     }
     @Override
     public void onDetach() {
         super.onDetach();
         mListener = null;
     //    setupOnAttached = true;
     }
 
     @Override
     public void onStart() {
         super.onStart();
         Log.d(DEBUG_TAG, "onStart called, setupOnStart: "+setupOnStart);
         if (setupOnStart) {
             if (pendingStopID==null){
 
                 if(PreferencesHolder.hasIntroFinishedOneShot(requireContext())){
                     Log.d(DEBUG_TAG, "Showing nearby stops");
                     if(!checkLocationPermission()){
                         requestLocationPermission();
                         pendingNearbyStopsFragmentRequest = true;
                     }
                     else {
                         showNearbyFragmentIfPossible();
                     }
                 } else {
                     //The Introductory Activity is about to be started, hence pause the request and show later
                     pendingIntroRun = true;
                 }
 
             }
             else{
                 ///TODO: if there is a stop displayed, we need to hold the update
             }
 
             setupOnStart = false;
         }
     }
 
     @Override
     public void onResume() {
         super.onResume();
 
         final Context con = requireContext();
         Log.w(DEBUG_TAG, "OnResume called, setupOnStart: "+ setupOnStart);
         if (locationManager == null)
             locationManager = AppLocationManager.getInstance(con);
         //recheck the introduction activity has been run
         if(pendingIntroRun && PreferencesHolder.hasIntroFinishedOneShot(con)){
             //request position permission if needed
             if(!checkLocationPermission()){
                 requestLocationPermission();
                 pendingNearbyStopsFragmentRequest = true;
             }
             else {
                 showNearbyFragmentIfPossible();
             }
             //deactivate flag
             pendingIntroRun = false;
         }
         if(Permissions.bothLocationPermissionsGranted(con)){
             Log.d(DEBUG_TAG, "Location permission OK");
             if(!locationManager.isRequesterRegistered(requester))
                 locationManager.addLocationRequestFor(requester);
         } //don't request permission
         // if we have a pending stopID request, do it
         Log.d(DEBUG_TAG, "Pending stop ID for arrivals: "+pendingStopID);
         //this is the second time we are attaching this fragment ->
         Log.d(DEBUG_TAG, "Waiting for new stop request: "+ suppressArrivalsReload);
         //TODO: if we come back to this from another fragment, and the user has given again the permission
         // for the Location, we should show the Nearby Stops
         if(!suppressArrivalsReload && pendingStopID==null){
             //none of the following cases are true
             // check if we are showing any fragment
             final Fragment fragment = getChildFragmentManager().findFragmentById(R.id.resultFrame);
             if(fragment==null || swipeRefreshLayout.getVisibility() != View.VISIBLE){
                 //we are not showing anything
                 if(Permissions.anyLocationPermissionsGranted(getContext())){
                     showNearbyFragmentIfPossible();
                 }
             }
         }
         if (suppressArrivalsReload){
             // we have to suppress the reloading of the (possible) ArrivalsFragment
             Fragment fragment = getChildFragmentManager().findFragmentById(R.id.resultFrame);
             if (fragment instanceof ArrivalsFragment){
                 ArrivalsFragment frag = (ArrivalsFragment) fragment;
                 frag.setReloadOnResume(false);
             }
             //deactivate
             suppressArrivalsReload = false;
         }
 
         if(pendingStopID!=null){
 
             Log.d(DEBUG_TAG, "Pending request for arrivals at stop ID: "+pendingStopID);
             requestArrivalsForStopID(pendingStopID);
             pendingStopID = null;
         }
         mListener.readyGUIfor(FragmentKind.MAIN_SCREEN_FRAGMENT);
 
         fragmentHelper.setBlockAllActivities(false);
 
     }
 
     @Override
     public void onPause() {
         //mainHandler = null;
         locationManager.removeLocationRequestFor(requester);
         super.onPause();
         fragmentHelper.setBlockAllActivities(true);
         fragmentHelper.stopLastRequestIfNeeded(true);
     }
 
 
 
 
     /*
     GUI METHODS
      */
     /**
      * QR scan button clicked
      *
      * @param v View QRButton clicked
      */
     public void onQRButtonClick(View v) {
 
         BarcodeScanOptions scanOptions = new BarcodeScanOptions();
         Intent intent = scanOptions.createScanIntent();
         if(!BarcodeScanUtils.checkTargetPackageExists(getContext(), intent)){
             BarcodeScanUtils.showDownloadDialog(null, this);
         }else {
             barcodeLauncher.launch(scanOptions);
         }
     }
 
     /**
      * OK this is pure shit
      *
      * @param v View clicked
      */
     public void onSearchClick(View v) {
         final StopsFinderByName[] stopsFinderByNames = new StopsFinderByName[]{new GTTStopsFetcher(), new FiveTStopsFetcher()};
         if (searchMode == SEARCH_BY_ID) {
             String busStopID = busStopSearchByIDEditText.getText().toString();
             fragmentHelper.stopLastRequestIfNeeded(true);
             requestArrivalsForStopID(busStopID);
         } else { // searchMode == SEARCH_BY_NAME
             String query = busStopSearchByNameEditText.getText().toString();
             query = query.trim();
             if(getContext()!=null) {
                 if (query.length() < 1) {
                     Toast.makeText(getContext(), R.string.insert_bus_stop_name_error, Toast.LENGTH_SHORT).show();
                 } else if(query.length()< 2){
                     Toast.makeText(getContext(), R.string.query_too_short, Toast.LENGTH_SHORT).show();
                 }
                 else {
                     fragmentHelper.stopLastRequestIfNeeded(true);
                     new AsyncStopsSearcher(fragmentHelper, stopsFinderByNames).execute(query);
                 }
             }
         }
     }
 
     public void onToggleKeyboardLayout(View v) {
 
         if (searchMode == SEARCH_BY_NAME) {
             setSearchModeBusStopID();
             if (busStopSearchByIDEditText.requestFocus()) {
                 showKeyboard();
             }
         } else { // searchMode == SEARCH_BY_ID
             setSearchModeBusStopName();
             if (busStopSearchByNameEditText.requestFocus()) {
                 showKeyboard();
             }
         }
 
     }
     @Override
     public void enableRefreshLayout(boolean yes) {
         swipeRefreshLayout.setEnabled(yes);
     }
 
     ////////////////////////////////////// GUI HELPERS /////////////////////////////////////////////
     public void showKeyboard() {
         if(getActivity() == null) return;
         InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
         View view = searchMode == SEARCH_BY_ID ? busStopSearchByIDEditText : busStopSearchByNameEditText;
         imm.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
     }
 
     private void setSearchModeBusStopID() {
         searchMode = SEARCH_BY_ID;
         busStopSearchByNameEditText.setVisibility(View.GONE);
         busStopSearchByNameEditText.setText("");
         busStopSearchByIDEditText.setVisibility(View.VISIBLE);
         floatingActionButton.setImageResource(R.drawable.alphabetical);
     }
 
     private void setSearchModeBusStopName() {
         searchMode = SEARCH_BY_NAME;
         busStopSearchByIDEditText.setVisibility(View.GONE);
         busStopSearchByIDEditText.setText("");
         busStopSearchByNameEditText.setVisibility(View.VISIBLE);
         floatingActionButton.setImageResource(R.drawable.numeric);
     }
     protected boolean isNearbyFragmentShown(){
         Fragment fragment = getChildFragmentManager().findFragmentByTag(NearbyStopsFragment.FRAGMENT_TAG);
         return (fragment!= null && fragment.isResumed());
     }
 
     /**
      * Having that cursor at the left of the edit text makes me cancer.
      *
      * @param busStopID bus stop ID
      */
     private void setBusStopSearchByIDEditText(String busStopID) {
         busStopSearchByIDEditText.setText(busStopID);
         busStopSearchByIDEditText.setSelection(busStopID.length());
     }
 
     @Nullable
     @org.jetbrains.annotations.Nullable
     @Override
     public View getBaseViewForSnackBar() {
         return coordLayout;
     }
 
     @Override
     public void toggleSpinner(boolean enable) {
         if (enable) {
             //already set by the RefreshListener when needed
             //swipeRefreshLayout.setRefreshing(true);
             progressBar.setVisibility(View.VISIBLE);
         } else {
             swipeRefreshLayout.setRefreshing(false);
             progressBar.setVisibility(View.GONE);
         }
     }
 
 
     private void prepareGUIForArrivals() {
         swipeRefreshLayout.setEnabled(true);
         swipeRefreshLayout.setVisibility(View.VISIBLE);
         //actionHelpMenuItem.setVisible(true);
     }
 
     private void prepareGUIForBusStops() {
         swipeRefreshLayout.setEnabled(false);
         swipeRefreshLayout.setVisibility(View.VISIBLE);
         //actionHelpMenuItem.setVisible(false);
     }
 
     private void actuallyShowNearbyStopsFragment(){
         swipeRefreshLayout.setVisibility(View.VISIBLE);
         final Fragment existingFrag = childFragMan.findFragmentById(R.id.resultFrame);
         // fragment;
         if (!(existingFrag instanceof NearbyStopsFragment)){
             Log.d(DEBUG_TAG, "actually showing Nearby Stops Fragment");
             //there is no fragment showing
             final NearbyStopsFragment fragment = NearbyStopsFragment.newInstance(NearbyStopsFragment.FragType.STOPS);
 
             FragmentTransaction ft = childFragMan.beginTransaction();
 
             ft.replace(R.id.resultFrame, fragment, NearbyStopsFragment.FRAGMENT_TAG);
             if (getActivity()!=null && !getActivity().isFinishing())
             ft.commit();
             else Log.e(DEBUG_TAG, "Not showing nearby fragment because activity null or is finishing");
         }
     }
 
 
     @Override
     public void showFloatingActionButton(boolean yes) {
         mListener.showFloatingActionButton(yes);
     }
 
     /**
      * This provides a temporary fix to make the transition
      * to a single asynctask go smoother
      *
      * @param fragmentType the type of fragment created
      */
     @Override
     public void readyGUIfor(FragmentKind fragmentType) {
 
 
         //if we are getting results, already, stop waiting for nearbyStops
         if (fragmentType == FragmentKind.ARRIVALS || fragmentType == FragmentKind.STOPS) {
             hideKeyboard();
 
             if (pendingNearbyStopsFragmentRequest) {
                 locationManager.removeLocationRequestFor(requester);
                 pendingNearbyStopsFragmentRequest = false;
             }
         }
 
         if (fragmentType == null) Log.e("ActivityMain", "Problem with fragmentType");
         else
             switch (fragmentType) {
                 case ARRIVALS:
                     prepareGUIForArrivals();
                     break;
                 case STOPS:
                     prepareGUIForBusStops();
                     break;
                 default:
                     Log.d(DEBUG_TAG, "Fragment type is unknown");
                     return;
             }
         // Shows hints
 
 
     }
 
     @Override
     public void openLineFromStop(String routeGtfsId, @Nullable String stopIDFrom) {
         //pass to activity
         mListener.openLineFromStop(routeGtfsId, stopIDFrom);
     }
 
     @Override
     public void openLineFromVehicle(String routeGtfsId, @Nullable String optionalPatternId, @Nullable Bundle args) {
         mListener.openLineFromVehicle(routeGtfsId, optionalPatternId, args);
     }
 
     @Override
     public void showMapCenteredOnStop(Stop stop) {
         if(mListener!=null) mListener.showMapCenteredOnStop(stop);
     }
 
     /**
      * Main method for stops requests
      * @param ID the Stop ID
      */
     @Override
     public void requestArrivalsForStopID(String ID) {
         if (!isResumed()){
             //defer request
             pendingStopID = ID;
             Log.d(DEBUG_TAG, "Deferring update for stop "+ID+ " saved: "+pendingStopID);
             return;
         }
         final boolean delayedRequest = !(pendingStopID==null);
         final FragmentManager framan = getChildFragmentManager();
         if (getContext()==null){
             Log.e(DEBUG_TAG, "Asked for arrivals with null context");
             return;
         }
         ArrivalsFetcher[] fetchers = utils.getDefaultArrivalsFetchers(getContext()).toArray(new ArrivalsFetcher[0]);
         if (ID == null || ID.length() <= 0) {
             // we're still in UI thread, no need to mess with Progress
             showToastMessage(R.string.insert_bus_stop_number_error, true);
             toggleSpinner(false);
         } else  if (framan.findFragmentById(R.id.resultFrame) instanceof ArrivalsFragment) {
             ArrivalsFragment fragment = (ArrivalsFragment) framan.findFragmentById(R.id.resultFrame);
             if (fragment != null && fragment.getStopID() != null && fragment.getStopID().equals(ID)){
                 // Run with previous fetchers
                 //fragment.getCurrentFetchers().toArray()
                 fragment.requestArrivalsForTheFragment();
             } else{
                 //SHOW NEW ARRIVALS FRAGMENT
                 //new AsyncArrivalsSearcher(fragmentHelper, fetchers, getContext()).execute(ID);
                 fragmentHelper.createOrUpdateStopFragment(new Palina(ID), true);
             }
         }
         else {
             Log.d(DEBUG_TAG, "This is probably the first arrivals search, preparing GUI");
             //prepareGUIForArrivals();
             //new AsyncArrivalsSearcher(fragmentHelper,fetchers, getContext()).execute(ID);
             fragmentHelper.createOrUpdateStopFragment(new Palina(ID), true);
 
         }
     }
 
     private boolean checkLocationPermission(){
         final Context context = getContext();
         if(context==null) return false;
 
         final boolean isOldVersion = Build.VERSION.SDK_INT < Build.VERSION_CODES.M;
         final boolean noPermission = ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
                 ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED;
 
         return isOldVersion || !noPermission;
 
     }
     private void requestLocationPermission(){
         requestPermissionLauncher.launch(LOCATION_PERMISSIONS);
     }
 
     private void showNearbyFragmentIfPossible() {
         if (isNearbyFragmentShown()) {
             //nothing to do
             Log.w(DEBUG_TAG, "Asked to show nearby fragment but we already are showing it");
             return;
         }
         if (getContext() == null) {
             Log.e(DEBUG_TAG, "Wanting to show nearby fragment but context is null");
             return;
         }
 
         if (fragmentHelper.getLastSuccessfullySearchedBusStop() == null
                 && !childFragMan.isDestroyed()) {
             //Go ahead with the request
 
             actuallyShowNearbyStopsFragment();
             pendingNearbyStopsFragmentRequest = false;
         }
     }
     /////////// LOCATION METHODS //////////
 
     /*
     private void startStopRequest(String provider) {
         Log.d(DEBUG_TAG, "Provider " + provider + " got enabled");
         if (locmgr != null && mainHandler != null && pendingNearbyStopsRequest && locmgr.getProvider(provider).meetsCriteria(cr)) {
 
         }
     }
 
      */
     /*
 
      * Run location requests separately and asynchronously
 
     class NearbyStopsRequester implements Runnable {
         Context appContext;
         Criteria cr;
 
         public NearbyStopsRequester(Context appContext, Criteria criteria) {
             this.appContext = appContext.getApplicationContext();
             this.cr = criteria;
         }
 
         @Override
         public void run() {
             if(isNearbyFragmentShown()) {
                 //nothing to do
                 Log.w(DEBUG_TAG, "launched nearby fragment request but we already are showing");
                 return;
             }
 
             final boolean isOldVersion = Build.VERSION.SDK_INT < Build.VERSION_CODES.M;
             final boolean noPermission = ActivityCompat.checkSelfPermission(appContext, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
                     ActivityCompat.checkSelfPermission(appContext, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED;
 
             //if we don't have the permission, we have to ask for it, if we haven't
             // asked too many times before
             if (noPermission) {
                 if (!isOldVersion) {
                     pendingNearbyStopsRequest = true;
                     //Permissions.assertLocationPermissions(appContext,getActivity());
                     requestPermissionLauncher.launch(LOCATION_PERMISSIONS);
                     Log.w(DEBUG_TAG, "Cannot get position: Asking permission, noPositionFromSys: " + noPermission);
                     return;
                 } else {
                     Toast.makeText(appContext, "Asked for permission position too many times", Toast.LENGTH_LONG).show();
                 }
             } else setOption(LOCATION_PERMISSION_GIVEN, true);
 
             AppLocationManager appLocationManager = AppLocationManager.getInstance(appContext);
             final boolean haveProviders = appLocationManager.anyLocationProviderMatchesCriteria(cr);
             if (haveProviders
                     && fragmentHelper.getLastSuccessfullySearchedBusStop() == null
                     && !fragMan.isDestroyed()) {
                 //Go ahead with the request
                 Log.d("mainActivity", "Recreating stop fragment");
                 showNearbyStopsFragment();
                 pendingNearbyStopsRequest = false;
             } else if(!haveProviders){
                 Log.e(DEBUG_TAG, "NO PROVIDERS FOR POSITION");
             }
 
         }
     }
 
      */
 
 }
\ No newline at end of file
diff --git a/app/src/main/java/it/reyboz/bustorino/fragments/MapLibreFragment.kt b/app/src/main/java/it/reyboz/bustorino/fragments/MapLibreFragment.kt
index 5cb180f..2c05198 100644
--- a/app/src/main/java/it/reyboz/bustorino/fragments/MapLibreFragment.kt
+++ b/app/src/main/java/it/reyboz/bustorino/fragments/MapLibreFragment.kt
@@ -1,800 +1,748 @@
+/*
+	BusTO  - Fragments components
+    Copyright (C) 2025 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.annotation.SuppressLint
 import android.content.Context
-import android.content.res.ColorStateList
 import android.location.Location
-import android.location.LocationListener
 import android.location.LocationManager
 import android.os.Bundle
 import android.util.Log
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import android.widget.ImageButton
 import android.widget.RelativeLayout
 import android.widget.Toast
-import it.reyboz.bustorino.backend.FiveTNormalizer
-import it.reyboz.bustorino.backend.gtfs.GtfsUtils
-import androidx.activity.result.ActivityResultCallback
-import androidx.activity.result.contract.ActivityResultContracts
 import androidx.core.content.ContextCompat
-import androidx.core.content.res.ResourcesCompat
-import androidx.core.view.ViewCompat
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.viewModels
 import androidx.preference.PreferenceManager
 import androidx.room.concurrent.AtomicBoolean
 import com.google.android.material.bottomsheet.BottomSheetBehavior
+import it.reyboz.bustorino.BuildConfig
 import it.reyboz.bustorino.R
 import it.reyboz.bustorino.backend.Stop
 import it.reyboz.bustorino.backend.gtfs.LivePositionUpdate
 import it.reyboz.bustorino.backend.mato.MQTTMatoClient
 import it.reyboz.bustorino.data.PreferencesHolder
 import it.reyboz.bustorino.data.gtfs.TripAndPatternWithStops
 import it.reyboz.bustorino.map.MapLibreStyles
-import it.reyboz.bustorino.util.Permissions
 import it.reyboz.bustorino.viewmodels.StopsMapViewModel
 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.engine.LocationEngineCallback
+import org.maplibre.android.location.engine.LocationEngineRequest
+import org.maplibre.android.location.engine.LocationEngineResult
 import org.maplibre.android.location.modes.CameraMode
+import org.maplibre.android.location.modes.RenderMode
 import org.maplibre.android.maps.MapLibreMap
 import org.maplibre.android.maps.Style
 import org.maplibre.android.plugins.annotation.Symbol
 import org.maplibre.geojson.Feature
 import org.maplibre.geojson.FeatureCollection
 
-
-// TODO: Rename parameter arguments, choose names that match
-// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
-private const val STOP_TO_SHOW = "stoptoshow"
-
 /**
  * A simple [Fragment] subclass.
  * Use the [MapLibreFragment.newInstance] factory method to
  * create an instance of this fragment.
  */
 class MapLibreFragment : GeneralMapLibreFragment() {
 
 
     private val stopsViewModel: StopsMapViewModel by viewModels()
     private var stopsShowing = ArrayList<Stop>(0)
 
     // Sources for stops and buses are in GeneralMapLibreFragment
     private var isUserMovingCamera = false
     private var lastStopsSizeShown = 0
     private var lastBBox = LatLngBounds.from(2.0, 2.0, 1.0,1.0)
-    private var mapInitCompleted =false
     private var stopsRedrawnTimes = 0
 
     //bottom Sheet behavior in GeneralMapLibreFragment
     //private var stopActiveSymbol: Symbol? = null
 
     // Location stuff
     private lateinit var locationManager: LocationManager
-    private lateinit var showUserPositionButton: ImageButton
+    private lateinit var userLocationButton: ImageButton
     private lateinit var centerUserButton: ImageButton
     private lateinit var followUserButton: ImageButton
 
     private var followingUserLocation = false
-    private var pendingLocationActivation = false
     private var ignoreCameraMovementForFollowing = true
-    private var enablingPositionFromClick = false
     private var restoredMapCamera = AtomicBoolean()
-    private var permissionsGranted = false
-
-    //TODO: Rewrite this mess using LocationEngineProvider in MapLibre
-    private val positionRequestLauncher = registerForActivityResult<Array<String>, Map<String, Boolean>>(
-            ActivityResultContracts.RequestMultiplePermissions(), ActivityResultCallback { result ->
-                if (result == null) {
-                    Log.w(DEBUG_TAG, "Got asked permission but request is null, doing nothing?")
-                }else if(!pendingLocationActivation){
-                    /// SHOULD DO NOTHING HERE
-                    Log.d(DEBUG_TAG, "Requested location but now there is no pendingLocationActivation")
-                } 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
-                    permissionsGranted = true
-                    if (context == null || requireContext().getSystemService(Context.LOCATION_SERVICE) == null)
-                        return@ActivityResultCallback
-                    val locationManager = requireContext().getSystemService(Context.LOCATION_SERVICE) as LocationManager
-                    var lastLoc = stopsViewModel.lastUserLocation
-                    @SuppressLint("MissingPermission")
-                    if(lastLoc==null)  lastLoc = locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER)
-                    else Log.d(DEBUG_TAG, "Got last location from cache")
-
-                    //FIRST CASE: I have no GPS
-                    if( !locationManager.allProviders.contains(LocationManager.GPS_PROVIDER) ){
-                        setMapLocationEnabled(false, false,false)
-
-                    }
-                    else if (lastLoc != null) {
-
-                        if(LatLng(lastLoc.latitude, lastLoc.longitude).distanceTo(DEFAULT_LATLNG) <= MAX_DIST_KM*1000){
-                            Log.d(DEBUG_TAG, "Showing the user position")
-                            setMapLocationEnabled(true, true, false)
-                        } else{
-                            setMapLocationEnabled(false, false,false)
-                            context?.let{Toast.makeText(it,R.string.too_far_not_showing_location, Toast.LENGTH_SHORT).show()}
-                        }
-                    } else requestInitialUserLocation()
-
-                } else{
-                    Toast.makeText(requireContext(),R.string.location_disabled, Toast.LENGTH_SHORT).show()
-                    Log.w(DEBUG_TAG, "No location permission")
-                }
-            })
-    private val showUserPositionRequestLauncher =
-        registerForActivityResult<Array<String>, Map<String, Boolean>>(
-            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
-                    setMapLocationEnabled(true, true, enablingPositionFromClick)
-                } else Log.w(DEBUG_TAG, "No location permission")
-            })
-
     //BUS POSITIONS
     private var usingMQTTPositions = true // THIS IS INSIDE VIEW MODEL NOW
 
     private val symbolsToUpdate = ArrayList<Symbol>()
 
     private var initialStopToShow : Stop? = null
     private var initialStopShown = false
     private var waitingDelayedBusUpdate = false
 
     //shown stuff
     //private var savedStateOnStop : Bundle? = null
 
     private val showBusLayer = true
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         arguments?.let {
             initialStopToShow = Stop.fromBundle(arguments)
             if (initialStopToShow==null){
 
             } else if(!initialStopToShow!!.hasCoords()){
                 //null the stop if it doesn't have coordinates, we cannot find it
                 initialStopToShow = null
             }
         }
     }
 
     override fun onCreateView(
         inflater: LayoutInflater, container: ViewGroup?,
         savedInstanceState: Bundle?
     ): View? {
         // Inflate the layout for this fragment
         val rootView =  inflater.inflate(R.layout.fragment_map_libre,
             container, false)
         //reset the counter
         lastStopsSizeShown = 0
         stopsRedrawnTimes = 0
         stopsLayerStarted = false
         symbolsToUpdate.clear()
 
         // Init layout view
 
         // Init the MapView
         mapView = rootView.findViewById(R.id.libreMapView)
 
         mapView.onCreate(savedInstanceState)
         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)
 
-        showUserPositionButton = rootView.findViewById(R.id.locationEnableIcon)
-        showUserPositionButton.setOnClickListener(this::switchUserLocationStatus)
+        userLocationButton = rootView.findViewById(R.id.locationEnableIcon)
+        userLocationButton.setOnClickListener(this::switchUserLocationStatus)
         followUserButton = rootView.findViewById(R.id.followUserImageButton)
         centerUserButton = rootView.findViewById(R.id.centerMapImageButton)
         busPositionsIconButton = rootView.findViewById(R.id.busPositionsImageButton)
         busPositionsIconButton.setOnClickListener {
             LivePositionsDialogFragment().show(parentFragmentManager, "LivePositionsDialog")
         }
         bottomSheetBehavior = BottomSheetBehavior.from(bottomSheet)
         bottomSheetBehavior.state = BottomSheetBehavior.STATE_HIDDEN
 
         arrivalsCard.setOnClickListener {
             if(context!=null){
                 Toast.makeText(context,"ARRIVALS", Toast.LENGTH_SHORT).show()
             }
         }
         centerUserButton.setOnClickListener {
             if(context!=null && locationComponent.isLocationComponentEnabled) {
                 val location = locationComponent.lastKnownLocation
 
                 location?.let {
                     mapView.getMapAsync { map ->
                         map.animateCamera(CameraUpdateFactory.newCameraPosition(
                             CameraPosition.Builder().target(LatLng(location.latitude, location.longitude)).build()), 500)
                     }
                 }
             }
         }
         followUserButton.setOnClickListener {
             // onClick user following button
-            if(context!=null && locationComponent.isLocationComponentEnabled){
-                if(followingUserLocation)
-                    locationComponent.cameraMode =  CameraMode.NONE
-                else locationComponent.cameraMode  = CameraMode.TRACKING
-                // CameraMode.TRACKING makes the camera move and jump to the location
+            if(context!=null && locationInitialized && locationComponent.isLocationComponentEnabled){
 
-               setFollowingUser(!followingUserLocation)
+                // CameraMode.TRACKING makes the camera move and jump to the location
+               setFollowUserLocation(!followingUserLocation)
             }
         }
-        locationManager = requireActivity().getSystemService(Context.LOCATION_SERVICE) as LocationManager
+        //locationManager = requireActivity().getSystemService(Context.LOCATION_SERVICE) as LocationManager
+        /*
         if (Permissions.bothLocationPermissionsGranted(requireContext()) && deviceHasGpsProvider()) {
+
             requestInitialUserLocation()
         } 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()
             }
             // PERMISSIONS REQUESTED AFTER MAP SETUP
         }
 
+         */
+
 
         // Setup close button
         rootView.findViewById<View>(R.id.btnClose).setOnClickListener {
             hideStopOrBusBottomSheet()
         }
         observeStatusLivePositions()
         //observe change in source of the live positions
         livePositionsViewModel.useMQTTPositionsLiveData.observe(viewLifecycleOwner){ useMQTT->
             //Log.d(DEBUG_TAG, "Changed MQTT positions, now have to use MQTT: $useMQTT")
             if (showBusLayer && isResumed) {
                 //Log.d(DEBUG_TAG, "Deciding to switch, the current source is using MQTT: $usingMQTTPositions")
                 if(useMQTT!=usingMQTTPositions){
                     // we have to switch
                     val clearPos = PreferenceManager.getDefaultSharedPreferences(requireContext()).getBoolean("positions_clear_on_switch_pref", true)
                     livePositionsViewModel.clearOldPositionsUpdates()
                     if(useMQTT){
                         //switching to MQTT, the GTFS positions are disabled automatically
                         livePositionsViewModel.requestMatoPosUpdates(MQTTMatoClient.LINES_ALL)
                     } else{
                         //switching to GTFS RT: stop Mato, launch first request
                         livePositionsViewModel.stopMatoUpdates()
                         livePositionsViewModel.requestGTFSUpdates()
                     }
                     Log.d(DEBUG_TAG, "Should clear positions: $clearPos")
                     if (clearPos) {
                         livePositionsViewModel.clearAllPositions()
                         //force clear of the viewed data
                         if(vehShowing.isNotEmpty()) hideStopOrBusBottomSheet()
                         clearAllBusPositionsInMap()
                     }
 
                 }
             }
             usingMQTTPositions = useMQTT
 
         }
+        mapStateViewModel.locationActive.observe(viewLifecycleOwner){ setLocationIconEnabled(it)}
+        mapStateViewModel.followingUserPosition.observe(viewLifecycleOwner){ updateFollowingIcon(it)}
 
         Log.d(DEBUG_TAG, "Fragment View Created!")
 
         //TODO: Reshow last open stop when switching back to the map fragment
         return rootView
     }
 
     /**
      * This method sets up the map and the layers
      */
     override fun onMapReady(mapReady: MapLibreMap) {
         this.map = mapReady
         val context = requireContext()
         val mjson = MapLibreStyles.getJsonStyleFromAsset(context, PreferencesHolder.getMapLibreStyleFile(context))
 
         val builder = Style.Builder().fromJson(mjson!!)
 
         mapReady.setStyle(builder) { style ->
 
             mapStyle = style
             //setupLayers(style)
             addImagesStyle(style)
 
-            initMapUserLocation(style, mapReady, requireContext())
             //init stop layer with this
             val stopsInCache = stopsViewModel.getAllStopsLoaded()
             if(stopsInCache.isEmpty())
                 initStopsLayer(style, null)
             else
                 displayStops(stopsInCache)
             if(showBusLayer) setupBusLayer(style, withLabels = true, busIconsScale = 1.2f)
 
             // Start observing data now that everything is set up
             observeStops()
+
+            checkInitMapLocation(mapReady,style, context)
         }
 
 
         mapReady.addOnCameraIdleListener {
-            isUserMovingCamera = false
             map?.let {
                 val newBbox = it.projection.visibleRegion.latLngBounds
                 if ((newBbox.center==lastBBox.center) && (newBbox.latitudeSpan==lastBBox.latitudeSpan) && (newBbox.longitudeSpan==lastBBox.latitudeSpan)){
                     //do nothing
                 } else {
                     stopsViewModel.loadStopsInLatLngBounds(newBbox)
                     lastBBox = newBbox
 
                 }
 
             }
 
         }
         mapReady.addOnCameraMoveStartedListener { v->
             if(v== MapLibreMap.OnCameraMoveStartedListener.REASON_API_GESTURE){
                 //the user is moving the map
-                isUserMovingCamera = true
+                //isUserMovingCamera = true
+                updateFollowingIcon(false)
             }
         }
 
         mapReady.addOnMapClickListener { point ->
            onMapClickReact(point)
         }
-
-        mapInitCompleted = true
         // we start requesting the bus positions now
         observeBusPositionUpdates()
 
         //Restoring data
 
-        if (initialStopToShow!=null){
+        if (initialStopToShow!=null && initialStopToShow?.hasCoords() == true){
             val s = initialStopToShow!!
             if(s.hasCoords()){
                 mapReady.cameraPosition = CameraPosition.Builder().target(
                     LatLng(s.latitude!!, s.longitude!!)
                 ).zoom(DEFAULT_ZOOM).build()
             }
             restoredMapCamera.set(true)
         } else{
             var boundsRestored = false
             //restore the map state here
             map?.let{
                 boundsRestored = mapStateViewModel.restoreMapState(it)
                  mapStateViewModel.lastOpenStopID.value?.let{ sID->
                      val s= stopsViewModel.getStopByID(sID)
                      if (s==null) {
                          if(sID.isNotEmpty())
                              Log.w(DEBUG_TAG,"Wanted to open stop $sID in map but it was not loaded!")
                      }
                      else{
                          openStopInBottomSheet(s) }
                  }
 
             }
             if(!boundsRestored){
-                mapReady.cameraPosition = CameraPosition.Builder().target(
-                    LatLng(DEFAULT_CENTER_LAT, DEFAULT_CENTER_LON)
-                ).zoom(DEFAULT_ZOOM).build()
+                // we have not restored the bounds, open normally in target location
+                // TODO: check that the map is reopened in the same location
+                val lastLoc = mapStateViewModel.locationToShow
+                val defaultLoc = LatLng(DEFAULT_CENTER_LAT, DEFAULT_CENTER_LON)
+                val proposedLoc = lastLoc?.let{ LatLng(lastLoc.latitude, lastLoc.longitude)}
+                val targetLoc = if(proposedLoc == null || proposedLoc.distanceTo(defaultLoc) > MAX_DIST_KM*1000)
+                        defaultLoc
+                    else proposedLoc
+
+
+                mapReady.cameraPosition = CameraPosition.Builder().target(targetLoc).zoom(DEFAULT_ZOOM).build()
             }
             restoredMapCamera.set(boundsRestored)
+
+
         }
+        mapInitialized = true
+
+        //pendingLocationActivation = true
+        //positionRequestLauncher.launch(Permissions.LOCATION_PERMISSIONS)
 
-        pendingLocationActivation = true
-        positionRequestLauncher.launch(Permissions.LOCATION_PERMISSIONS)
     }
 
     private fun onMapClickReact(point: LatLng): Boolean{
         map?.let { mapReady ->
             val screenPoint = mapReady.projection.toScreenLocation(point)
             val stopsFeatures = mapReady.queryRenderedFeatures(screenPoint, STOPS_LAYER_ID)
             val busNearby = mapReady.queryRenderedFeatures(screenPoint, BUSES_LAYER_ID)
             Log.d(DEBUG_TAG, "Clicked on stops: $stopsFeatures \n and buses: $busNearby")
             if (stopsFeatures.isNotEmpty()) {
                 val feature = stopsFeatures[0]
                 val id = feature.getStringProperty("id")
                 val name = feature.getStringProperty("name")
                 //Toast.makeText(requireContext(), "Clicked on $name ($id)", Toast.LENGTH_SHORT).show()
                 val stop = stopsViewModel.getStopByID(id)
                 Log.d(DEBUG_TAG, "Decided click is on stop with id $id : $stop")
                 stop?.let { newstop ->
                     val sameStopClicked = shownStopInBottomSheet?.let { newstop.ID==it.ID } ?: false
                     Log.d(DEBUG_TAG, "Hiding clicked stop: $sameStopClicked")
                     if (isBottomSheetShowing()) {
                         hideStopOrBusBottomSheet()
                     }
                     if(!sameStopClicked){
                         openStopInBottomSheet(newstop)
                         //isBottomSheetShowing = true
                         //move camera
                         if (newstop.latitude != null && newstop.longitude != null)
                         //mapReady.cameraPosition = CameraPosition.Builder().target(LatLng(it.latitude!!, it.longitude!!)).build()
                             mapReady.animateCamera(
                                 CameraUpdateFactory.newLatLng(LatLng(newstop.latitude!!, newstop.longitude!!)),
                                 750
                             )
                     }
 
                 }
                 return true
             } else if (busNearby.isNotEmpty()) {
                 val feature = busNearby[0]
                 val vehid = feature.getStringProperty("veh")
                 if (isBottomSheetShowing()) hideStopOrBusBottomSheet()
                 showVehicleTripInBottomSheet(vehid)
                 //move camera to center on vehicle
                 updatesByVehDict[vehid]?.let { dat ->
                     mapReady.animateCamera(
                         CameraUpdateFactory.newLatLng(LatLng(dat.posUpdate.latitude, dat.posUpdate.longitude)), 750
                     )
                 }
                 return true
             }
         }
         return false
     }
 
     override fun showOpenStopWithSymbolLayer(): Boolean {
         return false
     }
     override fun hideStopOrBusBottomSheet(){
         if (shownStopInBottomSheet?.ID == initialStopToShow?.ID){
             initialStopToShow = null
         }
         super.hideStopOrBusBottomSheet()
     }
 
     override fun onAttach(context: Context) {
         super.onAttach(context)
         fragmentListener = if (context is CommonFragmentListener) {
             context
         } else {
             throw RuntimeException(
                 context.toString()
                         + " must implement FragmentListenerMain"
             )
         }
     }
     override fun onDetach() {
         super.onDetach()
         fragmentListener = null
     }
 
     override fun onStart() {
         super.onStart()
     }
 
     override fun onResume() {
         super.onResume()
         //mapView.onResume() handled in GeneralMapLibreFragment
 
         if(showBusLayer) {
             //first, clean up all the old positions
             livePositionsViewModel.clearOldPositionsUpdates()
 
             if (livePositionsViewModel.useMQTTPositionsLiveData.value!!){
                 livePositionsViewModel.requestMatoPosUpdates(MQTTMatoClient.LINES_ALL)
                 usingMQTTPositions = true
             }
             else {
                 livePositionsViewModel.requestGTFSUpdates()
                 usingMQTTPositions = false
             }
 
             livePositionsViewModel.isLastWorkResultGood.observe(this) { d: Boolean ->
                 Log.d(
                     DEBUG_TAG, "Last trip download result is $d"
                 )
             }
             livePositionsViewModel.tripsGtfsIDsToQuery.observe(this) { dat: List<String> ->
                 Log.i(DEBUG_TAG, "Have these trips IDs missing from the DB, to be queried: $dat")
                 livePositionsViewModel.downloadTripsFromMato(dat)
             }
         }
 
         fragmentListener?.readyGUIfor(FragmentKind.MAP)
     }
 
     override fun onPause() {
         super.onPause()
         mapView.onPause()
         Log.d(DEBUG_TAG, "Fragment paused")
 
         map?.let{
             //if map is initialized
             mapStateViewModel.saveMapState(it)
         }
         mapStateViewModel.lastOpenStopID.postValue(shownStopInBottomSheet?.ID)
         if (livePositionsViewModel.useMQTTPositionsLiveData.value!!) livePositionsViewModel.stopMatoUpdates()
 
     }
 
     override fun onStop() {
         super.onStop()
         mapView.onStop()
         Log.d(DEBUG_TAG, "Fragment stopped!")
        /* stopsViewModel.savedState = Bundle().let {
             mapView.onSaveInstanceState(it)
             it
         }
         */
         //save last location
-        map?.locationComponent?.lastKnownLocation?.let{
-            stopsViewModel.lastUserLocation = it
-        }
+        if (locationInitialized)
+            map?.locationComponent?.lastKnownLocation?.let{
+                stopsViewModel.lastUserLocation = it
+            }
 
 
     }
 
     override fun onMapDestroy() {
         mapStyle.removeLayer(STOPS_LAYER_ID)
         mapStyle.removeSource(STOPS_SOURCE_ID)
 
         mapStyle.removeLayer(BUSES_LAYER_ID)
         mapStyle.removeSource(BUSES_SOURCE_ID)
 
 
-        //map?.locationComponent?.isLocationComponentEnabled = false
     }
     override fun getBaseViewForSnackBar(): View? {
         return mapView
     }
 
     private fun showVehicleTripInBottomSheet(veh: String) {
         val data = updatesByVehDict[veh] ?: return
         super.showVehicleTripInBottomSheet(veh) { patternCode, _ ->
             map?.let { mapStateViewModel.saveMapState(it) }
             fragmentListener?.openLineFromVehicle(
                 data.posUpdate.getLineGTFSFormat(),
                 patternCode,
                 mapStateViewModel.savedCameraState?.toBundle()
             )
         }
     }
     private fun observeStops() {
         // Observe stops
         stopsViewModel.stopsToShow.observe(viewLifecycleOwner) { stops ->
             stopsShowing = ArrayList(stops)
             displayStops(stopsShowing)
             initialStopToShow?.let{ s->
                 //show the stop in the bottom sheet
                 if(!initialStopShown && (s.ID in stopsShowing.map { it.ID })) {
                     val stopToShow = stopsShowing.first { it.ID == s.ID }
                     openStopInBottomSheet(stopToShow)
                     initialStopShown = true
                 }
             }
         }
 
     }
 
     /**
      * Add the stops to the layers
      */
     private fun displayStops(stops: List<Stop>?) {
         if (stops.isNullOrEmpty()) return
 
         if (stops.size==lastStopsSizeShown){
             Log.d(DEBUG_TAG, "Not updating, have same number of stops. After 3 times")
             return
         }
         /*if(stops.size> lastStopsSizeShown){
             stopsRedrawnTimes = 0
         } else{
             stopsRedrawnTimes++
         }
 
          */
 
         val features = ArrayList<Feature>()//stops.mapNotNull { stop ->
             //stop.latitude?.let { lat ->
             //    stop.longitude?.let { lon ->
         for (s in stops){
             if (s.latitude!=null && s.longitude!=null)
                 features.add(stopToGeoJsonFeature(s))
 
 
         }
         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))
             lastStopsSizeShown = features.size
         } else
             map?.let {
                 Log.d(DEBUG_TAG, "Map stop layer is not started yet, init layer")
                 initStopsLayer(mapStyle, FeatureCollection.fromFeatures(features))
                 Log.d(DEBUG_TAG,"Started stops layer on map")
                 lastStopsSizeShown = features.size
                 stopsLayerStarted = true
             }
     }
 
     // --------------- BUS LOCATIONS STUFF --------------------------
     /**
      * Start requesting position updates
      */
     private fun observeBusPositionUpdates() {
         livePositionsViewModel.updatesWithTripAndPatterns.observe(viewLifecycleOwner) { data: HashMap<String, Pair<LivePositionUpdate, TripAndPatternWithStops?>> ->
             Log.d(
                 DEBUG_TAG,
-                "Have " + data.size + " trip updates, has Map start finished: " + mapInitCompleted
+                "Have " + data.size + " trip updates, has Map start finished: $mapInitialized"
             )
-            if (mapInitCompleted) updateBusPositionsInMap(data, hasVehicleTracking = true) { veh ->
+            if (mapInitialized) updateBusPositionsInMap(data, hasVehicleTracking = true) { veh ->
                 showVehicleTripInBottomSheet(veh)
             }
             if (!isDetached && !livePositionsViewModel.useMQTTPositionsLiveData.value!!) livePositionsViewModel.requestDelayedGTFSUpdates(
                 3000
             )
         }
     }
 
 
     // ------ LOCATION STUFF -----
+
+
+
     @SuppressLint("MissingPermission")
-    private fun requestInitialUserLocation() {
-        val provider : String = LocationManager.GPS_PROVIDER//getBestLocationProvider()
-
-        //provider.let {
-        setLocationIconEnabled(true)
-        Toast.makeText(requireContext(), R.string.position_searching_message, Toast.LENGTH_SHORT).show()
-        locationManager.requestSingleUpdate(provider, object : LocationListener {
-            override fun onLocationChanged(location: Location) {
-                val userLatLng = LatLng(location.latitude, location.longitude)
-                val distanceToTarget = userLatLng.distanceTo(DEFAULT_LATLNG)
-
-                if (distanceToTarget <= MAX_DIST_KM*1000.0) {
-                    map?.let{
-                        // if we are still waiting for the position to enable
-                        if(pendingLocationActivation)
-                            setMapLocationEnabled(true, true, false)
+    override fun onMapLocationComponentInitialized() {
+        //locationComponent.cameraMode = CameraMode.TRACKING
+
+        locationComponent.renderMode = RenderMode.COMPASS
+        locationComponent.locationEngine?.apply{
+            // this is only called once
+            getLastLocation(object : LocationEngineCallback<LocationEngineResult> {
+                override fun onSuccess(res: LocationEngineResult?) {
+                    Log.d(DEBUG_TAG, "Got the last location, ${res?.lastLocation}")
+                    res?.lastLocation?.let { loc ->
+                        if(mapInitialized)
+                            map?.cameraPosition = CameraPosition.Builder().target(LatLng(loc.latitude, loc.longitude)).build()
+                        else
+                           mapStateViewModel.locationToShow = loc
                     }
-                } else {
-                    Toast.makeText(context, R.string.too_far_not_showing_location, Toast.LENGTH_SHORT).show()
-                    setMapLocationEnabled(false,false, false)
                 }
-            }
-
-            override fun onProviderDisabled(provider: String) {}
-            override fun onProviderEnabled(provider: String) {}
 
-            @Deprecated("Deprecated in Java")
-            override fun onStatusChanged(provider: String?, status: Int, extras: Bundle?) {}
-        }, null)
+                override fun onFailure(p0: java.lang.Exception) {
+                    Log.e(DEBUG_TAG, "Failed to get the last location", p0)
+                }
 
+            })
+        }
     }
 
+    override fun onMapLocationEnabled(active: Boolean) {
+        //Extra stuff to do
+        setFollowUserLocation(active)
+    }
 
-    /**
-     * Handles logic of enabling the user location on the map
-     */
     @SuppressLint("MissingPermission")
-    private fun setMapLocationEnabled(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, fromClick: $fromClick")
-                locationComponent.isLocationComponentEnabled = true
-                if (!restoredMapCamera.get()) {
-                    locationComponent.cameraMode = CameraMode.TRACKING //CameraMode.TRACKING
-                    setFollowingUser(true)
+    override fun onFirstReceivedLocation(location: Location) {
+
+        val it = location
+        if(locationInitialized && !receivedFirstLocation) {
+            //only zoom if the user position is close enough to the center
+            val newPoint = LatLng(it.latitude, it.longitude)
+            if(newPoint.distanceTo(LatLng(
+                    MapLibreFragment.DEFAULT_CENTER_LAT,
+                    MapLibreFragment.DEFAULT_CENTER_LON
+                ))
+                > MAX_DIST_KM * 1000){
+                //show Toast
+                if(!shownToastNoPosition) context?.let{ c->
+                    Toast.makeText(c, R.string.too_far_not_showing_location, Toast.LENGTH_LONG).show()
+                    shownToastNoPosition = true
                 }
-                setLocationIconEnabled(true)
-                if (fromClick) Toast.makeText(context, R.string.location_enabled, Toast.LENGTH_SHORT).show()
-                pendingLocationActivation =false
-                //locationComponent.locationEngine.requestLocationUpdates()
+                setLocationComponentEnabled(false)
+                //Update UI Status
+                mapStateViewModel.locationActive.value = false
+                mapStateViewModel.followingUserPosition.value = false
             } 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()
+                map?.apply {
+                    animateCamera(
+                        CameraUpdateFactory.newCameraPosition(
+                            CameraPosition.Builder().target(LatLng(location.latitude, location.longitude)).build()
+                        ),
+                        1000
+                    )
+                    setLocationComponentEnabled(true)
+                    locationComponent.cameraMode = CameraMode.TRACKING
+                    mapStateViewModel.locationActive.value = true
                 }
-                Log.d(DEBUG_TAG, "Requesting permission to show user location")
-                showUserPositionRequestLauncher.launch(Permissions.LOCATION_PERMISSIONS)
-            }
-        } else{
-            locationComponent.isLocationComponentEnabled = false
-            setFollowingUser(false)
-            setLocationIconEnabled(false)
-            if (fromClick) {
-                Toast.makeText(requireContext(), R.string.location_disabled, Toast.LENGTH_SHORT).show()
-                if(pendingLocationActivation) pendingLocationActivation=false //Cancel the request for the enablement of the position
+                setFollowUserLocation(true)
             }
         }
-
+        else{
+            //check for this is when the map is used
+            mapStateViewModel.locationToShow = location
+        }
     }
 
-
-
-    private fun setLocationIconEnabled(enabled: Boolean){
+    override fun setLocationIconEnabled(enabled: Boolean){
         if (enabled)
-            showUserPositionButton.setImageDrawable(ContextCompat.getDrawable(requireContext(), R.drawable.location_circlew_red))
+            userLocationButton.setImageDrawable(ContextCompat.getDrawable(requireContext(), R.drawable.location_circlew_red))
         else
-            showUserPositionButton.setImageDrawable(ContextCompat.getDrawable(requireContext(), R.drawable.location_circlew_grey))
+            userLocationButton.setImageDrawable(ContextCompat.getDrawable(requireContext(), R.drawable.location_circlew_grey))
 
     }
 
     private fun updateFollowingIcon(enabled: Boolean){
         if(enabled)
             followUserButton.setImageDrawable(ContextCompat.getDrawable(requireContext(), R.drawable.walk_circle_active))
         else
             followUserButton.setImageDrawable(ContextCompat.getDrawable(requireContext(), R.drawable.walk_circle_inactive))
 
     }
-    private fun setFollowingUser(following: Boolean){
-        updateFollowingIcon(following)
-        followingUserLocation = following
-        if(following)
-            ignoreCameraMovementForFollowing = true
-    }
-
 
     /**
-     * Method used for enabling / disabling the location
+     * This sets both the status on the component if it has been activated and the icon in the Fragment
      */
-    private fun switchUserLocationStatus(view: View?){
-        if(pendingLocationActivation || locationComponent.isLocationComponentEnabled)
-            setMapLocationEnabled(false, false, true)
-        else{
-            if(locationManager.allProviders.contains(LocationManager.GPS_PROVIDER)) {
-                pendingLocationActivation = true
-                Log.d(DEBUG_TAG, "Request enable location")
-                setMapLocationEnabled(true, false, true)
-            } else{
-                Log.w(DEBUG_TAG, "Cannot find location, no GPS")
-            }
-
+    private fun setFollowUserLocation(enabled: Boolean){
+        if(locationInitialized) {
+            if (enabled)
+                locationComponent.cameraMode = CameraMode.TRACKING
+            else locationComponent.cameraMode = CameraMode.NONE
         }
+        //update the icon by updating the livedata
+        mapStateViewModel.followingUserPosition.value = enabled
     }
 
 
     companion object {
         private const val STOPS_SOURCE_ID = "stops-source"
         private const val STOPS_LAYER_ID = "stops-layer"
 
         private const val LABELS_LAYER_ID = "bus-labels-layer"
         private const val LABELS_SOURCE = "labels-source"
         private const val STOP_IMAGE_ID ="bus-stop-icon"
         const val DEFAULT_CENTER_LAT = 45.0708
         const val DEFAULT_CENTER_LON = 7.6858
         private val DEFAULT_LATLNG = LatLng(DEFAULT_CENTER_LAT, DEFAULT_CENTER_LON)
         private val DEFAULT_ZOOM = 14.3
         private const val POSITION_FOUND_ZOOM = 16.5
         private const val NO_POSITION_ZOOM = 17.1
-        private const val MAX_DIST_KM = 90.0
 
         private const val DEBUG_TAG = "BusTO-MapLibreFrag"
         private const val STOP_ACTIVE_IMG = "Stop-active"
 
         const val FRAGMENT_TAG = "BusTOMapFragment"
 
         private const val LOCATION_PERMISSION_REQUEST_CODE = 981202
 
         /**
          * Use this factory method to create a new instance of
          * this fragment using the provided parameters.
          *
          * @param stop Eventual stop to center the map into
          * @return A new instance of fragment MapLibreFragment.
          */
         @JvmStatic
         fun newInstance(stop: Stop?) =
             MapLibreFragment().apply {
                 arguments = Bundle().let {
                     // Cannot use Parcelable as it requires higher version of Android
                     //stop?.let{putParcelable(STOP_TO_SHOW, it)}
                     stop?.toBundle(it)
                 }
             }
 
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/it/reyboz/bustorino/fragments/ScreenBaseFragment.java b/app/src/main/java/it/reyboz/bustorino/fragments/ScreenBaseFragment.java
index 5647038..838863c 100644
--- a/app/src/main/java/it/reyboz/bustorino/fragments/ScreenBaseFragment.java
+++ b/app/src/main/java/it/reyboz/bustorino/fragments/ScreenBaseFragment.java
@@ -1,105 +1,112 @@
 package it.reyboz.bustorino.fragments;
 
 import android.Manifest;
 import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
 import android.content.SharedPreferences;
+import android.net.Uri;
+import android.provider.Settings;
 import android.view.View;
 import android.view.inputmethod.InputMethodManager;
 import android.widget.Toast;
 
 import androidx.activity.result.ActivityResultCallback;
 import androidx.activity.result.ActivityResultLauncher;
 import androidx.activity.result.contract.ActivityResultContracts;
 import androidx.annotation.Nullable;
+import androidx.appcompat.app.AlertDialog;
 import androidx.fragment.app.Fragment;
 
 import com.google.android.material.snackbar.Snackbar;
 import it.reyboz.bustorino.BuildConfig;
+import it.reyboz.bustorino.R;
 
 import java.util.Map;
 
 import static android.content.Context.MODE_PRIVATE;
 
 public abstract class ScreenBaseFragment extends Fragment {
 
     protected final static String PREF_FILE= BuildConfig.APPLICATION_ID+".fragment_prefs";
 
     protected void setOption(String optionName, boolean value) {
         Context mContext = getContext();
         SharedPreferences.Editor editor = mContext.getSharedPreferences(PREF_FILE, MODE_PRIVATE).edit();
         editor.putBoolean(optionName, value);
         editor.commit();
     }
 
     protected boolean getOption(String optionName, boolean optDefault) {
         Context mContext = getContext();
         assert mContext != null;
         return getOption(mContext, optionName, optDefault);
     }
 
     protected void showToastMessage(int messageID, boolean short_lenght) {
         final int length = short_lenght ? Toast.LENGTH_SHORT : Toast.LENGTH_LONG;
         final Context context = getContext();
         if(context!=null)
             Toast.makeText(context, messageID, length).show();
     }
 
     public void hideKeyboard() {
         if (getActivity()==null) return;
         View view = getActivity().getCurrentFocus();
         if (view != null) {
             ((InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE))
                     .hideSoftInputFromWindow(view.getWindowToken(),
                             InputMethodManager.HIDE_NOT_ALWAYS);
         }
     }
 
     /**
      * Find the view on which the snackbar should be shown
      * @return a view or null if you don't want the snackbar shown
      */
     @Nullable
     public abstract View getBaseViewForSnackBar();
 
     /**
      * Empty method to override properties of the Snackbar before showing it
      * @param snackbar the Snackbar to be possibly modified
      */
     public void setSnackbarPropertiesBeforeShowing(Snackbar snackbar){
 
     }
     public boolean showSnackbarOnDBUpdate() {
         return true;
     }
 
     public static boolean getOption(Context context, String optionName, boolean optDefault){
         SharedPreferences preferences = context.getSharedPreferences(PREF_FILE, MODE_PRIVATE);
         return preferences.getBoolean(optionName, optDefault);
     }
     public static void setOption(Context context,String optionName, boolean value) {
         SharedPreferences.Editor editor = context.getSharedPreferences(PREF_FILE, MODE_PRIVATE).edit();
         editor.putBoolean(optionName, value);
         editor.apply();
     }
     public ActivityResultLauncher<String[]> getPositionRequestLauncher(LocationRequestListener listener){
         return registerForActivityResult(new ActivityResultContracts.RequestMultiplePermissions(), new ActivityResultCallback<>() {
             @Override
             public void onActivityResult(Map<String, Boolean> result) {
                 if (result == null) return;
 
                 if (result.get(Manifest.permission.ACCESS_COARSE_LOCATION) == null ||
                         result.get(Manifest.permission.ACCESS_FINE_LOCATION) == null)
                     return;
                 final boolean coarseGranted = Boolean.TRUE.equals(result.get(Manifest.permission.ACCESS_COARSE_LOCATION));
                 final boolean fineGranted = Boolean.TRUE.equals(result.get(Manifest.permission.ACCESS_FINE_LOCATION));
 
                 listener.onPermissionResult(coarseGranted, fineGranted);
             }
         });
     }
 
+
     public interface LocationRequestListener{
         void onPermissionResult(boolean isCoarseGranted, boolean isFineGranted);
     }
 
 }
diff --git a/app/src/main/java/it/reyboz/bustorino/map/MapLibreLocationEngine.kt b/app/src/main/java/it/reyboz/bustorino/map/MapLibreLocationEngine.kt
new file mode 100644
index 0000000..ab0ffd0
--- /dev/null
+++ b/app/src/main/java/it/reyboz/bustorino/map/MapLibreLocationEngine.kt
@@ -0,0 +1,114 @@
+package it.reyboz.bustorino.map
+
+import android.app.PendingIntent
+import android.os.Looper
+import android.util.Log
+import org.maplibre.android.location.engine.LocationEngine
+import org.maplibre.android.location.engine.LocationEngineCallback
+import org.maplibre.android.location.engine.LocationEngineRequest
+import org.maplibre.android.location.engine.LocationEngineResult
+
+import it.reyboz.bustorino.middleware.FusedNativeLocationProvider
+
+/**
+ * Adattatore che implementa l'interfaccia [LocationEngine] di MapLibre
+ * delegando a [FusedNativeLocationProvider].
+ *
+ * Separa completamente la logica di fusione dei provider (in [FusedNativeLocationProvider])
+ * dalla traduzione nel contratto MapLibre (qui).
+ *
+ * Uso:
+ *   val provider = FusedNativeLocationProvider(context)
+ *   val engine   = MapLibreLocationEngine(provider)
+ *   // poi passa engine a LocationComponentActivationOptions
+ */
+class MapLibreLocationEngine(
+    private val provider: FusedNativeLocationProvider,
+) : LocationEngine {
+
+    // Mappa callback MapLibre → listener del provider, per poterli rimuovere
+    private val callbackListeners =
+        HashMap<LocationEngineCallback<LocationEngineResult>, FusedNativeLocationProvider.LocationUpdateListener>()
+
+
+    override fun getLastLocation(callback: LocationEngineCallback<LocationEngineResult>) {
+        val location = provider.getLastLocationFromProviders()
+        if (location != null) {
+            callback.onSuccess(LocationEngineResult.create(location))
+        } else {
+            callback.onFailure(NoLocationException())
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // requestLocationUpdates — overload con Looper (quello usato da MapLibre)
+    // -------------------------------------------------------------------------
+
+    override fun requestLocationUpdates(
+        request: LocationEngineRequest,
+        callback: LocationEngineCallback<LocationEngineResult>,
+        looper: Looper?,
+    ) {
+        val providerListener = FusedNativeLocationProvider.LocationUpdateListener { location ->
+            callback.onSuccess(LocationEngineResult.create(location))
+        }
+
+        callbackListeners[callback] = providerListener
+        provider.addListener(providerListener)
+
+        // Avvia (o riavvia) il provider con i parametri della request MapLibre.
+        // Se il provider è già attivo con altri listener, stop+start lo ri-configura.
+        provider.startUpdates(
+            FusedNativeLocationProvider.Options(
+                minIntervalMs    = request.interval,
+                minDisplacementM = request.displacement,
+                looper           = looper,
+            )
+        )
+    }
+
+    // -------------------------------------------------------------------------
+    // requestLocationUpdates — overload con PendingIntent (background/geofencing)
+    // -------------------------------------------------------------------------
+
+    override fun requestLocationUpdates(
+        request: LocationEngineRequest,
+        pendingIntent: PendingIntent,
+    ) {
+        // PendingIntent is used for background updates via BroadcastReceiver.
+        // FusedNativeLocationProvider operates in the foreground: delegating to PendingIntent
+        // would require a different architecture (LocationManager.requestLocationUpdates
+        // with native PendingIntent). Not supported in this implementation.
+        throw UnsupportedOperationException(
+            "MapLibreLocationEngine does not support updates via PendingIntent. " +
+                    "Use requestLocationUpdates(request, callback, looper) or " +
+                    "implement a dedicated BroadcastReceiver."
+        )
+    }
+
+    // -------------------------------------------------------------------------
+    // removeLocationUpdates — overload con callback
+    // -------------------------------------------------------------------------
+
+    override fun removeLocationUpdates(callback: LocationEngineCallback<LocationEngineResult>) {
+        callbackListeners.remove(callback)?.let { providerListener ->
+            provider.removeListener(providerListener)
+        }
+        Log.d(DEBUG_TAG, "Removed location updates callback $callback")
+    }
+
+    // -------------------------------------------------------------------------
+    // removeLocationUpdates — overload con PendingIntent
+    // -------------------------------------------------------------------------
+
+    override fun removeLocationUpdates(pendingIntent: PendingIntent) {
+        throw UnsupportedOperationException(
+            "MapLibreLocationEngine does not support PendingIntent removal."
+        )
+    }
+
+    class NoLocationException : Exception()
+    companion object {
+        const val DEBUG_TAG = "BusTO-MapLocationEngine"
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/it/reyboz/bustorino/middleware/AppLocationManager.kt b/app/src/main/java/it/reyboz/bustorino/middleware/AppLocationManager.kt
index bd8472f..5b2967d 100644
--- a/app/src/main/java/it/reyboz/bustorino/middleware/AppLocationManager.kt
+++ b/app/src/main/java/it/reyboz/bustorino/middleware/AppLocationManager.kt
@@ -1,278 +1,275 @@
 /*
 	BusTO (middleware)
     Copyright (C) 2019 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.middleware
 
 import android.Manifest
 import android.content.Context
 import android.content.pm.PackageManager
 import android.location.*
 import android.os.Bundle
 import android.util.Log
 import androidx.core.content.ContextCompat
 import androidx.core.location.LocationListenerCompat
 import it.reyboz.bustorino.util.LocationCriteria
 import it.reyboz.bustorino.util.Permissions
 import java.lang.ref.WeakReference
 import kotlin.math.min
 
 /**
  * Singleton class used to access location. Possibly extended with other location sources.
  *
  * 2024: This is far too much. We need to simplify the whole mechanism (no more singleton)
  */
 class AppLocationManager private constructor(context: Context) : LocationListener {
     private val appContext: Context
     private val locMan: LocationManager
     private val BUNDLE_LOCATION = "location"
     private var oldGPSLocStatus = LOCATION_UNAVAILABLE
     private var minimum_time_milli = -1
     private val requestersRef = ArrayList<WeakReference<LocationRequester?>>()
 
     init {
         appContext = context.applicationContext
         locMan = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
     }
 
     @Throws(SecurityException::class)
     private fun requestGPSPositionUpdates(): Boolean {
         val timeinterval =
             if (minimum_time_milli > 0 && minimum_time_milli < Int.MAX_VALUE) minimum_time_milli else 2000
         locMan.removeUpdates(this)
         if (!checkLocationPermission(appContext)){
             Log.e(DEBUG_TAG, "No location permission!!")
             return false
         }
         if (locMan.allProviders.contains("gps")) locMan.requestLocationUpdates(
             LocationManager.GPS_PROVIDER,
             timeinterval.toLong(),
             5f,
             this
         )
         /*LocationManagerCompat.requestLocationUpdates(locMan, LocationManager.GPS_PROVIDER,
                     new LocationRequestCompat.Builder(timeinterval).setMinUpdateDistanceMeters(5.F).build(),this, );
                     TODO: find a way to do this
              */
         return true
     }
 
     private fun cleanAndUpdateRequesters() {
         minimum_time_milli = Int.MAX_VALUE
         val iter = requestersRef.listIterator()
         while (iter.hasNext()) {
             val cReq = iter.next().get()
             if (cReq == null) iter.remove() else {
                 minimum_time_milli = min(cReq.locationCriteria.timeInterval.toDouble(), minimum_time_milli.toDouble())
                     .toInt()
             }
         }
         Log.d(
             DEBUG_TAG,
             "Updated requesters, got " + requestersRef.size + " listeners to update every " + minimum_time_milli + " ms at least"
         )
     }
 
     fun addLocationRequestFor(req: LocationRequester) {
         var present = false
         minimum_time_milli = Int.MAX_VALUE
         var countNull = 0
         val iter = requestersRef.listIterator()
         while (iter.hasNext()) {
             val cReq = iter.next().get()
             if (cReq == null) {
                 countNull++
                 iter.remove()
             } else if (cReq == req) {
                 present = true
                 minimum_time_milli = min(cReq.locationCriteria.timeInterval.toDouble(), minimum_time_milli.toDouble())
                     .toInt()
             }
         }
         Log.d(DEBUG_TAG, "$countNull listeners have been removed because null")
         if (!present) {
             val newref = WeakReference(req)
             requestersRef.add(newref)
             minimum_time_milli = min(req.locationCriteria.timeInterval.toDouble(), minimum_time_milli.toDouble())
                 .toInt()
             Log.d(DEBUG_TAG, "Added new stop requester, instance of " + req.javaClass.simpleName)
         }
         if (requestersRef.size > 0) {
             Log.d(DEBUG_TAG, "Requesting location updates")
             requestGPSPositionUpdates()
         }
     }
 
     fun removeLocationRequestFor(req: LocationRequester) {
         minimum_time_milli = Int.MAX_VALUE
         val iter = requestersRef.listIterator()
         while (iter.hasNext()) {
             val cReq = iter.next().get()
             if (cReq == null || cReq == req) iter.remove() else {
                 minimum_time_milli = min(cReq.locationCriteria.timeInterval.toDouble(), minimum_time_milli.toDouble())
                     .toInt()
             }
         }
         if (requestersRef.size <= 0) {
             locMan.removeUpdates(this)
         }
     }
 
     private fun sendLocationStatusToAll(status: Int) {
         val iter = requestersRef.listIterator()
         while (iter.hasNext()) {
             val cReq = iter.next().get()
             if (cReq == null) iter.remove() else cReq.onLocationStatusChanged(status)
         }
     }
 
     fun isRequesterRegistered(requester: LocationRequester): Boolean {
         for (regRef in requestersRef) {
             if (regRef.get() != null && regRef.get() === requester) return true
         }
         return false
     }
 
     override fun onLocationChanged(location: Location) {
         Log.d(
             DEBUG_TAG, "found location: \nlat: ${location.latitude} lon: ${location.longitude} accuracy: ${location.accuracy}"
         )
         val iter = requestersRef.listIterator()
         var new_min_interval = Int.MAX_VALUE
         while (iter.hasNext()) {
             val requester = iter.next().get()
             if (requester == null) iter.remove() else {
                 val timeNow = System.currentTimeMillis()
                 val criteria = requester.locationCriteria
                 if (location.accuracy < criteria.minAccuracy &&
                     timeNow - requester.lastUpdateTimeMillis > criteria.timeInterval
                 ) {
                     requester.onLocationChanged(location)
                     Log.d(
                         "AppLocationManager",
                         "Updating position for instance of requester " + requester.javaClass.simpleName
                     )
                 }
                 //update minimum time interval
                 new_min_interval = min(requester.locationCriteria.timeInterval.toDouble(), new_min_interval.toDouble())
                     .toInt()
             }
         }
         minimum_time_milli = new_min_interval
         if (requestersRef.size == 0) {
             //stop requesting the position
             locMan.removeUpdates(this)
         }
     }
 
     @Deprecated("Deprecated in Java")
     override fun onStatusChanged(provider: String, status: Int, extras: Bundle) {
         //IF ANOTHER LOCATION SOURCE IS READY, USE IT
         //OTHERWISE, SIGNAL THAT WE HAVE NO LOCATION
         if (oldGPSLocStatus != status) {
             if (status == LocationProvider.OUT_OF_SERVICE || status == LocationProvider.TEMPORARILY_UNAVAILABLE) {
                 sendLocationStatusToAll(LOCATION_UNAVAILABLE)
             } else if (status == LocationProvider.AVAILABLE) {
                 sendLocationStatusToAll(LOCATION_GPS_AVAILABLE)
             }
             oldGPSLocStatus = status
         }
         Log.d(DEBUG_TAG, "Provider status changed: $provider status: $status")
     }
 
     override fun onProviderEnabled(provider: String) {
         cleanAndUpdateRequesters()
         requestGPSPositionUpdates()
         Log.d(DEBUG_TAG, "Provider: $provider enabled")
         for (req in requestersRef) {
             if (req.get() == null) continue
             req.get()!!.onLocationProviderAvailable()
         }
     }
 
     override fun onProviderDisabled(provider: String) {
         cleanAndUpdateRequesters()
         for (req in requestersRef) {
             if (req.get() == null) continue
             req.get()!!.onLocationDisabled()
         }
         //locMan.removeUpdates(this);
         Log.d(DEBUG_TAG, "Provider: $provider disabled")
     }
 
-    fun anyLocationProviderMatchesCriteria(cr: Criteria?): Boolean {
-        return Permissions.anyLocationProviderMatchesCriteria(locMan, cr, true)
-    }
 
     /**
      * Interface to be implemented to get the location request
      */
     interface LocationRequester {
         /**
          * Do something with the newly obtained location
          * @param loc the obtained location
          */
         fun onLocationChanged(loc: Location?)
 
         /**
          * Inform the requester that the GPS status has changed
          * @param status new status
          */
         fun onLocationStatusChanged(status: Int)
 
         /**
          * We have a location provider available
          */
         fun onLocationProviderAvailable()
 
         /**
          * Called when location is disabled
          */
         fun onLocationDisabled()
 
         /**
          * Give the last time of update the requester has
          * Set it to -1 in order to receive each new location
          * @return the time for update in milliseconds since epoch
          */
         val lastUpdateTimeMillis: Long
 
         /**
          * Get the specifications for the location
          * @return fully parsed LocationCriteria
          */
         val locationCriteria: LocationCriteria
     }
 
     companion object {
         const val LOCATION_GPS_AVAILABLE = 22
         const val LOCATION_UNAVAILABLE = -22
         private const val DEBUG_TAG = "BUSTO LocAdapter"
         private var instance: AppLocationManager? = null
         @JvmStatic
         fun getInstance(con: Context): AppLocationManager {
             if (instance == null) instance = AppLocationManager(con)
             return instance!!
         }
 
         fun checkLocationPermission(context: Context?): Boolean {
             return ContextCompat.checkSelfPermission(
                 context!!,
                 Manifest.permission.ACCESS_FINE_LOCATION
             ) == PackageManager.PERMISSION_GRANTED
         }
     }
 }
diff --git a/app/src/main/java/it/reyboz/bustorino/middleware/FusedNativeLocationProvider.kt b/app/src/main/java/it/reyboz/bustorino/middleware/FusedNativeLocationProvider.kt
new file mode 100644
index 0000000..92398c1
--- /dev/null
+++ b/app/src/main/java/it/reyboz/bustorino/middleware/FusedNativeLocationProvider.kt
@@ -0,0 +1,263 @@
+package it.reyboz.bustorino.middleware
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.location.Location
+import android.location.LocationListener
+import android.location.LocationManager
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import it.reyboz.bustorino.BuildConfig
+import it.reyboz.bustorino.util.Permissions
+import java.util.concurrent.CopyOnWriteArraySet
+
+/**
+ * Native Android location provider that fuses GPS_PROVIDER, NETWORK_PROVIDER
+ * and PASSIVE_PROVIDER with no dependency on Google Play Services.
+ *
+ * Standalone class to be used anywhere in the app
+ *
+ */
+class FusedNativeLocationProvider(context: Context) {
+
+    // -------------------------------------------------------------------------
+    // Public interface for location update consumers
+    // -------------------------------------------------------------------------
+
+    fun interface LocationUpdateListener {
+        fun onLocationUpdate(location: Location)
+    }
+
+    /**
+     * Configuration for location updates.
+     *
+     * @param minIntervalMs     Minimum interval between updates in ms.
+     * @param minDisplacementM  Minimum displacement in meters to trigger an update.
+     * @param looper            Thread on which to receive callbacks. Null = main thread.
+     * @param useGps            Enables GPS_PROVIDER.
+     * @param useNetwork        Enables NETWORK_PROVIDER (WiFi + cell).
+     * @param usePassive        Enables PASSIVE_PROVIDER (zero consumption, opportunistic updates).
+     */
+    data class Options(
+        val minIntervalMs: Long = 500L,
+        val minDisplacementM: Float = 5f,
+        val looper: Looper? = null,
+        val useGps: Boolean = true,
+        val useNetwork: Boolean = true,
+        val usePassive: Boolean = true,
+    )
+
+
+    private val locationManager =
+        context.applicationContext.getSystemService(Context.LOCATION_SERVICE) as LocationManager
+
+    // List of registered listeners (called on the configured looper)
+    private val listeners = CopyOnWriteArraySet<LocationUpdateListener>()
+
+    // Active Android listeners, one per provider
+    private val activeAndroidListeners = mutableListOf<LocationListener>()
+
+    @Volatile
+    private var bestLocation: Location? = null
+
+    @Volatile
+    private var running = false
+
+    private var runningOptions = Options(500L, 5f, null, true, true, true)
+
+    private val activeProviders = ArrayList<String>()
+
+    private var havePermissions = false
+
+    //private val removedListener = mutableSetOf<LocationUpdateListener>()
+
+    private val handler by lazy { Handler(runningOptions.looper ?: Looper.getMainLooper()) }
+
+    //private var appContext = context.applicationContext
+
+    // -------------------------------------------------------------------------
+    // Public API
+    // -------------------------------------------------------------------------
+
+    /**
+     * Adds a listener. Can be called before or after [startUpdates].
+     */
+    fun addListener(listener: LocationUpdateListener) {
+        if(BuildConfig.DEBUG)
+            Log.d(DEBUG_TAG, "Adding listener $listener")
+        synchronized(listeners) {
+            listeners.add(listener)
+        }
+    }
+
+    /**
+     * Removes a previously registered listener.
+     */
+    fun removeListener(listener: LocationUpdateListener) {
+        if(BuildConfig.DEBUG)
+            Log.d(DEBUG_TAG, "Removing listener $listener")
+        synchronized(listeners){
+            if(listeners.remove(listener)){
+                if(listeners.isEmpty()) stopUpdates()
+            }
+            if(BuildConfig.DEBUG)
+                Log.d(DEBUG_TAG, "Listener now size: ${listeners.size}")
+        }
+    }
+
+    /**
+     * Starts receiving location updates from the enabled providers.
+     * If already running, stops the existing providers first and restarts
+     * them with the new configuration.
+     *
+     * Requires ACCESS_FINE_LOCATION or ACCESS_COARSE_LOCATION.
+     */
+    @SuppressLint("MissingPermission")
+    fun startUpdates(options: Options?): Boolean {
+        if (running) stopUpdates()
+        if (options!=null){
+            runningOptions = options
+        }
+        val selectedProviders = buildList {
+            if (runningOptions.useGps)     add(LocationManager.GPS_PROVIDER)
+            if (runningOptions.useNetwork) add(LocationManager.NETWORK_PROVIDER)
+            if (runningOptions.usePassive) add(LocationManager.PASSIVE_PROVIDER)
+        }
+
+        val effectiveLooper = runningOptions.looper ?: Looper.getMainLooper()
+
+        selectedProviders.forEach { provider ->
+            if (!locationManager.isProviderEnabled(provider)) return@forEach
+
+            val locListener = LocationListener { location ->
+                if (isBetterLocation(location, bestLocation)) {
+                    bestLocation = location
+                    //Log.d(DEBUG_TAG, "New best location: $bestLocation")
+                    notifyListeners(location)
+                }
+            }
+
+            //runCatching {
+            locationManager.requestLocationUpdates(
+                provider,
+                runningOptions.minIntervalMs,
+                runningOptions.minDisplacementM,
+                locListener,
+                effectiveLooper,
+            )
+            activeAndroidListeners.add(locListener)
+            activeProviders.add(provider)
+            //}
+        }
+
+        running = activeAndroidListeners.isNotEmpty()
+        Log.d(DEBUG_TAG, "Started location updates, running: $running, with providers: $activeProviders")
+        return running
+    }
+
+    /**
+     * Stops all updates and releases the Android listeners.
+     * [LocationUpdateListener]s registered via [addListener] are retained:
+     * calling [startUpdates] again will resume delivering updates to them.
+     */
+    private fun stopUpdatesInternal() {
+        if(!running) //we have already done this
+            return
+        Log.d(DEBUG_TAG, "Actually stopping location updates, active providers: $activeProviders")
+        activeAndroidListeners.forEach { listener ->
+            runCatching { locationManager.removeUpdates(listener) }
+        }
+        activeAndroidListeners.clear()
+        running = false
+        activeProviders.clear()
+    }
+
+    /**
+     * Returns the best known location cached by the enabled providers,
+     * without starting continuous updates.
+     *
+     * May return null if no provider has ever acquired a fix
+     * (e.g. first launch, device just turned on).
+     *
+     * Do not use if we do not have the Location permission
+     */
+    @SuppressLint("MissingPermission")
+    fun getLastLocationFromProviders(): Location? {
+        val candidatesLocations = listOf(
+            LocationManager.GPS_PROVIDER,
+            LocationManager.NETWORK_PROVIDER,
+            LocationManager.PASSIVE_PROVIDER,
+        ).mapNotNull { provider ->
+             locationManager.getLastKnownLocation(provider)
+        }
+
+        // Among the candidates, the most accurate wins. On equal accuracy,
+        // the most recent wins.
+        return candidatesLocations.minWithOrNull(
+            compareBy({ it.accuracy }, { -it.time })
+        )
+    }
+
+    //fun getLastReceivedBestLocation(): Location? {
+    //    return bestLocation
+    //}
+
+
+    private fun notifyListeners(location: Location) {
+        //synchronized(listeners) {
+            listeners.forEach { it.onLocationUpdate(location) }
+    }
+
+    /**
+     * Public call for stopping the updates
+     */
+    fun stopUpdates() {
+        Log.d(DEBUG_TAG, "Stopping updates")
+        if (Looper.myLooper() == handler.looper) {
+            stopUpdatesInternal()
+        } else {
+            handler.post { stopUpdatesInternal() }
+        }
+    }
+
+
+
+    companion object {
+        private const val TIME_DELAY = 2 * 60 * 1_000L  // two minutes
+        private const val ACCURACY_DEGRADATION_THRESHOLD_M = 200f
+        private const val DEBUG_TAG = "BusTO-FusedLocationProv"
+
+        /**
+         * Determines whether [candidate] is a better location than [current].
+         *
+         * Criteria, in priority order:
+         * 1. If the candidate is newer than [TIME_DELAY], always accept it.
+         * 2. If it is significantly older, reject it.
+         * 3. Equal freshness: the one with lower accuracy (tighter radius) wins.
+         * 4. Same provider, same freshness delta, and not degrading too much: accept.
+         */
+        @JvmStatic
+        fun isBetterLocation(candidate: Location, current: Location?): Boolean {
+            if (current == null) return true
+
+            val timeDeltaMs = candidate.time - current.time
+
+            return when {
+                timeDeltaMs > TIME_DELAY  -> true   // much more recent: accept immediately
+                timeDeltaMs < -TIME_DELAY -> false  // much older: reject immediately
+                else -> {
+                    val accuracyDeltaM = candidate.accuracy - current.accuracy
+                    when {
+                        accuracyDeltaM < 0 -> true   // more accurate
+                        accuracyDeltaM == 0f && timeDeltaMs > 0 -> true   // same accuracy, fresher
+                        timeDeltaMs > 0
+                                && accuracyDeltaM <= ACCURACY_DEGRADATION_THRESHOLD_M
+                                && candidate.provider == current.provider -> true
+                        else -> false
+                    }
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/it/reyboz/bustorino/util/Permissions.java b/app/src/main/java/it/reyboz/bustorino/util/Permissions.java
deleted file mode 100644
index 8bbb696..0000000
--- a/app/src/main/java/it/reyboz/bustorino/util/Permissions.java
+++ /dev/null
@@ -1,73 +0,0 @@
-package it.reyboz.bustorino.util;
-
-import android.Manifest;
-import android.app.Activity;
-import android.content.Context;
-import android.content.pm.PackageManager;
-import android.location.Criteria;
-import android.location.LocationManager;
-import android.os.Build;
-import android.util.Log;
-
-import androidx.annotation.RequiresApi;
-import androidx.core.app.ActivityCompat;
-import androidx.core.content.ContextCompat;
-
-import java.util.List;
-
-public class Permissions {
-    final static public String DEBUG_TAG = "BusTO -Permissions";
-
-    final static public int PERMISSION_REQUEST_POSITION = 33;
-    final static public String LOCATION_PERMISSION_GIVEN = "loc_permission";
-    final static public int STORAGE_PERMISSION_REQ = 291;
-
-    final static public int PERMISSION_OK = 0;
-    final static public int PERMISSION_ASKING = 11;
-    final static public int PERMISSION_NEG_CANNOT_ASK = -3;
-
-    final static public String[] LOCATION_PERMISSIONS={Manifest.permission.ACCESS_COARSE_LOCATION,
-            Manifest.permission.ACCESS_FINE_LOCATION};
-    //final static public String[] NOTIFICATION_PERMISSION={Manifest.permission.POST_NOTIFICATIONS};
-
-    @RequiresApi(api = Build.VERSION_CODES.TIRAMISU)
-    public static String[] getNotificationPermissions(){
-        return new String[]{Manifest.permission.POST_NOTIFICATIONS};
-    }
-
-    public static boolean anyLocationProviderMatchesCriteria(LocationManager mng, Criteria cr, boolean enabled) {
-        List<String> providers = mng.getProviders(cr, enabled);
-        Log.d(DEBUG_TAG, "Getting enabled location providers: ");
-        for (String s : providers) {
-            Log.d(DEBUG_TAG, "Provider " + s);
-        }
-        return !providers.isEmpty();
-    }
-    public static boolean isPermissionGranted(Context con,String permission){
-        return ContextCompat.checkSelfPermission(con, permission) == PackageManager.PERMISSION_GRANTED;
-    }
-
-    public static boolean bothLocationPermissionsGranted(Context con){
-        return isPermissionGranted(con, Manifest.permission.ACCESS_FINE_LOCATION) &&
-                isPermissionGranted(con, Manifest.permission.ACCESS_COARSE_LOCATION);
-    }
-    public static boolean anyLocationPermissionsGranted(Context con){
-        return isPermissionGranted(con, Manifest.permission.ACCESS_FINE_LOCATION) ||
-                isPermissionGranted(con, Manifest.permission.ACCESS_COARSE_LOCATION);
-    }
-
-    public static void assertLocationPermissions(Context con, Activity activity) {
-        if(!isPermissionGranted(con, Manifest.permission.ACCESS_FINE_LOCATION) ||
-                !isPermissionGranted(con,Manifest.permission.ACCESS_COARSE_LOCATION)){
-            ActivityCompat.requestPermissions(activity,new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, PERMISSION_REQUEST_POSITION);
-        }
-    }
-
-    /**
-     * Check if the system requires the POST_NOTIFICATION permission to send notifications
-     * @return true if required
-     */
-    public static boolean isNotificationPermissionNeeded(){
-        return (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU);
-    }
-}
diff --git a/app/src/main/java/it/reyboz/bustorino/util/Permissions.kt b/app/src/main/java/it/reyboz/bustorino/util/Permissions.kt
new file mode 100644
index 0000000..2ec7efc
--- /dev/null
+++ b/app/src/main/java/it/reyboz/bustorino/util/Permissions.kt
@@ -0,0 +1,156 @@
+package it.reyboz.bustorino.util
+
+import android.Manifest
+import android.app.Activity
+import android.content.Context
+import android.content.DialogInterface
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.location.Criteria
+import android.location.LocationManager
+import android.net.Uri
+import android.os.Build
+import android.provider.Settings
+import android.util.Log
+import android.widget.Toast
+import androidx.activity.result.ActivityResultLauncher
+import androidx.annotation.RequiresApi
+import androidx.appcompat.app.AlertDialog
+import androidx.core.app.ActivityCompat
+import androidx.core.app.ActivityCompat.shouldShowRequestPermissionRationale
+import androidx.core.content.ContextCompat
+import androidx.core.content.ContextCompat.startActivity
+import it.reyboz.bustorino.R
+import java.util.concurrent.atomic.AtomicInteger
+import kotlin.concurrent.atomics.AtomicInt
+
+class Permissions private constructor(private val appContext: Context) {
+
+    /*
+    @get:RequiresApi(api = Build.VERSION_CODES.TIRAMISU)
+    val notificationPermissions: Array<String>
+        //final static public String[] NOTIFICATION_PERMISSION={Manifest.permission.POST_NOTIFICATIONS};
+        get() = arrayOf<String>(Manifest.permission.POST_NOTIFICATIONS)
+
+     */
+    private var askedTimesLocation = AtomicInteger(0)
+
+    fun anyLocationProviderMatchesCriteria(mng: LocationManager, cr: Criteria, enabled: Boolean): Boolean {
+        val providers = mng.getProviders(cr, enabled)
+        Log.d(DEBUG_TAG, "Getting enabled location providers: ")
+        for (s in providers) {
+            Log.d(DEBUG_TAG, "Provider " + s)
+        }
+        return !providers.isEmpty()
+    }
+
+
+    fun checkRequestLocationPermissions(activity: Activity, launcher: ActivityResultLauncher<Array<String>>): Boolean {
+
+         //activity.getSharedPreferences(, Context.MODE_PRIVATE)
+        var launched = false
+        if(shouldShowRequestPermissionRationale(activity,Manifest.permission.ACCESS_FINE_LOCATION)){
+            Toast.makeText(activity, R.string.enable_position_message_map, Toast.LENGTH_LONG).show()
+        } /*else{
+            //cannot show the dialog anymore, go to the settings
+            openShowAppSettingsLocationDialog()
+        }
+        */
+        val reqTimes = askedTimesLocation.getAndIncrement()
+        Log.d(DEBUG_TAG, "Requesting location permissions, asked ${reqTimes} times ")
+        if(reqTimes > 4){
+            openShowAppSettingsLocationDialog()
+        } else{
+            launcher.launch(LOCATION_PERMISSIONS)
+            launched = true
+        }
+        return launched
+    }
+
+    /**
+     * Show alert dialog to enable location permission
+     */
+    fun openShowAppSettingsLocationDialog() {
+        val context = appContext
+        val builder = AlertDialog.Builder(context)
+
+        builder.setTitle(R.string.no_permission_dialog_title)
+        builder.setMessage(R.string.no_permission_dialog_text_location)
+        builder.setPositiveButton(
+            R.string.no_permission_dialog_open,
+            DialogInterface.OnClickListener { dialogInterface: DialogInterface?, i: Int ->
+                val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
+                intent.setData(Uri.fromParts("package", context.getPackageName(), null))
+                context.startActivity(intent)
+            })
+        builder.setNegativeButton(android.R.string.cancel, null)
+        builder.show()
+    }
+
+
+    fun assertLocationPermissions(con: Context, activity: Activity) {
+        if (!isPermissionGranted(con, Manifest.permission.ACCESS_FINE_LOCATION) ||
+            !isPermissionGranted(con, Manifest.permission.ACCESS_COARSE_LOCATION)
+        ) {
+            ActivityCompat.requestPermissions(
+                activity,
+                arrayOf<String>(Manifest.permission.ACCESS_FINE_LOCATION),
+                PERMISSION_REQUEST_POSITION
+            )
+        }
+    }
+
+
+
+    companion object{
+        const val DEBUG_TAG: String = "BusTO -Permissions"
+
+        const val PERMISSION_REQUEST_POSITION: Int = 33
+        const val LOCATION_PERMISSION_GIVEN: String = "loc_permission"
+        const val STORAGE_PERMISSION_REQ: Int = 291
+
+        const val PERMISSION_OK: Int = 0
+        const val PERMISSION_ASKING: Int = 11
+        const val PERMISSION_NEG_CANNOT_ASK: Int = -3
+
+        @JvmField
+        val LOCATION_PERMISSIONS: Array<String> = arrayOf(
+            Manifest.permission.ACCESS_COARSE_LOCATION,
+            Manifest.permission.ACCESS_FINE_LOCATION
+        )
+
+        @JvmStatic
+        fun isPermissionGranted(con: Context, permission: String): Boolean {
+            return ContextCompat.checkSelfPermission(con, permission) == PackageManager.PERMISSION_GRANTED
+        }
+        @JvmStatic
+        fun bothLocationPermissionsGranted(con: Context): Boolean {
+            return isPermissionGranted(con, Manifest.permission.ACCESS_FINE_LOCATION) &&
+                    isPermissionGranted(con, Manifest.permission.ACCESS_COARSE_LOCATION)
+        }
+
+        @JvmStatic
+        fun anyLocationPermissionsGranted(con: Context): Boolean {
+            return isPermissionGranted(con, Manifest.permission.ACCESS_FINE_LOCATION) ||
+                    isPermissionGranted(con, Manifest.permission.ACCESS_COARSE_LOCATION)
+        }
+
+        /**
+         * Check if the system requires the POST_NOTIFICATION permission to send notifications
+         * @return true if required
+         */
+        @JvmStatic
+        fun isNotificationPermissionNeeded() = (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU)
+
+
+
+        @Volatile
+        private var instance: Permissions? = null
+
+        fun getInstance(context: Context) =
+            instance ?: synchronized(this) {
+                instance ?: Permissions(context.applicationContext).also { instance = it }
+            }
+
+    }
+}
diff --git a/app/src/main/java/it/reyboz/bustorino/viewmodels/ArrivalsViewModel.kt b/app/src/main/java/it/reyboz/bustorino/viewmodels/ArrivalsViewModel.kt
index ba40734..ea5d49a 100644
--- a/app/src/main/java/it/reyboz/bustorino/viewmodels/ArrivalsViewModel.kt
+++ b/app/src/main/java/it/reyboz/bustorino/viewmodels/ArrivalsViewModel.kt
@@ -1,245 +1,262 @@
+/*
+	BusTO - View Model components
+    Copyright (C) 2025 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.viewmodels
 
 import android.app.Application
 import android.content.Context
 import android.util.Log
 import androidx.lifecycle.AndroidViewModel
 import androidx.lifecycle.MediatorLiveData
 import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.viewModelScope
 import it.reyboz.bustorino.backend.*
 import it.reyboz.bustorino.backend.mato.MatoAPIFetcher
 import it.reyboz.bustorino.data.NextGenDB
 import it.reyboz.bustorino.data.OldDataRepository
 import it.reyboz.bustorino.middleware.RecursionHelper
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import java.util.concurrent.Executors
 import java.util.concurrent.atomic.AtomicReference
 
 class ArrivalsViewModel(application: Application): AndroidViewModel(application) {
 
     // Arrivals of palina
     val appContext: Context
 
     val palinaLiveData = MediatorLiveData<Palina>()
     val sourcesLiveData = MediatorLiveData<Passaggio.Source>()
 
     val resultLiveData = MutableLiveData<Fetcher.Result>()
 
     val currentFetchers = MediatorLiveData<List<ArrivalsFetcher>>()
 
     /// OLD REPO for stops instance
     private val executor = Executors.newFixedThreadPool(2)
     private val oldRepo = OldDataRepository(executor, NextGenDB.getInstance(application))
 
     private var stopIdRequested = ""
     private val stopFromDB = MutableLiveData<Stop>()
 
     val arrivalsRequestRunningLiveData = MutableLiveData(false)
 
     private val oldRepoStopCallback = OldDataRepository.Callback<List<Stop>>{ stopListRes ->
         if(stopIdRequested.isEmpty()) return@Callback
 
         if(stopListRes.isSuccess) {
             val stopF = stopListRes.result!!.filter { s -> s.ID == stopIdRequested }
             if (stopF.isEmpty()) {
                 Log.w(DEBUG_TAG, "Requested stop $stopIdRequested but is not in the list from database: ${stopListRes.result}")
             } else{
                 stopFromDB.postValue(stopF[0])
                 Log.d(DEBUG_TAG, "Setting new stop ${stopF[0]} from database")
             }
         } else{
             Log.e(DEBUG_TAG, "Requested stop ${stopIdRequested} from database but error occured: ${stopListRes.exception}")
         }
     }
 
     init {
         appContext = application.applicationContext
 
         palinaLiveData.addSource(stopFromDB){
             s ->
             val hasSource = palinaLiveData.value?.passaggiSourceIfAny
             Log.d(DEBUG_TAG, "Have current palina ${palinaLiveData.value!=null}, source passaggi $hasSource,  new incoming stop $s from database")
             val newp = if(palinaLiveData.value == null) Palina(s) else Palina.mergePaline(palinaLiveData.value, Palina(s))
             Log.d(DEBUG_TAG, "Merged palina: $newp, num passages: ${newp?.totalNumberOfPassages}, has coords: ${newp?.hasCoords()}")
             newp?.let { pal -> palinaLiveData.postValue(pal) }
         }
 
     }
 
     fun clearPalinaArrivals(palina: Palina) : Palina{
         palina.clearRoutes()
         return palina
     }
 
     fun requestArrivalsForStop(stopId: String, fetchers: List<ArrivalsFetcher>){
         val context = appContext //application.applicationContext
         currentFetchers.value = fetchers
         //THIS IS TOTALLY WRONG!!!
         /*palinaLiveData.value?.let{
             palinaLiveData.value = clearPalinaArrivals(it)
         }
 
          */
         //request stop from the DB
         stopIdRequested = stopId
         oldRepo.requestStopsWithGtfsIDs(listOf("gtt:$stopId"), oldRepoStopCallback)
         arrivalsRequestRunningLiveData.value = true
         viewModelScope.launch(Dispatchers.IO){
             runArrivalsFetching(stopId, fetchers, context)
         }
     }
 
     fun requestArrivalsForStop(stopId: String, fetchersSources: Array<String>){
         val fetchers = constructFetchersFromStrList(fetchersSources)
         requestArrivalsForStop(stopId, fetchers)
     }
 
     private suspend fun runArrivalsFetching(stopId: String, fetchers: List<ArrivalsFetcher>, appContext: Context) {
 
         if (fetchers.isEmpty()) {
             //do nothing
             arrivalsRequestRunningLiveData.postValue(false)
             return
         }
 
         // Equivalente del doInBackground nell'AsyncTask
         val recursionHelper = RecursionHelper(fetchers.toTypedArray())
         var resultPalina : Palina? = null
 
         val stringBuilder = StringBuilder()
         for (f in fetchers) {
             stringBuilder.append("")
             stringBuilder.append(f.javaClass.simpleName)
             stringBuilder.append("; ")
         }
         Log.d(DEBUG_TAG, "Using fetchers: $stringBuilder")
 
         val resultRef = AtomicReference<Fetcher.Result>()
 
         while (recursionHelper.valid()) {
 
             val fetcher = recursionHelper.getAndMoveForward()
 
             sourcesLiveData.postValue(fetcher.sourceForFetcher)
 
 
             if (fetcher is ArrivalsFetcherContext) {
                 fetcher.setContext(appContext)
             }
             Log.d(DEBUG_TAG, "Using the ArrivalsFetcher: ${fetcher.javaClass}")
 
             // Verifica se è un fetcher per MetroStop da saltare
             try {
                 if (fetcher is FiveTAPIFetcher && stopId.toInt() >= 8200) {
                     continue
                 }
             } catch (ex: NumberFormatException) {
                 Log.e(DEBUG_TAG, "The stop number is not a valid integer, expect failures")
             }
 
             // Legge i tempi di arrivo
             val palina = fetcher.ReadArrivalTimesAll(stopId, resultRef)
 
             Log.d(DEBUG_TAG, "Arrivals fetcher: $fetcher\n\tProgress: ${resultRef.get()}")
 
 
             // Gestione del FiveTAPIFetcher per ottenere le direzioni
             if (fetcher is FiveTAPIFetcher) {
                 val branchResultRef = AtomicReference<Fetcher.Result>()
                 val branches = fetcher.getDirectionsForStop(stopId, branchResultRef)
                 Log.d(DEBUG_TAG, "FiveTArrivals fetcher: $fetcher\n\tDetails req: ${branchResultRef.get()}")
 
                 if (branchResultRef.get() == Fetcher.Result.OK) {
                     palina.addInfoFromRoutes(branches)
 
                     // Inserisce i dati nel database
                     viewModelScope.launch(Dispatchers.IO) {
                         //modify the DB in another coroutine in the background
                         NextGenDB.insertBranchesIntoDB(appContext,branches)
                     }
 
                 } else {
                     resultRef.set(Fetcher.Result.NOT_FOUND)
                 }
             }
 
             // Unisce percorsi duplicati
             palina.mergeDuplicateRoutes(0)
 
             if (resultRef.get() == Fetcher.Result.OK && palina.getTotalNumberOfPassages() == 0) {
                 resultRef.set(Fetcher.Result.EMPTY_RESULT_SET)
                 Log.d(DEBUG_TAG, "Setting empty results")
             }
             //reportProgress
             resultLiveData.postValue(resultRef.get())
 
             // Se è un MatoAPIFetcher con risultati validi, salviamo i dati
             if (resultPalina == null && fetcher is MatoAPIFetcher && palina.queryAllRoutes().size > 0) {
                 resultPalina = palina
             }
 
             // Se abbiamo un risultato OK, restituiamo la palina
             if (resultRef.get() == Fetcher.Result.OK) {
                 setResultAndPalinaFromFetchers(palina, Fetcher.Result.OK)
 
                 return
             }
             //end Fetchers loop
         }
 
         // Se arriviamo qui, tutti i fetcher hanno fallito
         //failedAll = true
 
         // Se abbiamo comunque una palina, la restituiamo
         resultPalina?.let {
             setResultAndPalinaFromFetchers(it, resultRef.get())
         }
         //in ogni caso, settiamo la richiesta come conclusa
         arrivalsRequestRunningLiveData.postValue(false)
         Log.d(DEBUG_TAG, "Finished fetchers available to search arrivals for palina stop $stopId")
     }
 
     private fun setResultAndPalinaFromFetchers(palina: Palina, fetcherResult: Fetcher.Result) {
         arrivalsRequestRunningLiveData.postValue(false)
         resultLiveData.postValue(fetcherResult)
         Log.d(DEBUG_TAG, "Have new result palina for stop ${palina.ID}, source ${palina.passaggiSourceIfAny} has coords: ${palina.hasCoords()}")
         Log.d(DEBUG_TAG, "Old palina liveData is: ${palinaLiveData.value?.stopDisplayName}, has Coords ${palinaLiveData.value?.hasCoords()}")
         palinaLiveData.postValue(Palina.mergePaline(palina, palinaLiveData.value))
     }
     companion object{
         const val DEBUG_TAG="BusTO-ArrivalsViMo"
 
         @JvmStatic
         fun getFetcherFromStrSource(src:String): ArrivalsFetcher?{
             val srcEnum = Passaggio.Source.valueOf(src)
 
             val fe: ArrivalsFetcher? = when(srcEnum){
                 Passaggio.Source.FiveTAPI -> FiveTAPIFetcher()
                 Passaggio.Source.GTTJSON ->  GTTJSONFetcher()
                 Passaggio.Source.FiveTScraper -> FiveTScraperFetcher()
                 Passaggio.Source.MatoAPI -> MatoAPIFetcher()
                 Passaggio.Source.UNDETERMINED -> null
                 null -> null
             }
             return fe
         }
 
         @JvmStatic
         fun constructFetchersFromStrList(sources: Array<String>): List<ArrivalsFetcher>{
             val fetchers = mutableListOf<ArrivalsFetcher>()
             for(s in sources){
                 val fe = getFetcherFromStrSource(s)
                 if(fe!=null){
                     fetchers.add(fe)
                 } else{
                     Log.d(DEBUG_TAG, "Cannot convert fetcher source $s to a fetcher")
                 }
             }
 
             return fetchers
         }
     }
 
 }
\ No newline at end of file
diff --git a/app/src/main/java/it/reyboz/bustorino/viewmodels/MapStateViewModel.kt b/app/src/main/java/it/reyboz/bustorino/viewmodels/MapStateViewModel.kt
index d8bf03d..3ca621b 100644
--- a/app/src/main/java/it/reyboz/bustorino/viewmodels/MapStateViewModel.kt
+++ b/app/src/main/java/it/reyboz/bustorino/viewmodels/MapStateViewModel.kt
@@ -1,48 +1,54 @@
 package it.reyboz.bustorino.viewmodels
 
+import android.location.Location
 import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.ViewModel
 import it.reyboz.bustorino.map.MapCameraState
 import org.maplibre.android.camera.CameraPosition
 import org.maplibre.android.geometry.LatLng
 import org.maplibre.android.geometry.LatLngBounds
 import org.maplibre.android.maps.MapLibreMap
 
 class MapStateViewModel : ViewModel() {
 
     var savedCameraState: MapCameraState? = null
         private set
 
     val lastOpenStopID = MutableLiveData<String>()
 
     fun saveMapState(map: MapLibreMap){
         val cp = map.cameraPosition
         val newBbox = map.projection.visibleRegion.latLngBounds
 
         val cameraState = MapCameraState(
             latitude = newBbox.center.latitude,
             longitude = newBbox.center.longitude,
             zoom = cp.zoom,
             bearing = cp.bearing,
             tilt = cp.tilt
         )
 
         savedCameraState = cameraState
     }
     fun restoreMapState(map: MapLibreMap): Boolean {
         return restoreMapState(map, this.savedCameraState)
     }
 
+    var locationToShow: Location? = null
+
+    val locationActive = MutableLiveData(false)
+    val followingUserPosition = MutableLiveData(false)
+
     companion object{
         fun restoreMapState(map: MapLibreMap, savedCameraState: MapCameraState?): Boolean {
             val state = savedCameraState ?: return false
             map.cameraPosition = CameraPosition.Builder()
                 .target(LatLng(state.latitude, state.longitude))
                 .zoom(state.zoom)
                 .bearing(state.bearing)
                 .tilt(state.tilt)
                 .build()
             return true
         }
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/it/reyboz/bustorino/viewmodels/NearbyStopsViewModel.kt b/app/src/main/java/it/reyboz/bustorino/viewmodels/NearbyStopsViewModel.kt
index eb35c2e..fc182cb 100644
--- a/app/src/main/java/it/reyboz/bustorino/viewmodels/NearbyStopsViewModel.kt
+++ b/app/src/main/java/it/reyboz/bustorino/viewmodels/NearbyStopsViewModel.kt
@@ -1,139 +1,156 @@
+/*
+	BusTO - View Model 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.viewmodels
 
 import android.app.Application
 import android.location.Location
 import android.util.Log
 import androidx.lifecycle.AndroidViewModel
 import androidx.lifecycle.MediatorLiveData
 import androidx.lifecycle.MutableLiveData
 import it.reyboz.bustorino.BuildConfig
 import it.reyboz.bustorino.backend.GPSPoint
 import it.reyboz.bustorino.backend.Stop
 import it.reyboz.bustorino.data.OldDataRepository
 import java.util.ArrayList
 import java.util.concurrent.Executors
 
 class NearbyStopsViewModel(application: Application): AndroidViewModel(application) {
 
     private val executor = Executors.newFixedThreadPool(2)
     private val oldRepo = OldDataRepository(executor, application)
 
 
     val locationLiveData = MutableLiveData<GPSPoint>()
     val distanceMtLiveData = MutableLiveData<Int>(40)
 
 
     val stopsAtDistance = MediatorLiveData<ArrayList<Stop>>()
 
     private val dbUpdateRunning = MutableLiveData(false)
 
     private val callback =
         OldDataRepository.Callback<ArrayList<Stop>> { res ->
             if(res.isSuccess){
                 stopsAtDistance.postValue(res.result)
                 if(BuildConfig.DEBUG)
                     Log.d(DEBUG_TAG, "Setting value of stops in bounding box")
             }
         }
 
     fun setLastLocation(location: Location) {
         locationLiveData.value = GPSPoint(location.latitude, location.longitude)
     }
     fun setDistance(distance: Int) {
         distanceMtLiveData.value = distance
     }
     fun setDBUpdateRunning(running: Boolean) {
         dbUpdateRunning.value = (running)
     }
 
 
     /**
      * Request stop in location [latitude], [longitude], at distance [distanceMeters]
      * If [saveValues] is true, store the position and the distance used
      */
     fun requestStopsAtDistance(latitude: Double, longitude: Double, distanceMeters: Int, saveValues: Boolean){
         if(saveValues){
             locationLiveData.postValue(GPSPoint(latitude, longitude))
             distanceMtLiveData.postValue(distanceMeters)
         }
         oldRepo.requestStopsWithinDistance(latitude, longitude, distanceMeters, callback)
     }
 
     /**
      * Request stops using the previously saved location
      */
     fun requestStopsAtDistance(distanceMeters: Int, saveValue: Boolean){
         if(saveValue){
             distanceMtLiveData.postValue(distanceMeters)
         }
         oldRepo.requestStopsWithinDistance(
             locationLiveData.value!!.latitude,
             locationLiveData.value!!.longitude, distanceMeters, callback)
     }
 
     fun requestStopsCheckDBRunning(position: GPSPoint, distanceMt: Int){
         if(dbUpdateRunning.value==null || !(dbUpdateRunning.value!!)){
             oldRepo.requestStopsWithinDistance(position.latitude, position.longitude, distanceMt, callback)
         } else{
             Log.d(DEBUG_TAG, "Database update is running, cannot do it")
         }
     }
 
 
     fun postLocation(location: Location){
         locationLiveData.postValue(GPSPoint(location.latitude, location.longitude))
     }
     fun postLocation(location: GPSPoint){
         locationLiveData.postValue(location)
     }
     fun postLastDistance(distanceMeters: Int){
         distanceMtLiveData.postValue(distanceMeters)
     }
 
     init {
         stopsAtDistance.addSource(locationLiveData){ point->
             if(BuildConfig.DEBUG) Log.d(DEBUG_TAG, "New location: $point")
             val distance = distanceMtLiveData.value ?: 40
             //oldRepo.requestStopsWithinDistance(point.latitude, point.longitude, distance, callback)
             requestStopsCheckDBRunning(point, distance)
         }
 
         stopsAtDistance.addSource(distanceMtLiveData){ dist->
             if(BuildConfig.DEBUG) Log.d(DEBUG_TAG, "New distance: $dist")
 
             if(locationLiveData.value != null){
                 val point: GPSPoint = locationLiveData.value!!
                 //oldRepo.requestStopsWithinDistance(point.latitude, point.longitude, dist, callback)
                 requestStopsCheckDBRunning(point, dist)
             } else{
                 Log.d(DEBUG_TAG, "Modified distance but locationLiveData value is null")
             }
         }
         stopsAtDistance.addSource(dbUpdateRunning){ running ->
             if(BuildConfig.DEBUG) Log.d(DEBUG_TAG, "DB update running: $running")
             if(!running) {
                 reRequestStops()
             }
         }
     }
 
 
     private fun reRequestStops(){
         var req = false
         locationLiveData.value?.let{ point ->
             distanceMtLiveData.value ?.let { dist->
                 req = true
                 oldRepo.requestStopsWithinDistance(point.latitude, point.longitude, dist, callback)
             }
 
         }
         if(!req){
             Log.w(DEBUG_TAG, "Requested to rerun stops, but position or distance (or both) are null")
         }
     }
 
 
     companion object{
         private const val DEBUG_TAG = "BusTO-NearbyStopVwModel"
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/it/reyboz/bustorino/viewmodels/ServiceAlertsViewModel.kt b/app/src/main/java/it/reyboz/bustorino/viewmodels/ServiceAlertsViewModel.kt
index 4812de7..31fdad3 100644
--- a/app/src/main/java/it/reyboz/bustorino/viewmodels/ServiceAlertsViewModel.kt
+++ b/app/src/main/java/it/reyboz/bustorino/viewmodels/ServiceAlertsViewModel.kt
@@ -1,179 +1,196 @@
+/*
+	BusTO - View Model components
+    Copyright (C) 2026 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.viewmodels
 
 import android.app.Application
 import android.util.Log
 import androidx.lifecycle.AndroidViewModel
 import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.map
 import androidx.lifecycle.switchMap
 import androidx.lifecycle.viewModelScope
 import androidx.room.concurrent.AtomicBoolean
 import androidx.work.ExistingWorkPolicy
 import androidx.work.WorkManager
 import com.google.transit.realtime.GtfsRealtime.Alert
 import it.reyboz.bustorino.backend.NetworkVolleyManager
 import it.reyboz.bustorino.data.GtfsAlertDBDownloadWorker
 import it.reyboz.bustorino.data.GtfsRepository
 import it.reyboz.bustorino.data.gtfs.GtfsDatabase
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlin.time.Duration.Companion.seconds
 
 class ServiceAlertsViewModel(app: Application) : AndroidViewModel(app) {
 
     private val gtfsRepo = GtfsRepository(app)
     private val volleyManager = NetworkVolleyManager.getInstance(app)
 
     private val alertsDao = GtfsDatabase.getGtfsDatabase(app).alertsDao()
 
     private val workManager = WorkManager.getInstance(app)
 
     //val alertsLiveData = MutableLiveData<ArrayList<Alert>>(ArrayList())
 
     private val stopToFilter = MutableLiveData("")
     private val routeToFilter = MutableLiveData("")
 
     val lastTimeRunningDownload = MutableLiveData(0L)
     private val keepRunning = AtomicBoolean(false)
     private val waitingToRerun = AtomicBoolean(false)
     fun setRunningDownloadRequests(value: Boolean) {
         Log.d(DEBUG_TAG, "setRunningDownloadRequests: $value")
         keepRunning.set(value)
     }
 
     val alertsByRouteLiveData = routeToFilter.switchMap {
         val unixTimestamp = (System.currentTimeMillis()/1000)
         gtfsRepo.getAlertsByRouteID(it).map{ l -> l.filter { al->al.isActive(unixTimestamp) }}
     }
 
     val alertsByStopLiveData = stopToFilter.switchMap {
         gtfsRepo.alertsDao.getAlertsForStop(it)
     }
 
     val allAlertsLiveData = gtfsRepo.alertsDao.getAllAlertsLiveData()
     /*
     private val volleyErrorListener = Response.ErrorListener { err ->
         Log.e(DEBUG_TAG, "Error getting alerts: ${err.message}", err)
     }
     private var numTries = 0
     private val responseListener = Response.Listener<ArrayList<GtfsRealtime.FeedEntity>> {
         Log.d(DEBUG_TAG, "Received ${it.size} alerts")
         if (it.isEmpty()) {
             if(numTries<4){
                 numTries++;
                 requestAlerts()
                 Log.d(DEBUG_TAG, "Alerts requested again: $numTries")
             }
         }
 
         alertsLiveData.postValue(it.map { it.alert })
     }
 
     private fun requestAlerts(){
         val req = GtfsRtAlertsRequest(volleyErrorListener, responseListener)
 
         volleyManager.requestQueue.add(req)
     }
 
      */
     fun setStopFilter(stopId: String) {
         stopToFilter.value = stopId
     }
     fun setGtfsLineFilter(routeId: String) {
         routeToFilter.value = routeId
     }
 
     private fun downloadWorkIfTimePassed(){
         val currentTime = System.currentTimeMillis()
         waitingToRerun.set(false)
         val diff = currentTime - lastTimeRunningDownload.value!!
         Log.d(DEBUG_TAG, "diff : ${diff/1000} s")
         val MINUTES_CHECK = 3
         if (lastTimeRunningDownload.value == 0L ||
             currentTime > lastTimeRunningDownload.value!! + MINUTES_CHECK*60*1000){
             //actually enqueue request
             Log.d(DEBUG_TAG, "Launching request to download alerts")
             val req = GtfsAlertDBDownloadWorker.makeOneTimeRequest("alertsrn")
             workManager.enqueueUniqueWork("AlertsDownloadsRun", ExistingWorkPolicy.KEEP, req)
             lastTimeRunningDownload.postValue(System.currentTimeMillis())
         }
         viewModelScope.launch(Dispatchers.IO) {
             waitingToRerun.set(true)
             delay((61).seconds)
             if(keepRunning.get()) downloadWorkIfTimePassed()
         }
 
     }
 
     fun launchAlertsPeriodCheck(){
         setRunningDownloadRequests(true)
         if(!waitingToRerun.get())
             downloadWorkIfTimePassed()
     }
 
 
 
     private fun filterAlertsForStop(stopId: String, alerts: ArrayList<Alert>) : ArrayList<Alert>{
 
         val filteredAlerts = ArrayList<Alert>()
         for (al in alerts) {
             for (ie in al.informedEntityList) {
                 if (ie.stopId == stopId) {
                     filteredAlerts.add(al)
                 }
             }
         }
         return filteredAlerts
     }
 
     init{
 
         /*
         requestAlerts()
 
         alertsByRouteLiveData.addSource(alertsLiveData){ alerts ->
             if(alerts.isEmpty()){
                 return@addSource
             }
             val routeMap = HashMap<String, ArrayList<Alert>>()
             for (al in alerts){
                 for( ie in al.informedEntityList){
                     var routeID  = ""
                     if(ie.routeId.isNotEmpty()){
                         routeID = "gtt:${ie.routeId}"
                     } else if(ie.trip?.routeId?.isNotEmpty() == true){
                         routeID = "gtt:${ie.trip?.routeId}"
                     }
                     if (routeID.isNotEmpty()) {
                         if (!routeMap.containsKey(routeID)) {
                             routeMap[routeID] = ArrayList()
                         }
 
                         routeMap[routeID]!!.add(al)
                     }
                 }
             }
 
             alertsByRouteLiveData.postValue(routeMap)
         }
         // Set transformations for stop
         alertsForStop.addSource(stopToFilter){ stopId ->
             alertsLiveData.value?.let{
                 alertsForStop.postValue(filterAlertsForStop(stopId,it))
             }
         }
 
         alertsForStop.addSource(alertsLiveData){ alerts ->
             alertsForStop.postValue(filterAlertsForStop(stopToFilter.value!!,alerts))
         }
 
 
          */
     }
 
     companion object{
         private const val DEBUG_TAG = "BusTO-GTFSRTAlerts"
 
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/it/reyboz/bustorino/viewmodels/StopsMapViewModel.kt b/app/src/main/java/it/reyboz/bustorino/viewmodels/StopsMapViewModel.kt
index bebe751..70bf47d 100644
--- a/app/src/main/java/it/reyboz/bustorino/viewmodels/StopsMapViewModel.kt
+++ b/app/src/main/java/it/reyboz/bustorino/viewmodels/StopsMapViewModel.kt
@@ -1,89 +1,108 @@
+/*
+	BusTO - View Model components
+    Copyright (C) 2025 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.viewmodels
 
 import android.app.Application
 import android.location.Location
 import android.os.Bundle
 import android.util.Log
 import androidx.lifecycle.AndroidViewModel
 import androidx.lifecycle.MutableLiveData
 import it.reyboz.bustorino.backend.Stop
 import it.reyboz.bustorino.data.NextGenDB
 import it.reyboz.bustorino.data.OldDataRepository
 import org.maplibre.android.geometry.LatLngBounds
 import java.util.concurrent.Executors
 import kotlin.collections.ArrayList
 
 class StopsMapViewModel(application: Application): AndroidViewModel(application) {
 
 
     private val executor = Executors.newFixedThreadPool(2)
     private val oldRepo = OldDataRepository(executor, NextGenDB.getInstance(application))
 
     val stopsToShow = MutableLiveData(ArrayList<Stop>())
     private var stopsShownIDs = HashSet<String>()
     private var allStopsLoaded = HashMap<String,Stop>()
 
 
     val stopsInBoundingBox = MutableLiveData<ArrayList<Stop>>()
 
     private val callback =
         OldDataRepository.Callback<ArrayList<Stop>> { res ->
                 if(res.isSuccess){
                     stopsInBoundingBox.postValue(res.result)
                     Log.d(DEBUG_TAG, "Setting value of stops in bounding box")
                 }
         }
 
     private val addStopsCallback =
         OldDataRepository.Callback<ArrayList<Stop>> { res ->
             if(res.isSuccess) res.result?.let{ newStops ->
                 val stopsAdd = stopsToShow.value ?: ArrayList()
                 for (s in newStops){
                     if (s.ID !in stopsShownIDs){
                         stopsShownIDs.add(s.ID)
                         stopsAdd.add(s)
                         allStopsLoaded[s.ID] = s
                     }
                 }
 
                 stopsToShow.postValue(stopsAdd)
                 //Log.d(DEBUG_TAG, "Loaded ${stopsAdd.size} stops in total")
             }
         }
 
     fun getStopByID(id: String): Stop? {
         if (id in allStopsLoaded) return allStopsLoaded[id]
         else return null
     }
 
     fun getAllStopsLoaded(): ArrayList<Stop>{
         return ArrayList(allStopsLoaded.values)
     }
 
     /*fun requestStopsInBoundingBox(bb: BoundingBox) {
         bb.let {
             Log.d(DEBUG_TAG, "Launching stop request")
             oldRepo.requestStopsInArea(it.latSouth, it.latNorth, it.lonWest, it.lonEast, callback)
         }
     }
 
      */
     fun requestStopsInLatLng(bb: LatLngBounds) {
         bb.let {
             Log.d(DEBUG_TAG, "Launching stop request")
             oldRepo.requestStopsInArea(it.latitudeSouth, it.latitudeNorth, it.longitudeWest, it.longitudeEast, callback)
         }
     }
     fun loadStopsInLatLngBounds(bb: LatLngBounds?){
         bb?.let {
             Log.d(DEBUG_TAG, "Launching stop request")
             oldRepo.requestStopsInArea(it.latitudeSouth, it.latitudeNorth, it.longitudeWest, it.longitudeEast,
                 addStopsCallback)
         }
     }
+
+    //this is only saved at the end, is it really necessary?
     var lastUserLocation: Location? = null
 
     companion object{
         private const val DEBUG_TAG = "BusTOStopMapViewModel"
     }
 }
\ 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 6b0972d..a326e4b 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -1,388 +1,394 @@
 <?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 has 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_fill">Arrivals at: %1$s</string>
     <string name="passages">Arrivals at:</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="no_lines_found">No lines found in this category</string>
     <string name="no_lines_found_query">No lines match the searched name</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="line_fill_towards">Line %1$s towards:</string>
     <string name="stop_fill">Stop %1$s</string>
     <string name="vehicle_fill">Vehicle %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">Open the wiki</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 information or want 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="action_open_line">Show line details</string>
     <string name="action_show_direction">Show full direction</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="no_gps_on_device">No GPS receiver found 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="searching_arrivals_fmt">Loading arrivals from %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</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="search_box_lines_suggestion_filter">Filter by name</string>
     <string name="requesting_db_update">Launching database update</string>
     <string name="downloading_data_mato">Downloading data from MaTO server</string>
     <string name="downloading_alerts_message">Downloading realtime alerts data</string>
 
     <!-- preferences -->
     <string name="pref_directions_capitalize">Capitalize directions</string>
     <string-array name="directions_capitalize">
         <item>@string/directions_capitalize_no_change</item>
         <item>@string/directions_capitalize_everything</item>
         <item>@string/directions_capitalize_first_letter</item>
     </string-array>
     <string name="directions_capitalize_no_change">Do not change arrivals directions</string>
     <string name="directions_capitalize_everything">Capitalize everything</string>
     <string name="directions_capitalize_first_letter">Capitalize only first letter</string>
     <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>
     <string name="positions_source_mato_descr">MaTO (updated more frequently, might have errors)</string>
     <string name="positions_source_gtfsrt_descr">GTFS RT (less frequently updated, more accurate)</string>
     <array name="positions_source_sel">
         <item>@string/positions_source_mato_descr</item>
         <item>@string/positions_source_gtfsrt_descr</item>
     </array>
     <string name="too_far_not_showing_location">"You are too far, not showing your position</string>
     <string name="map_style_pref_title">Style of the map</string>
     <string name="map_style_versatiles">Versatiles (vector)</string>
     <string name="map_style_legacy_raster">OSM legacy (raster, lighter)</string>
     <array name="map_style_pref_categories">
         <item>@string/map_style_versatiles</item>
         <item>@string/map_style_legacy_raster</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="no_permission_dialog_title">Missing permission</string>
+    <!-- If more permissions are needed, adapt this string to make if "fillable" -->
+    <string name="no_permission_dialog_text_location">To use this functionality, the application needs access to the location, which can not only be granted in the system settings.</string>
+    <string name="no_permission_dialog_open">Open settings</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>
     <string name="destination_loading">Loading destination…</string>
     <string name="destination_unknown">Destination unknown</string>
     <!-- LIVE POSITIONS DIALOG -->
     <string name="live_positions_msg_ok">Service for positions working normally</string>
     <string name="live_positions_msg_no_positions">No positions received</string>
     <string name="live_positions_msg_connection_error">Error connecting to the server</string>
     <string name="live_positions_msg_parsing_error">Error parsing the server response</string>
     <string name="live_positions_msg_network_error">Error: network response is not as expected</string>
     <string name="live_positions_msg_connecting">Connecting...</string>
     <string name="positions_source_mato_short" translatable="false">MaTO</string>
     <string name="positions_source_gtfsrt_short" translatable="false">GTFS RT</string>
     <string name="live_positions_dialog_provider_text">Live positions source:</string>
     <string name="live_positions_switch_provider">Switch source</string>
     <string name="live_positions_preference_switch_clear_title">Clear bus positions when switching live positions
         source
     </string>
 
     <string name="updated_fill">Updated: %1$s</string>
     <string name="alert_line_fill">Alerts for line %1$s:</string>
     <string name="no_alerts_in_your_language_fill">No alerts in your language, showing in %1$s</string>
     <string name="italian">Italian</string>
     <string name="english">English</string>
     <string name="checking_alerts_update">Checking new alerts now</string>
 </resources>