diff --git a/app/src/main/java/org/obd/graphs/PowerBroadcastReceiver.kt b/app/src/main/java/org/obd/graphs/PowerBroadcastReceiver.kt
index f94733b1..5e212a64 100644
--- a/app/src/main/java/org/obd/graphs/PowerBroadcastReceiver.kt
+++ b/app/src/main/java/org/obd/graphs/PowerBroadcastReceiver.kt
@@ -25,7 +25,7 @@ import android.util.Log
 import org.obd.graphs.activity.LOG_TAG
 import org.obd.graphs.activity.MainActivity
 import org.obd.graphs.bl.datalogger.DATA_LOGGER_SCHEDULED_START_EVENT
-import org.obd.graphs.bl.datalogger.dataLogger
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_SCHEDULED_STOP_EVENT
 
 const val SCREEN_OFF_EVENT = "power.screen.off"
 const val SCREEN_ON_EVENT = "power.screen.on"
@@ -65,12 +65,7 @@ internal class PowerBroadcastReceiver : BroadcastReceiver() {
             }
 
             if (powerPreferences.connectOnPower) {
-                Log.d(
-                    LOG_TAG,
-                    "Stop data logging",
-                )
-                dataLogger.stop()
-                dataLogger.scheduledStop()
+                sendBroadcastEvent(DATA_LOGGER_SCHEDULED_STOP_EVENT)
             }
 
             if (powerPreferences.screenOnOff) {
diff --git a/app/src/main/java/org/obd/graphs/activity/MainActivity.kt b/app/src/main/java/org/obd/graphs/activity/MainActivity.kt
index 9b485f68..308763cc 100644
--- a/app/src/main/java/org/obd/graphs/activity/MainActivity.kt
+++ b/app/src/main/java/org/obd/graphs/activity/MainActivity.kt
@@ -38,7 +38,7 @@ import org.obd.graphs.MAIN_ACTIVITY_EVENT_DESTROYED
 import org.obd.graphs.MAIN_ACTIVITY_EVENT_PAUSE
 import org.obd.graphs.Permissions
 import org.obd.graphs.R
-import org.obd.graphs.bl.datalogger.dataLogger
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.bl.drag.dragRacingMetricsProcessor
 import org.obd.graphs.bl.extra.vehicleStatusMetricsProcessor
 import org.obd.graphs.bl.generator.MetricsGenerator
@@ -46,6 +46,7 @@ import org.obd.graphs.bl.gps.gpsMetricsEmitter
 import org.obd.graphs.bl.trip.tripManager
 import org.obd.graphs.cacheManager
 import org.obd.graphs.network
+import org.obd.graphs.preferences.initPrefs
 import org.obd.graphs.profile.profile
 import org.obd.graphs.sendBroadcastEvent
 import org.obd.graphs.setActivityContext
@@ -58,7 +59,6 @@ const val LOG_TAG = "MainActivity"
 class MainActivity :
     AppCompatActivity(),
     EasyPermissions.PermissionCallbacks {
-
     lateinit var lockScreenDialog: AlertDialog
     internal lateinit var backupManager: BackupManager
 
@@ -125,13 +125,14 @@ class MainActivity :
 
     override fun onSupportNavigateUp(): Boolean {
         val navController = (supportFragmentManager.findFragmentById(R.id.nav_host_fragment) as NavHostFragment).navController
-        return NavigationUI.navigateUp(navController,appBarConfiguration) || super.onSupportNavigateUp()
+        return NavigationUI.navigateUp(navController, appBarConfiguration) || super.onSupportNavigateUp()
     }
 
     override fun onCreate(savedInstanceState: Bundle?) {
         setupStrictMode()
         super.onCreate(savedInstanceState)
         setActivityContext(this)
+        initPrefs(this)
         initCache()
         setContentView(R.layout.activity_main)
 
@@ -164,7 +165,6 @@ class MainActivity :
         validatePermissions()
     }
 
-
     override fun onResume() {
         super.onResume()
         screen.setupWindowManager(this)
@@ -188,15 +188,15 @@ class MainActivity :
         Thread.setDefaultUncaughtExceptionHandler(ExceptionHandler())
     }
 
-
-    fun getAppBarConfiguration(): AppBarConfiguration = AppBarConfiguration(
-        setOf(
-            R.id.nav_giulia,
-            R.id.nav_graph,
-            R.id.nav_gauge,
-        ),
-        findViewById<DrawerLayout>(R.id.drawer_layout)
-    )
+    fun getAppBarConfiguration(): AppBarConfiguration =
+        AppBarConfiguration(
+            setOf(
+                R.id.nav_giulia,
+                R.id.nav_graph,
+                R.id.nav_gauge,
+            ),
+            findViewById<DrawerLayout>(R.id.drawer_layout),
+        )
 
     private fun initCache() {
         cacheManager.initCache(cache)
@@ -244,14 +244,14 @@ class MainActivity :
     }
 
     private fun setupMetricsProcessors() {
-        dataLogger
+        DataLoggerRepository
             .observe(dragRacingMetricsProcessor)
             .observe(tripManager)
             .observe(vehicleStatusMetricsProcessor)
             .observe(gpsMetricsEmitter)
 
         if (BuildConfig.DEBUG) {
-            dataLogger.observe(MetricsGenerator(BuildConfig.DEBUG))
+            DataLoggerRepository.observe(MetricsGenerator(BuildConfig.DEBUG))
         }
     }
 
diff --git a/app/src/main/java/org/obd/graphs/activity/Navigation.kt b/app/src/main/java/org/obd/graphs/activity/Navigation.kt
index c1023455..51ff0aa4 100644
--- a/app/src/main/java/org/obd/graphs/activity/Navigation.kt
+++ b/app/src/main/java/org/obd/graphs/activity/Navigation.kt
@@ -23,7 +23,7 @@ import androidx.core.os.bundleOf
 import androidx.core.view.GravityCompat
 import androidx.navigation.ui.NavigationUI
 import org.obd.graphs.R
-import org.obd.graphs.bl.datalogger.dataLogger
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.getContext
 import org.obd.graphs.preferences.PREFERENCE_SCREEN_KEY
 import org.obd.graphs.preferences.Prefs
@@ -99,7 +99,7 @@ internal fun MainActivity.setupNavigationBar() {
         navController.addOnDestinationChangedListener { _, destination, _ ->
 
             bottomAppBar {
-                it.menu.findItem(R.id.ctx_menu_dtc).isVisible = dataLogger.isDTCEnabled()
+                it.menu.findItem(R.id.ctx_menu_dtc).isVisible = DataLoggerRepository.isDTCEnabled() ?: false
                 it.menu.findItem(R.id.ctx_menu_android_auto)?.let {
                     if (NavigationRouter.isAndroidAutoEnabled(this)) {
                         val spanString = SpannableString(it.title.toString())
diff --git a/app/src/main/java/org/obd/graphs/activity/Receivers.kt b/app/src/main/java/org/obd/graphs/activity/Receivers.kt
index 10d87e81..ce1623dc 100644
--- a/app/src/main/java/org/obd/graphs/activity/Receivers.kt
+++ b/app/src/main/java/org/obd/graphs/activity/Receivers.kt
@@ -60,10 +60,11 @@ import org.obd.graphs.bl.datalogger.DATA_LOGGER_DTC_AVAILABLE
 import org.obd.graphs.bl.datalogger.DATA_LOGGER_ERROR_CONNECT_EVENT
 import org.obd.graphs.bl.datalogger.DATA_LOGGER_ERROR_EVENT
 import org.obd.graphs.bl.datalogger.DATA_LOGGER_NO_NETWORK_EVENT
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_SCHEDULED_STOP_EVENT
 import org.obd.graphs.bl.datalogger.DATA_LOGGER_STOPPED_EVENT
 import org.obd.graphs.bl.datalogger.DATA_LOGGER_WIFI_INCORRECT
 import org.obd.graphs.bl.datalogger.DATA_LOGGER_WIFI_NOT_CONNECTED
-import org.obd.graphs.bl.datalogger.dataLogger
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.bl.datalogger.dataLoggerSettings
 import org.obd.graphs.bl.extra.EVENT_VEHICLE_STATUS_IGNITION_OFF
 import org.obd.graphs.bl.extra.EVENT_VEHICLE_STATUS_IGNITION_ON
@@ -81,6 +82,7 @@ import org.obd.graphs.registerReceiver
 import org.obd.graphs.ui.common.COLOR_CARDINAL
 import org.obd.graphs.ui.common.COLOR_PHILIPPINE_GREEN
 import org.obd.graphs.ui.common.toast
+import org.obd.graphs.ui.withDataLogger
 
 internal val powerReceiver = PowerBroadcastReceiver()
 const val NOTIFICATION_GRAPH_VIEW_TOGGLE = "view.graph.toggle"
@@ -96,6 +98,16 @@ private const val EVENT_VEHICLE_STATUS_CHANGED = "event.vehicle.status.CHANGED"
 
 internal fun MainActivity.receive(intent: Intent?) {
     when (intent?.action) {
+        DATA_LOGGER_SCHEDULED_STOP_EVENT -> {
+            Log.d(
+                LOG_TAG,
+                "Stop data logging",
+            )
+            withDataLogger {
+                stop()
+                scheduledStop()
+            }
+        }
 
         NAVIGATION_BUTTONS_VISIBILITY_CHANGED -> setupNavigationBar()
         GOOGLE_SIGN_IN_NO_CREDENTIAL_FAILURE -> toast(org.obd.graphs.commons.R.string.main_activity_toast_google_signin_failed)
@@ -150,7 +162,9 @@ internal fun MainActivity.receive(intent: Intent?) {
         UsbManager.ACTION_USB_DEVICE_DETACHED -> {
             val usbDevice: UsbDevice = intent.extras?.get(UsbManager.EXTRA_DEVICE) as UsbDevice
             toast(R.string.pref_usb_device_detached, usbDevice.productName!!)
-            dataLogger.stop()
+            withDataLogger {
+                stop()
+            }
         }
 
         USB_DEVICE_ATTACHED_EVENT -> {
@@ -211,7 +225,9 @@ internal fun MainActivity.receive(intent: Intent?) {
                     ContextCompat.getColorStateList(applicationContext, org.obd.graphs.commons.R.color.cardinal)
                 it.setOnClickListener {
                     Log.i(LOG_TAG, "Stop data logging ")
-                    dataLogger.stop()
+                    withDataLogger {
+                       stop()
+                    }
                 }
                 it.refreshDrawableState()
             }
@@ -264,7 +280,9 @@ internal fun MainActivity.receive(intent: Intent?) {
             updateVehicleStatus("Key off")
             if (dataLoggerSettings.instance().vehicleStatusDisconnectWhenOff) {
                 Log.i(LOG_TAG, "Received vehicle status OFF event. Closing the session.")
-                dataLogger.stop()
+                withDataLogger {
+                    stop()
+                }
             }
         }
     }
@@ -301,7 +319,7 @@ internal fun MainActivity.toggleNavigationItem(
 internal fun MainActivity.unregisterReceiver() {
     unregisterReceiver(activityBroadcastReceiver)
     unregisterReceiver(powerReceiver)
-    unregisterReceiver(dataLogger.eventsReceiver)
+    unregisterReceiver(DataLoggerRepository.eventsReceiver)
 }
 
 internal fun MainActivity.registerReceiver() {
@@ -359,6 +377,7 @@ internal fun MainActivity.registerReceiver() {
         it.addAction(REQUEST_NOTIFICATION_PERMISSIONS)
         it.addAction(LOCATION_IS_DISABLED)
         it.addAction(NAVIGATION_BUTTONS_VISIBILITY_CHANGED)
+        it.addAction(DATA_LOGGER_SCHEDULED_STOP_EVENT)
     }
 
     registerReceiver(this, powerReceiver) {
@@ -366,7 +385,7 @@ internal fun MainActivity.registerReceiver() {
         it.addAction("android.intent.action.ACTION_POWER_DISCONNECTED")
     }
 
-    registerReceiver(this, dataLogger.eventsReceiver) {
+    registerReceiver(this, DataLoggerRepository.eventsReceiver) {
         it.addAction(MODULES_LIST_CHANGED_EVENT)
         it.addAction(PROFILE_CHANGED_EVENT)
     }
diff --git a/app/src/main/java/org/obd/graphs/preferences/PreferencesFragment.kt b/app/src/main/java/org/obd/graphs/preferences/PreferencesFragment.kt
index b432d54f..7e09390a 100644
--- a/app/src/main/java/org/obd/graphs/preferences/PreferencesFragment.kt
+++ b/app/src/main/java/org/obd/graphs/preferences/PreferencesFragment.kt
@@ -27,7 +27,7 @@ import android.view.ViewGroup
 import androidx.preference.*
 import org.obd.graphs.R
 import org.obd.graphs.activity.*
-import org.obd.graphs.bl.datalogger.dataLogger
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.bl.trip.tripVirtualScreenManager
 import org.obd.graphs.preferences.dtc.DiagnosticTroubleCodeListPreferences
 import org.obd.graphs.preferences.dtc.DiagnosticTroubleCodePreferenceDialogFragment
@@ -191,7 +191,7 @@ class PreferencesFragment : PreferenceFragmentCompat() {
 
     private fun hidePreferences() {
         findPreference<PreferenceCategory>("pref.dtc.category")?.isVisible =
-            dataLogger.isDTCEnabled()
+            DataLoggerRepository.isDTCEnabled()
     }
 
     private fun registerListeners() {
diff --git a/app/src/main/java/org/obd/graphs/preferences/pid/PidDefinitionPreferenceDialogFragment.kt b/app/src/main/java/org/obd/graphs/preferences/pid/PidDefinitionPreferenceDialogFragment.kt
index c5459322..07dc4f4c 100644
--- a/app/src/main/java/org/obd/graphs/preferences/pid/PidDefinitionPreferenceDialogFragment.kt
+++ b/app/src/main/java/org/obd/graphs/preferences/pid/PidDefinitionPreferenceDialogFragment.kt
@@ -35,7 +35,7 @@ import androidx.recyclerview.widget.ItemTouchHelper
 import androidx.recyclerview.widget.RecyclerView
 import org.obd.graphs.R
 import org.obd.graphs.ViewPreferencesSerializer
-import org.obd.graphs.bl.datalogger.dataLogger
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.bl.datalogger.dataLoggerSettings
 import org.obd.graphs.bl.datalogger.serialize
 import org.obd.graphs.bl.datalogger.vehicleCapabilitiesManager
@@ -317,12 +317,12 @@ open class PidDefinitionPreferenceDialogFragment(
     private fun getAdapter() = (getRecyclerView(root).adapter as PidViewAdapter)
 
     private fun sourceList(): MutableList<PidDefinitionDetails> {
-        val all = dataLogger.getPidDefinitionRegistry().findAll()
+        val all = DataLoggerRepository.getPidDefinitionRegistry().findAll()
         val individualQuery = dataLoggerSettings.instance().adapter.individualQueryStrategyEnabled
 
         val sourceList: List<PidDefinitionDetails> =
             if (source == PREFERENCE_SCREEN_SOURCE_TRIP_INFO) {
-                val pidRegistry = dataLogger.getPidDefinitionRegistry()
+                val pidRegistry = DataLoggerRepository.getPidDefinitionRegistry()
                 val list =
                     Query
                         .instance(QueryStrategyType.TRIP_INFO_QUERY)
@@ -331,7 +331,7 @@ open class PidDefinitionPreferenceDialogFragment(
                         .toMutableList()
                 list.map { PidDefinitionDetails(it, checked = false, supported = true) }
             } else if (source == PREFERENCE_SCREEN_SOURCE_PERFORMANCE) {
-                val pidRegistry = dataLogger.getPidDefinitionRegistry()
+                val pidRegistry = DataLoggerRepository.getPidDefinitionRegistry()
                 val list =
                     Query
                         .instance(QueryStrategyType.PERFORMANCE_QUERY)
@@ -340,18 +340,18 @@ open class PidDefinitionPreferenceDialogFragment(
                         .toMutableList()
                 list.map { PidDefinitionDetails(it, checked = false, supported = true) }
             } else if (individualQuery) {
-                findPidDefinitionByPriority(dataLogger.getPidDefinitionRegistry().findAll()) { true }
+                findPidDefinitionByPriority(DataLoggerRepository.getPidDefinitionRegistry().findAll()) { true }
             } else {
                 when (source) {
                     "low" -> findPidDefinitionByPriority(all) { pidDefinition -> pidDefinition.priority > 0 }
                     "high" -> findPidDefinitionByPriority(all) { pidDefinition -> pidDefinition.priority == 0 }
-                    "edit" -> findPidDefinitionByPriority(dataLogger.getPidDefinitionRegistry().findAll()) { true }
+                    "edit" -> findPidDefinitionByPriority(DataLoggerRepository.getPidDefinitionRegistry().findAll()) { true }
                     "dashboard" -> map(all)
                     "graph" -> map(all)
                     "gauge" -> map(all)
                     "giulia" -> map(all)
                     "aa" -> map(all)
-                    else -> findPidDefinitionByPriority(dataLogger.getPidDefinitionRegistry().findAll()) { true }
+                    else -> findPidDefinitionByPriority(DataLoggerRepository.getPidDefinitionRegistry().findAll()) { true }
                 }
             }
 
diff --git a/app/src/main/java/org/obd/graphs/ui/Extensions.kt b/app/src/main/java/org/obd/graphs/ui/Extensions.kt
new file mode 100644
index 00000000..5d739427
--- /dev/null
+++ b/app/src/main/java/org/obd/graphs/ui/Extensions.kt
@@ -0,0 +1,65 @@
+ /**
+ * Copyright 2019-2026, Tomasz Żebrowski
+ *
+ * <p>Licensed to the Apache Software Foundation (ASF) under one or more contributor license
+ * agreements. See the NOTICE file distributed with this work for additional information regarding
+ * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License. You may obtain a
+ * copy of the License at
+ *
+ * <p>http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * <p>Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.obd.graphs.ui
+
+import android.util.Log
+import androidx.activity.ComponentActivity
+import androidx.core.content.ContextCompat
+import androidx.fragment.app.Fragment
+import com.google.android.material.floatingactionbutton.FloatingActionButton
+import org.obd.graphs.R
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
+import org.obd.graphs.bl.datalogger.DataLoggerService
+import org.obd.graphs.bl.query.Query
+
+fun Fragment.withDataLogger(action: DataLoggerService.() -> Unit) {
+    org.obd.graphs.bl.datalogger.withDataLogger(requireContext(), action)
+}
+
+fun ComponentActivity.withDataLogger(action: DataLoggerService.() -> Unit) {
+    org.obd.graphs.bl.datalogger.withDataLogger(this, action)
+}
+
+fun Fragment.configureActionButton(query: Query) {
+    activity?.let {
+        val btn = it.findViewById<FloatingActionButton>(R.id.connect_btn)
+
+        btn?.setOnClickListener {
+            if (DataLoggerRepository.isRunning()) {
+                withDataLogger {
+                    Log.i("Fragment", "Stop data logging")
+                    stop()
+                }
+            } else {
+                withDataLogger {
+                    Log.i("Fragment", "Start data logging")
+                    start(query)
+                }
+            }
+        }
+
+        btn?.backgroundTintList =
+            ContextCompat.getColorStateList(
+                it,
+                if (DataLoggerRepository.isRunning()) {
+                    org.obd.graphs.commons.R.color.cardinal
+                } else {
+                    org.obd.graphs.commons.R.color.philippine_green
+                },
+            )
+    }
+}
diff --git a/app/src/main/java/org/obd/graphs/ui/common/FloatingButton.kt b/app/src/main/java/org/obd/graphs/ui/common/FloatingButton.kt
deleted file mode 100644
index adfd79b4..00000000
--- a/app/src/main/java/org/obd/graphs/ui/common/FloatingButton.kt
+++ /dev/null
@@ -1,49 +0,0 @@
- /**
- * Copyright 2019-2026, Tomasz Żebrowski
- *
- * <p>Licensed to the Apache Software Foundation (ASF) under one or more contributor license
- * agreements. See the NOTICE file distributed with this work for additional information regarding
- * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License. You may obtain a
- * copy of the License at
- *
- * <p>http://www.apache.org/licenses/LICENSE-2.0
- *
- * <p>Unless required by applicable law or agreed to in writing, software distributed under the
- * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
- * express or implied. See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.obd.graphs.ui.common
-
-import android.app.Activity
-import android.util.Log
-import androidx.core.content.ContextCompat
-import com.google.android.material.floatingactionbutton.FloatingActionButton
-import org.obd.graphs.R
-import org.obd.graphs.bl.datalogger.dataLogger
-import org.obd.graphs.bl.query.Query
-
-private const val LOG_TAG = "FloatingButton"
-
-fun attachToFloatingButton(
-    activity: Activity?,
-    query: Query,
-) {
-    activity?.let {
-        val btn = activity.findViewById<FloatingActionButton>(R.id.connect_btn)
-        btn?.setOnClickListener {
-            if (dataLogger.isRunning()) {
-                Log.i(org.obd.graphs.activity.LOG_TAG, "DragRacingFragment: Start data logging")
-                dataLogger.stop()
-            } else {
-                Log.i(LOG_TAG, "Start data logging")
-                dataLogger.start(query)
-            }
-        }
-
-        btn?.backgroundTintList =
-            ContextCompat.getColorStateList(activity, if (dataLogger.isRunning()) org.obd.graphs.commons.R.color.cardinal
-            else org.obd.graphs.commons.R.color.philippine_green)
-    }
-}
diff --git a/app/src/main/java/org/obd/graphs/ui/dashboard/DashboardFragment.kt b/app/src/main/java/org/obd/graphs/ui/dashboard/DashboardFragment.kt
index e5d6a8b8..d4acc288 100644
--- a/app/src/main/java/org/obd/graphs/ui/dashboard/DashboardFragment.kt
+++ b/app/src/main/java/org/obd/graphs/ui/dashboard/DashboardFragment.kt
@@ -26,49 +26,58 @@ import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import androidx.recyclerview.widget.RecyclerView
-import org.obd.graphs.bl.collector.Metric
-import org.obd.graphs.bl.collector.MetricsCollector
 import org.obd.graphs.R
 import org.obd.graphs.RenderingThread
-import org.obd.graphs.bl.datalogger.*
+import org.obd.graphs.bl.collector.Metric
+import org.obd.graphs.bl.collector.MetricsCollector
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_CONNECTED_EVENT
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_STOPPED_EVENT
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.preferences.Prefs
 import org.obd.graphs.preferences.getLongSet
 import org.obd.graphs.preferences.getS
 import org.obd.graphs.registerReceiver
-import org.obd.graphs.ui.common.attachToFloatingButton
-import org.obd.graphs.ui.recycler.RefreshableFragment
+import org.obd.graphs.ui.configureActionButton
 import org.obd.graphs.ui.gauge.AdapterContext
+import org.obd.graphs.ui.recycler.RefreshableFragment
+import org.obd.graphs.ui.withDataLogger
 
 private const val CONFIGURATION_CHANGE_EVENT_DASH = "recycler.view.change.configuration.event.dash_id"
+
 class DashboardFragment : RefreshableFragment() {
     private val metricsCollector = MetricsCollector.instance()
 
-    private val renderingThread: RenderingThread = RenderingThread(
-        renderAction = {
-            refreshRecyclerView(metricsCollector, R.id.dashboard_recycler_view)
-        },
-        perfFrameRate = {
-            Prefs.getS("pref.dashboard.fps", "10").toInt()
-        }
-    )
+    private val renderingThread: RenderingThread =
+        RenderingThread(
+            renderAction = {
+                refreshRecyclerView(metricsCollector, R.id.dashboard_recycler_view)
+            },
+            perfFrameRate = {
+                Prefs.getS("pref.dashboard.fps", "10").toInt()
+            },
+        )
 
     private val dashboardPreferences: DashboardPreferences by lazy { getDashboardPreferences() }
-    private var broadcastReceiver = object : BroadcastReceiver() {
-        override fun onReceive(context: Context?, intent: Intent?) {
-            when (intent?.action) {
-                CONFIGURATION_CHANGE_EVENT_DASH -> setupDashboardRecyclerView(false)
-
-                DATA_LOGGER_CONNECTED_EVENT -> {
-                    renderingThread.start()
-                }
-
-                DATA_LOGGER_STOPPED_EVENT -> {
-                    renderingThread.stop()
-                    attachToFloatingButton(activity, query())
+    private var broadcastReceiver =
+        object : BroadcastReceiver() {
+            override fun onReceive(
+                context: Context?,
+                intent: Intent?,
+            ) {
+                when (intent?.action) {
+                    CONFIGURATION_CHANGE_EVENT_DASH -> setupDashboardRecyclerView(false)
+
+                    DATA_LOGGER_CONNECTED_EVENT -> {
+                        renderingThread.start()
+                    }
+
+                    DATA_LOGGER_STOPPED_EVENT -> {
+                        renderingThread.stop()
+                        configureActionButton(query())
+                    }
                 }
             }
         }
-    }
 
     override fun onConfigurationChanged(newConfig: Configuration) {
         super.onConfigurationChanged(newConfig)
@@ -98,24 +107,24 @@ class DashboardFragment : RefreshableFragment() {
     override fun onCreateView(
         inflater: LayoutInflater,
         container: ViewGroup?,
-        savedInstanceState: Bundle?
+        savedInstanceState: Bundle?,
     ): View {
         root = inflater.inflate(R.layout.fragment_dashboard, container, false)
         setupDashboardRecyclerView(true)
 
-        dataLogger.observe(viewLifecycleOwner) {
+        DataLoggerRepository.observe(viewLifecycleOwner) {
             it.run {
                 metricsCollector.append(it)
             }
         }
 
-        if (dataLogger.isRunning()) {
-            dataLogger.updateQuery(query())
+        if (DataLoggerRepository.isRunning()) {
+            withDataLogger {
+                updateQuery(query())
+            }
             renderingThread.start()
         }
 
-        attachToFloatingButton(activity, query())
-
         return root
     }
 
@@ -124,23 +133,26 @@ class DashboardFragment : RefreshableFragment() {
     private fun setupDashboardRecyclerView(enableOnTouchListener: Boolean) {
         configureView(
             configureChangeEventId = CONFIGURATION_CHANGE_EVENT_DASH,
-            recyclerView = root.findViewById(R.id.dashboard_recycler_view) as RecyclerView,
+            recyclerView = root.findViewById<RecyclerView>(R.id.dashboard_recycler_view)!!,
             metricsIdsPref = dashboardPreferences.dashboardSelectedMetrics.first,
-            adapterContext = AdapterContext(
-                layoutId = R.layout.item_dashboard,
-                spanCount = calculateSpanCount(),
-                height = calculateHeight(Prefs.getLongSet(dashboardPreferences.dashboardSelectedMetrics.first).size)
-            ),
+            adapterContext =
+                AdapterContext(
+                    layoutId = R.layout.item_dashboard,
+                    spanCount = calculateSpanCount(),
+                    height = calculateHeight(Prefs.getLongSet(dashboardPreferences.dashboardSelectedMetrics.first).size),
+                ),
             enableDragManager = dashboardPreferences.dragAndDropEnabled,
             enableOnTouchListener = enableOnTouchListener,
             enableSwipeToDelete = dashboardPreferences.swipeToDeleteEnabled,
-            adapter = { context: Context,
-                        data: MutableList<Metric>,
-                        resourceId: Int,
-                        height: Int? ->
+            adapter = {
+                context: Context,
+                data: MutableList<Metric>,
+                resourceId: Int,
+                height: Int?,
+                ->
                 DashboardViewAdapter(context, data, resourceId, height)
             },
-            metricsSerializerPref = "prefs.dash.pids.settings"
+            metricsSerializerPref = "prefs.dash.pids.settings",
         )
 
         metricsCollector.applyFilter(dashboardPreferences.dashboardSelectedMetrics.second)
@@ -154,7 +166,7 @@ class DashboardFragment : RefreshableFragment() {
     }
 
     private fun calculateSpanCount(): Int {
-        val numberOfItems =  Prefs.getLongSet(dashboardPreferences.dashboardSelectedMetrics.first).size
+        val numberOfItems = Prefs.getLongSet(dashboardPreferences.dashboardSelectedMetrics.first).size
         return if (numberOfItems <= 3) {
             1
         } else {
diff --git a/app/src/main/java/org/obd/graphs/ui/drag_racing/DragRacingFragment.kt b/app/src/main/java/org/obd/graphs/ui/drag_racing/DragRacingFragment.kt
index d9d0e8c6..9c53e3b0 100644
--- a/app/src/main/java/org/obd/graphs/ui/drag_racing/DragRacingFragment.kt
+++ b/app/src/main/java/org/obd/graphs/ui/drag_racing/DragRacingFragment.kt
@@ -21,23 +21,27 @@ import android.content.Context
 import android.content.Intent
 import android.content.res.Configuration
 import android.os.Bundle
-import android.view.*
+import android.view.LayoutInflater
+import android.view.SurfaceView
+import android.view.View
+import android.view.ViewGroup
 import androidx.fragment.app.Fragment
 import org.obd.graphs.R
 import org.obd.graphs.RenderingThread
 import org.obd.graphs.bl.collector.MetricsCollector
-import org.obd.graphs.bl.query.Query
 import org.obd.graphs.bl.datalogger.DATA_LOGGER_CONNECTED_EVENT
 import org.obd.graphs.bl.datalogger.DATA_LOGGER_STOPPED_EVENT
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
+import org.obd.graphs.bl.query.Query
 import org.obd.graphs.bl.query.QueryStrategyType
-import org.obd.graphs.bl.datalogger.dataLogger
 import org.obd.graphs.registerReceiver
 import org.obd.graphs.renderer.Fps
 import org.obd.graphs.renderer.SurfaceRenderer
 import org.obd.graphs.renderer.SurfaceRendererType
 import org.obd.graphs.renderer.ViewSettings
+import org.obd.graphs.ui.configureActionButton
 import org.obd.graphs.ui.common.SurfaceController
-import org.obd.graphs.ui.common.attachToFloatingButton
+import org.obd.graphs.ui.withDataLogger
 
 open class DragRacingFragment : Fragment() {
 
@@ -63,13 +67,15 @@ open class DragRacingFragment : Fragment() {
             when (intent?.action) {
 
                 DATA_LOGGER_CONNECTED_EVENT -> {
-                    dataLogger.updateQuery(query)
+                    withDataLogger {
+                       updateQuery(query)
+                    }
                     renderingThread.start()
                 }
 
                 DATA_LOGGER_STOPPED_EVENT -> {
                     renderingThread.stop()
-                    attachToFloatingButton(activity, query)
+                    configureActionButton(query)
                 }
             }
         }
@@ -83,7 +89,7 @@ open class DragRacingFragment : Fragment() {
     override fun onAttach(context: Context) {
         super.onAttach(context)
 
-        registerReceiver(activity, broadcastReceiver){
+        registerReceiver(activity, broadcastReceiver) {
             it.addAction(DATA_LOGGER_CONNECTED_EVENT)
             it.addAction(DATA_LOGGER_STOPPED_EVENT)
         }
@@ -106,7 +112,7 @@ open class DragRacingFragment : Fragment() {
         savedInstanceState: Bundle?
     ): View {
 
-        root  = inflater.inflate(R.layout.fragment_drag_racing, container, false)
+        root = inflater.inflate(R.layout.fragment_drag_racing, container, false)
 
         val surfaceView = root.findViewById<SurfaceView>(R.id.surface_view)
         val renderer = SurfaceRenderer.allocate(
@@ -121,18 +127,20 @@ open class DragRacingFragment : Fragment() {
             enabled = query.getIDs()
         )
 
-        dataLogger.observe(viewLifecycleOwner) {
+        DataLoggerRepository.observe(viewLifecycleOwner) {
             it.run {
                 metricsCollector.append(it)
             }
         }
 
-        if (dataLogger.isRunning()) {
-            dataLogger.updateQuery(query)
+        if (DataLoggerRepository.isRunning()) {
+            withDataLogger {
+                updateQuery(query)
+            }
             renderingThread.start()
         }
 
-        attachToFloatingButton(activity, query)
+        configureActionButton(query)
         return root
     }
 }
diff --git a/app/src/main/java/org/obd/graphs/ui/gauge/GaugeAdapter.kt b/app/src/main/java/org/obd/graphs/ui/gauge/GaugeAdapter.kt
index 19d3a9cf..d22f9d59 100644
--- a/app/src/main/java/org/obd/graphs/ui/gauge/GaugeAdapter.kt
+++ b/app/src/main/java/org/obd/graphs/ui/gauge/GaugeAdapter.kt
@@ -33,7 +33,7 @@ import androidx.recyclerview.widget.RecyclerView
 import org.obd.graphs.PREF_ALERTING_ENABLED
 import org.obd.graphs.R
 import org.obd.graphs.bl.collector.Metric
-import org.obd.graphs.bl.datalogger.dataLogger
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.format
 import org.obd.graphs.mapRange
 import org.obd.graphs.modules
@@ -212,7 +212,7 @@ class GaugeAdapter(
             if (preferences.commandRateEnabled) {
                 this.visibility = View.VISIBLE
                 val rate =
-                    dataLogger
+                    DataLoggerRepository
                         .getDiagnostics()
                         .rate()
                         .findBy(RateType.MEAN, pid)
diff --git a/app/src/main/java/org/obd/graphs/ui/gauge/GaugeFragment.kt b/app/src/main/java/org/obd/graphs/ui/gauge/GaugeFragment.kt
index f9668862..49898564 100644
--- a/app/src/main/java/org/obd/graphs/ui/gauge/GaugeFragment.kt
+++ b/app/src/main/java/org/obd/graphs/ui/gauge/GaugeFragment.kt
@@ -35,13 +35,22 @@ import org.obd.graphs.RenderingThread
 import org.obd.graphs.activity.TOOLBAR_TOGGLE_ACTION
 import org.obd.graphs.bl.collector.Metric
 import org.obd.graphs.bl.collector.MetricsCollector
-import org.obd.graphs.bl.datalogger.*
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_CONNECTED_EVENT
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_CONNECTING_EVENT
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_SCHEDULED_START_EVENT
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_STOPPED_EVENT
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.getPowerPreferences
-import org.obd.graphs.preferences.*
+import org.obd.graphs.preferences.Prefs
+import org.obd.graphs.preferences.getS
 import org.obd.graphs.registerReceiver
-import org.obd.graphs.ui.common.*
+import org.obd.graphs.ui.configureActionButton
+import org.obd.graphs.ui.common.COLOR_PHILIPPINE_GREEN
+import org.obd.graphs.ui.common.COLOR_TRANSPARENT
+import org.obd.graphs.ui.common.isTablet
 import org.obd.graphs.ui.recycler.RecyclerViewAdapter
 import org.obd.graphs.ui.recycler.RefreshableFragment
+import org.obd.graphs.ui.withDataLogger
 import kotlin.math.roundToInt
 
 private const val ENABLE_DRAG_AND_DROP_PREF = "pref.gauge_enable_drag_and_drop"
@@ -51,64 +60,74 @@ private const val GAUGE_PIDS_SETTINGS = "prefs.gauge.pids.settings"
 
 class GaugeFragment : RefreshableFragment() {
     private val metricsCollector = MetricsCollector.instance()
-    private val renderingThread: RenderingThread = RenderingThread(
-        id = "GaugeFragmentRenderingThread",
-        renderAction = {
-            refreshRecyclerView(metricsCollector, R.id.recycler_view)
-        },
-        perfFrameRate = {
-            Prefs.getS("pref.gauge.fps", "10").toInt()
-        }
-    )
+    private val renderingThread: RenderingThread =
+        RenderingThread(
+            id = "GaugeFragmentRenderingThread",
+            renderAction = {
+                refreshRecyclerView(metricsCollector, R.id.recycler_view)
+            },
+            perfFrameRate = {
+                Prefs.getS("pref.gauge.fps", "10").toInt()
+            },
+        )
 
     @SuppressLint("NotifyDataSetChanged")
-    private var broadcastReceiver = object : BroadcastReceiver() {
-        override fun onReceive(context: Context?, intent: Intent?) {
-            when (intent?.action) {
-                DATA_LOGGER_SCHEDULED_START_EVENT -> {
-                    if (isAdded && isVisible) {
-                        Log.i(org.obd.graphs.activity.LOG_TAG, "Scheduling data logger for=${query().getIDs()}")
-                        dataLogger.scheduleStart(getPowerPreferences().startDataLoggingAfter, query())
+    private var broadcastReceiver =
+        object : BroadcastReceiver() {
+            override fun onReceive(
+                context: Context?,
+                intent: Intent?,
+            ) {
+                when (intent?.action) {
+                    DATA_LOGGER_SCHEDULED_START_EVENT -> {
+                        if (isAdded && isVisible) {
+                            Log.i(org.obd.graphs.activity.LOG_TAG, "Scheduling data logger for=${query().getIDs()}")
+                            withDataLogger {
+                                scheduleStart(getPowerPreferences().startDataLoggingAfter, query())
+                            }
+                        }
                     }
-                }
 
-                CONFIGURE_CHANGE_EVENT_GAUGE -> {
-                    configureView(false)
-                }
-                DATA_LOGGER_CONNECTING_EVENT -> {
-                    val recyclerView = root.findViewById(R.id.recycler_view) as RecyclerView
-                    val adapter = recyclerView.adapter as RecyclerViewAdapter
-                    val metrics = prepareMetrics(
-                        metricsIdsPref = gaugeVirtualScreen.getVirtualScreenPrefKey(),
-                        metricsSerializerPref = GAUGE_PIDS_SETTINGS
-                    )
-                    adapter.data.clear()
-                    adapter.data.addAll(metrics)
-                    adapter.notifyDataSetChanged()
-                }
-                DATA_LOGGER_CONNECTED_EVENT -> {
-                    virtualScreensPanel {
-                        it.isVisible = false
+                    CONFIGURE_CHANGE_EVENT_GAUGE -> {
+                        configureView(false)
                     }
-                    renderingThread.start()
-                }
 
-                DATA_LOGGER_STOPPED_EVENT -> {
-                    virtualScreensPanel {
-                        it.isVisible = true
+                    DATA_LOGGER_CONNECTING_EVENT -> {
+                        val recyclerView: RecyclerView = root.findViewById(R.id.recycler_view)
+                        val adapter = recyclerView.adapter as RecyclerViewAdapter
+                        val metrics =
+                            prepareMetrics(
+                                metricsIdsPref = gaugeVirtualScreen.getVirtualScreenPrefKey(),
+                                metricsSerializerPref = GAUGE_PIDS_SETTINGS,
+                            )
+                        adapter.data.clear()
+                        adapter.data.addAll(metrics)
+                        adapter.notifyDataSetChanged()
+                    }
+
+                    DATA_LOGGER_CONNECTED_EVENT -> {
+                        virtualScreensPanel {
+                            it.isVisible = false
+                        }
+                        renderingThread.start()
+                    }
+
+                    DATA_LOGGER_STOPPED_EVENT -> {
+                        virtualScreensPanel {
+                            it.isVisible = true
+                        }
+                        renderingThread.stop()
+                        configureActionButton(query())
                     }
-                    renderingThread.stop()
-                    attachToFloatingButton(activity, query())
-                }
 
-                TOOLBAR_TOGGLE_ACTION -> {
-                    virtualScreensPanel {
-                        it.isVisible = !it.isVisible
+                    TOOLBAR_TOGGLE_ACTION -> {
+                        virtualScreensPanel {
+                            it.isVisible = !it.isVisible
+                        }
                     }
                 }
             }
         }
-    }
 
     override fun onConfigurationChanged(newConfig: Configuration) {
         super.onConfigurationChanged(newConfig)
@@ -118,11 +137,11 @@ class GaugeFragment : RefreshableFragment() {
     override fun onCreateView(
         inflater: LayoutInflater,
         container: ViewGroup?,
-        savedInstanceState: Bundle?
+        savedInstanceState: Bundle?,
     ): View {
         root = inflater.inflate(R.layout.fragment_gauge, container, false)
 
-        dataLogger.observe(viewLifecycleOwner) {
+        DataLoggerRepository.observe(viewLifecycleOwner) {
             it.run {
                 metricsCollector.append(it)
             }
@@ -131,20 +150,22 @@ class GaugeFragment : RefreshableFragment() {
         configureView(true)
         setupVirtualViewPanel()
 
-        if (dataLogger.isRunning()) {
-            dataLogger.updateQuery(query())
+        if (DataLoggerRepository.isRunning()) {
+            withDataLogger {
+                updateQuery(query())
+            }
+
             renderingThread.start()
         }
 
-        attachToFloatingButton(activity, query())
+        configureActionButton(query())
 
         return root
     }
 
-
     override fun onAttach(context: Context) {
         super.onAttach(context)
-        registerReceiver(activity, broadcastReceiver){
+        registerReceiver(activity, broadcastReceiver) {
             it.addAction(CONFIGURE_CHANGE_EVENT_GAUGE)
             it.addAction(DATA_LOGGER_CONNECTING_EVENT)
             it.addAction(DATA_LOGGER_CONNECTED_EVENT)
@@ -173,23 +194,25 @@ class GaugeFragment : RefreshableFragment() {
     private fun configureView(enableOnTouchListener: Boolean) {
         configureView(
             configureChangeEventId = CONFIGURE_CHANGE_EVENT_GAUGE,
-            recyclerView = root.findViewById(R.id.recycler_view) as RecyclerView,
+            recyclerView = root.findViewById<RecyclerView>(R.id.recycler_view)!!,
             metricsIdsPref = gaugeVirtualScreen.getVirtualScreenPrefKey(),
-            adapterContext = AdapterContext(
-                layoutId = R.layout.item_gauge,
-                spanCount = calculateSpan()
-            ),
-
+            adapterContext =
+                AdapterContext(
+                    layoutId = R.layout.item_gauge,
+                    spanCount = calculateSpan(),
+                ),
             enableSwipeToDelete = Prefs.getBoolean(ENABLE_SWIPE_TO_DELETE_PREF, false),
             enableDragManager = Prefs.getBoolean(ENABLE_DRAG_AND_DROP_PREF, false),
             enableOnTouchListener = enableOnTouchListener,
-            adapter = { context: Context,
-                        data: MutableList<Metric>,
-                        resourceId: Int,
-                        height: Int? ->
+            adapter = {
+                context: Context,
+                data: MutableList<Metric>,
+                resourceId: Int,
+                height: Int?,
+                ->
                 GaugeAdapter(context, data, resourceId, height)
             },
-            metricsSerializerPref = GAUGE_PIDS_SETTINGS
+            metricsSerializerPref = GAUGE_PIDS_SETTINGS,
         )
 
         metricsCollector.applyFilter(getSelectedPIDs())
@@ -212,6 +235,7 @@ class GaugeFragment : RefreshableFragment() {
                     }
                 }
             }
+
             else -> {
                 when (numberOfPIDsToDisplay) {
                     0 -> 1
@@ -225,7 +249,11 @@ class GaugeFragment : RefreshableFragment() {
 
     private fun getSelectedPIDs() = query.filterBy(gaugeVirtualScreen.getVirtualScreenPrefKey())
 
-    private fun setVirtualViewBtn(btnId: Int, selection: String, viewId: String) {
+    private fun setVirtualViewBtn(
+        btnId: Int,
+        selection: String,
+        viewId: String,
+    ) {
         (root.findViewById<Button>(btnId)).let {
             if (selection == viewId) {
                 it.setBackgroundColor(COLOR_PHILIPPINE_GREEN)
@@ -236,8 +264,10 @@ class GaugeFragment : RefreshableFragment() {
             it.setOnClickListener {
                 gaugeVirtualScreen.updateVirtualScreen(viewId)
 
-                if (dataLogger.isRunning()) {
-                    dataLogger.updateQuery(query())
+                if (DataLoggerRepository.isRunning()) {
+                    withDataLogger {
+                        updateQuery(query())
+                    }
                 }
 
                 configureView(true)
diff --git a/app/src/main/java/org/obd/graphs/ui/giulia/GiuliaFragment.kt b/app/src/main/java/org/obd/graphs/ui/giulia/GiuliaFragment.kt
index 14ade280..b4ebd303 100644
--- a/app/src/main/java/org/obd/graphs/ui/giulia/GiuliaFragment.kt
+++ b/app/src/main/java/org/obd/graphs/ui/giulia/GiuliaFragment.kt
@@ -35,7 +35,7 @@ import org.obd.graphs.bl.collector.MetricsCollector
 import org.obd.graphs.bl.datalogger.DATA_LOGGER_CONNECTED_EVENT
 import org.obd.graphs.bl.datalogger.DATA_LOGGER_SCHEDULED_START_EVENT
 import org.obd.graphs.bl.datalogger.DATA_LOGGER_STOPPED_EVENT
-import org.obd.graphs.bl.datalogger.dataLogger
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.bl.query.Query
 import org.obd.graphs.getPowerPreferences
 import org.obd.graphs.registerReceiver
@@ -43,10 +43,11 @@ import org.obd.graphs.renderer.Fps
 import org.obd.graphs.renderer.SurfaceRenderer
 import org.obd.graphs.renderer.SurfaceRendererType
 import org.obd.graphs.renderer.ViewSettings
+import org.obd.graphs.ui.configureActionButton
 import org.obd.graphs.ui.common.COLOR_PHILIPPINE_GREEN
 import org.obd.graphs.ui.common.COLOR_TRANSPARENT
 import org.obd.graphs.ui.common.SurfaceController
-import org.obd.graphs.ui.common.attachToFloatingButton
+import org.obd.graphs.ui.withDataLogger
 
 open class GiuliaFragment : Fragment() {
     private lateinit var root: View
@@ -81,7 +82,9 @@ open class GiuliaFragment : Fragment() {
                     DATA_LOGGER_SCHEDULED_START_EVENT -> {
                         if (isAdded && isVisible) {
                             Log.i(LOG_TAG, "Scheduling data logger for=${query().getIDs()}")
-                            dataLogger.scheduleStart(getPowerPreferences().startDataLoggingAfter, query())
+                            withDataLogger {
+                                scheduleStart(getPowerPreferences().startDataLoggingAfter, query())
+                            }
                         }
                     }
 
@@ -92,7 +95,7 @@ open class GiuliaFragment : Fragment() {
 
                     DATA_LOGGER_STOPPED_EVENT -> {
                         renderingThread.stop()
-                        attachToFloatingButton(activity, query())
+                        configureActionButton(query())
                     }
                 }
             }
@@ -146,18 +149,20 @@ open class GiuliaFragment : Fragment() {
 
         applyFilter()
 
-        dataLogger.observe(viewLifecycleOwner) {
+        DataLoggerRepository.observe(viewLifecycleOwner) {
             it.run {
                 metricsCollector.append(it, forceAppend = false)
             }
         }
 
-        if (dataLogger.isRunning()) {
-            dataLogger.updateQuery(query())
+        if (DataLoggerRepository.isRunning()) {
+            withDataLogger {
+                updateQuery(query())
+            }
             renderingThread.start()
         }
 
-        attachToFloatingButton(activity, query())
+        configureActionButton(query())
 
         return root
     }
@@ -176,8 +181,10 @@ open class GiuliaFragment : Fragment() {
 
             it.setOnClickListener {
                 giuliaVirtualScreen.updateVirtualScreen(viewId)
+                withDataLogger {
+                   updateQuery(query())
+                }
 
-                dataLogger.updateQuery(query())
                 applyFilter()
                 setupVirtualViewPanel()
                 surfaceController.renderFrame()
diff --git a/app/src/main/java/org/obd/graphs/ui/graph/GraphFragment.kt b/app/src/main/java/org/obd/graphs/ui/graph/GraphFragment.kt
index 38dc4dcb..48616d86 100644
--- a/app/src/main/java/org/obd/graphs/ui/graph/GraphFragment.kt
+++ b/app/src/main/java/org/obd/graphs/ui/graph/GraphFragment.kt
@@ -51,7 +51,7 @@ import org.obd.graphs.bl.datalogger.DATA_LOGGER_CONNECTED_EVENT
 import org.obd.graphs.bl.datalogger.DATA_LOGGER_CONNECTING_EVENT
 import org.obd.graphs.bl.datalogger.DATA_LOGGER_SCHEDULED_START_EVENT
 import org.obd.graphs.bl.datalogger.DATA_LOGGER_STOPPED_EVENT
-import org.obd.graphs.bl.datalogger.dataLogger
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.bl.datalogger.scaleToRange
 import org.obd.graphs.bl.query.Query
 import org.obd.graphs.bl.query.QueryStrategyType
@@ -61,11 +61,12 @@ import org.obd.graphs.bl.trip.tripVirtualScreenManager
 import org.obd.graphs.getPowerPreferences
 import org.obd.graphs.preferences.Prefs
 import org.obd.graphs.registerReceiver
+import org.obd.graphs.ui.configureActionButton
 import org.obd.graphs.ui.common.COLOR_PHILIPPINE_GREEN
 import org.obd.graphs.ui.common.COLOR_TRANSPARENT
 import org.obd.graphs.ui.common.Colors
-import org.obd.graphs.ui.common.attachToFloatingButton
 import org.obd.graphs.ui.common.onDoubleClickListener
+import org.obd.graphs.ui.withDataLogger
 import org.obd.metrics.api.model.ObdMetric
 import org.obd.metrics.pid.PidDefinition
 import org.obd.metrics.pid.PidDefinitionRegistry
@@ -86,7 +87,9 @@ class GraphFragment : Fragment() {
                     DATA_LOGGER_SCHEDULED_START_EVENT -> {
                         if (isAdded && isVisible) {
                             Log.i(org.obd.graphs.activity.LOG_TAG, "Scheduling data logger for=${query().getIDs()}")
-                            dataLogger.scheduleStart(getPowerPreferences().startDataLoggingAfter, query())
+                            withDataLogger {
+                                scheduleStart(getPowerPreferences().startDataLoggingAfter, query())
+                            }
                         }
                     }
 
@@ -99,7 +102,7 @@ class GraphFragment : Fragment() {
                             it.isVisible = true
                         }
 
-                        attachToFloatingButton(activity, query())
+                        configureActionButton(query())
                     }
 
                     DATA_LOGGER_CONNECTED_EVENT -> {
@@ -133,7 +136,8 @@ class GraphFragment : Fragment() {
             override fun onChartGestureStart(
                 me: MotionEvent,
                 lastPerformedGesture: ChartGesture,
-            ) {}
+            ) {
+            }
 
             override fun onChartGestureEnd(
                 me: MotionEvent,
@@ -162,13 +166,15 @@ class GraphFragment : Fragment() {
                 me: MotionEvent,
                 scaleX: Float,
                 scaleY: Float,
-            ) {}
+            ) {
+            }
 
             override fun onChartTranslate(
                 me: MotionEvent,
                 dX: Float,
                 dY: Float,
-            ) {}
+            ) {
+            }
         }
 
     private val simpleDateFormat = SimpleDateFormat("HH:mm:ss", Locale.getDefault())
@@ -198,7 +204,8 @@ class GraphFragment : Fragment() {
         registerReceivers()
         configureRecyclerView()
         setupVirtualViewPanel()
-        attachToFloatingButton(activity, query())
+        configureActionButton(query())
+        configureActionButton(query())
         return root
     }
 
@@ -223,7 +230,7 @@ class GraphFragment : Fragment() {
     }
 
     private fun registerMetricsObserver() {
-        dataLogger.observe(viewLifecycleOwner) {
+        DataLoggerRepository.observe(viewLifecycleOwner) {
             if (preferences.metrics.contains(it.command.pid.id)) {
                 addEntry(it)
             }
@@ -238,8 +245,8 @@ class GraphFragment : Fragment() {
         recyclerView.layoutManager = GridLayoutManager(root.context, 1)
         recyclerView.adapter = adapter
 
-        dataLogger.observe(viewLifecycleOwner) {
-            dataLogger.findHistogramFor(it).let { hist ->
+        DataLoggerRepository.observe(viewLifecycleOwner) {
+            DataLoggerRepository.findHistogramFor(it).let { hist ->
                 val sensorData =
                     SensorData(
                         id = it.command.pid.id,
@@ -264,7 +271,7 @@ class GraphFragment : Fragment() {
         val colors = Colors().get()
         chart =
             buildChart(root).apply {
-                val pidRegistry: PidDefinitionRegistry = dataLogger.getPidDefinitionRegistry()
+                val pidRegistry: PidDefinitionRegistry = DataLoggerRepository.getPidDefinitionRegistry()
                 val metrics =
                     preferences.metrics
                         .mapNotNull {
@@ -300,7 +307,7 @@ class GraphFragment : Fragment() {
     private fun loadCurrentTrip() {
         if (preferences.cacheEnabled) {
             val trip = tripManager.getCurrentTrip()
-            val registry = dataLogger.getPidDefinitionRegistry()
+            val registry = DataLoggerRepository.getPidDefinitionRegistry()
             tripStartTs = trip.startTs
 
             val recyclerView: RecyclerView = root.findViewById(R.id.recycler_view)
diff --git a/app/src/main/java/org/obd/graphs/ui/graph/MarkerWindow.kt b/app/src/main/java/org/obd/graphs/ui/graph/MarkerWindow.kt
index 40f98690..b893ea83 100644
--- a/app/src/main/java/org/obd/graphs/ui/graph/MarkerWindow.kt
+++ b/app/src/main/java/org/obd/graphs/ui/graph/MarkerWindow.kt
@@ -26,7 +26,7 @@ import com.github.mikephil.charting.data.Entry
 import com.github.mikephil.charting.highlight.Highlight
 import com.github.mikephil.charting.utils.MPPointF
 import org.obd.graphs.R
-import org.obd.graphs.bl.datalogger.dataLogger
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.bl.datalogger.scaleToRange
 import org.obd.metrics.api.model.ObdMetric
 import org.obd.metrics.command.obd.ObdCommand
@@ -111,7 +111,7 @@ class MarkerWindow(
         id: Long,
         v: Float,
     ): ObdMetric {
-        val pidRegistry: PidDefinitionRegistry = dataLogger.getPidDefinitionRegistry()
+        val pidRegistry: PidDefinitionRegistry = DataLoggerRepository.getPidDefinitionRegistry()
         val pid = pidRegistry.findBy(id)
         val value = pid.scaleToRange(v)
         return ObdMetric
diff --git a/app/src/main/java/org/obd/graphs/ui/graph/TripDetailsViewAdapter.kt b/app/src/main/java/org/obd/graphs/ui/graph/TripDetailsViewAdapter.kt
index fce9c76c..be285570 100644
--- a/app/src/main/java/org/obd/graphs/ui/graph/TripDetailsViewAdapter.kt
+++ b/app/src/main/java/org/obd/graphs/ui/graph/TripDetailsViewAdapter.kt
@@ -24,7 +24,7 @@ import android.view.ViewGroup
 import android.widget.TextView
 import androidx.recyclerview.widget.RecyclerView
 import org.obd.graphs.R
-import org.obd.graphs.bl.datalogger.dataLogger
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.bl.trip.SensorData
 import org.obd.graphs.format
 import org.obd.graphs.ui.common.COLOR_PHILIPPINE_GREEN
@@ -47,7 +47,7 @@ class TripDetailsViewAdapter internal constructor(
         position: Int,
     ) {
         mData.elementAt(position).let { metric ->
-            val pid = dataLogger.getPidDefinitionRegistry().findBy(metric.id)
+            val pid = DataLoggerRepository.getPidDefinitionRegistry().findBy(metric.id)
             holder.metricName.setText(pid.description, COLOR_PHILIPPINE_GREEN, 1.0f)
             metric.run {
                 holder.metricMaxValue.setText(
diff --git a/app/src/main/java/org/obd/graphs/ui/performance/PerformanceFragment.kt b/app/src/main/java/org/obd/graphs/ui/performance/PerformanceFragment.kt
index 9dd9e6d0..0629f389 100644
--- a/app/src/main/java/org/obd/graphs/ui/performance/PerformanceFragment.kt
+++ b/app/src/main/java/org/obd/graphs/ui/performance/PerformanceFragment.kt
@@ -22,23 +22,27 @@ import android.content.Context
 import android.content.Intent
 import android.content.res.Configuration
 import android.os.Bundle
-import android.view.*
+import android.view.LayoutInflater
+import android.view.SurfaceView
+import android.view.View
+import android.view.ViewGroup
 import androidx.fragment.app.Fragment
 import org.obd.graphs.R
 import org.obd.graphs.RenderingThread
 import org.obd.graphs.bl.collector.MetricsCollector
-import org.obd.graphs.bl.query.Query
 import org.obd.graphs.bl.datalogger.DATA_LOGGER_CONNECTED_EVENT
 import org.obd.graphs.bl.datalogger.DATA_LOGGER_STOPPED_EVENT
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
+import org.obd.graphs.bl.query.Query
 import org.obd.graphs.bl.query.QueryStrategyType
-import org.obd.graphs.bl.datalogger.dataLogger
 import org.obd.graphs.registerReceiver
 import org.obd.graphs.renderer.Fps
 import org.obd.graphs.renderer.SurfaceRenderer
 import org.obd.graphs.renderer.SurfaceRendererType
 import org.obd.graphs.renderer.ViewSettings
+import org.obd.graphs.ui.configureActionButton
 import org.obd.graphs.ui.common.SurfaceController
-import org.obd.graphs.ui.common.attachToFloatingButton
+import org.obd.graphs.ui.withDataLogger
 
 open class PerformanceFragment : Fragment() {
     private lateinit var root: View
@@ -50,43 +54,48 @@ open class PerformanceFragment : Fragment() {
     private val settings = PerformanceSettings()
     private lateinit var surfaceController: SurfaceController
 
-    private val renderingThread: RenderingThread = RenderingThread(
-        id = "DragRacingRenderingThread",
-        renderAction = {
-            surfaceController.renderFrame()
-        },
-        perfFrameRate = {
-            settings.getSurfaceFrameRate()
-        }
-    )
-
-    private var broadcastReceiver = object : BroadcastReceiver() {
-        override fun onReceive(context: Context?, intent: Intent?) {
-            when (intent?.action) {
-
-                DATA_LOGGER_CONNECTED_EVENT -> {
-                    dataLogger.updateQuery(query)
-                    renderingThread.start()
-                }
+    private val renderingThread: RenderingThread =
+        RenderingThread(
+            id = "DragRacingRenderingThread",
+            renderAction = {
+                surfaceController.renderFrame()
+            },
+            perfFrameRate = {
+                settings.getSurfaceFrameRate()
+            },
+        )
 
-                DATA_LOGGER_STOPPED_EVENT -> {
-                    renderingThread.stop()
-                    attachToFloatingButton(activity, query)
+    private var broadcastReceiver =
+        object : BroadcastReceiver() {
+            override fun onReceive(
+                context: Context?,
+                intent: Intent?,
+            ) {
+                when (intent?.action) {
+                    DATA_LOGGER_CONNECTED_EVENT -> {
+                        withDataLogger {
+                            updateQuery(query)
+                        }
+                        renderingThread.start()
+                    }
+
+                    DATA_LOGGER_STOPPED_EVENT -> {
+                        renderingThread.stop()
+                        configureActionButton(query)
+                    }
                 }
             }
         }
-    }
 
     override fun onConfigurationChanged(newConfig: Configuration) {
         super.onConfigurationChanged(newConfig)
         surfaceController.renderFrame()
-
     }
 
     override fun onAttach(context: Context) {
         super.onAttach(context)
 
-        registerReceiver(activity, broadcastReceiver){
+        registerReceiver(activity, broadcastReceiver) {
             it.addAction(DATA_LOGGER_CONNECTED_EVENT)
             it.addAction(DATA_LOGGER_STOPPED_EVENT)
         }
@@ -107,36 +116,42 @@ open class PerformanceFragment : Fragment() {
     override fun onCreateView(
         inflater: LayoutInflater,
         container: ViewGroup?,
-        savedInstanceState: Bundle?
+        savedInstanceState: Bundle?,
     ): View {
-
-        root  = inflater.inflate(R.layout.fragment_drag_racing, container, false)
+        root = inflater.inflate(R.layout.fragment_drag_racing, container, false)
 
         val surfaceView = root.findViewById<SurfaceView>(R.id.surface_view)
-        val renderer = SurfaceRenderer.allocate(
-            requireContext(), settings, metricsCollector, fps,
-            surfaceRendererType = SurfaceRendererType.PERFORMANCE, viewSettings = ViewSettings(marginTop = 20)
-        )
+        val renderer =
+            SurfaceRenderer.allocate(
+                requireContext(),
+                settings,
+                metricsCollector,
+                fps,
+                surfaceRendererType = SurfaceRendererType.PERFORMANCE,
+                viewSettings = ViewSettings(marginTop = 20),
+            )
 
         surfaceController = SurfaceController(renderer)
         surfaceView.holder.addCallback(surfaceController)
 
         metricsCollector.applyFilter(
-            enabled = query.getIDs()
+            enabled = query.getIDs(),
         )
 
-        dataLogger.observe(viewLifecycleOwner) {
+        DataLoggerRepository.observe(viewLifecycleOwner) {
             it.run {
                 metricsCollector.append(it)
             }
         }
 
-        if (dataLogger.isRunning()) {
-            dataLogger.updateQuery(query)
+        if (DataLoggerRepository.isRunning()) {
+            withDataLogger {
+                updateQuery(query)
+            }
             renderingThread.start()
         }
 
-        attachToFloatingButton(activity, query)
+        configureActionButton(query)
         return root
     }
 }
diff --git a/app/src/main/java/org/obd/graphs/ui/recycler/RefreshableFragment.kt b/app/src/main/java/org/obd/graphs/ui/recycler/RefreshableFragment.kt
index 17993ea4..71aa0b37 100644
--- a/app/src/main/java/org/obd/graphs/ui/recycler/RefreshableFragment.kt
+++ b/app/src/main/java/org/obd/graphs/ui/recycler/RefreshableFragment.kt
@@ -24,7 +24,9 @@ import androidx.recyclerview.widget.GridLayoutManager
 import androidx.recyclerview.widget.ItemTouchHelper
 import androidx.recyclerview.widget.RecyclerView
 import org.obd.graphs.ViewPreferencesSerializer
-import org.obd.graphs.bl.collector.*
+import org.obd.graphs.bl.collector.Metric
+import org.obd.graphs.bl.collector.MetricsBuilder
+import org.obd.graphs.bl.collector.MetricsCollector
 import org.obd.graphs.bl.query.Query
 import org.obd.graphs.preferences.Prefs
 import org.obd.graphs.preferences.updateLongSet
@@ -35,13 +37,15 @@ import org.obd.graphs.ui.common.ToggleToolbarDoubleClickListener
 import org.obd.graphs.ui.gauge.AdapterContext
 
 open class RefreshableFragment : Fragment() {
-
     protected val query: Query = Query.instance()
     protected lateinit var root: View
 
-    protected fun refreshRecyclerView(metricsCollector: MetricsCollector, recyclerViewId: Int) {
-        if (::root.isInitialized){
-            val adapter = ((root.findViewById(recyclerViewId) as RecyclerView).adapter) as RecyclerViewAdapter<RecyclerView.ViewHolder>
+    protected fun refreshRecyclerView(
+        metricsCollector: MetricsCollector,
+        recyclerViewId: Int,
+    ) {
+        if (::root.isInitialized) {
+            val adapter = ((root.findViewById<RecyclerView>(recyclerViewId)!!).adapter) as RecyclerViewAdapter<RecyclerView.ViewHolder>
             val data = adapter.data
             metricsCollector.getMetrics().forEach {
                 it.run {
@@ -57,7 +61,7 @@ open class RefreshableFragment : Fragment() {
 
     protected fun prepareMetrics(
         metricsIdsPref: String,
-        metricsSerializerPref: String
+        metricsSerializerPref: String,
     ): MutableList<Metric> {
         val viewPreferences = ViewPreferencesSerializer(metricsSerializerPref)
         val metricsIds = query.filterBy(metricsIdsPref)
@@ -77,20 +81,20 @@ open class RefreshableFragment : Fragment() {
             context: Context,
             data: MutableList<Metric>,
             resourceId: Int,
-            height: Int?
+            height: Int?,
         ) -> RecyclerViewAdapter<*>,
-        metricsSerializerPref: String
+        metricsSerializerPref: String,
     ) {
-
         val viewPreferences = ViewPreferencesSerializer(metricsSerializerPref)
         val metricsIds = query.filterBy(metricsIdsPref)
         val metrics = MetricsBuilder().buildFor(metricsIds, viewPreferences.getItemsSortOrder())
 
         recyclerView.layoutManager = GridLayoutManager(requireContext(), adapterContext.spanCount)
-        recyclerView.adapter = adapter(requireContext(), metrics, adapterContext.layoutId, adapterContext.height).apply {
-            setHasStableIds(true)
-            notifyDataSetChanged()
-        }
+        recyclerView.adapter =
+            adapter(requireContext(), metrics, adapterContext.layoutId, adapterContext.height).apply {
+                setHasStableIds(true)
+                notifyDataSetChanged()
+            }
 
         attachDragManager(
             configureChangeEventId = configureChangeEventId,
@@ -98,7 +102,7 @@ open class RefreshableFragment : Fragment() {
             enableDragManager = enableDragManager,
             recyclerView = recyclerView,
             metricsIdsPref = metricsIdsPref,
-            viewPreferences = viewPreferences
+            viewPreferences = viewPreferences,
         )
 
         attachOnTouchListener(enableOnTouchListener, recyclerView)
@@ -110,41 +114,45 @@ open class RefreshableFragment : Fragment() {
         configureChangeEventId: String,
         recyclerView: RecyclerView,
         metricsIdsPref: String,
-        viewSerializer: ViewPreferencesSerializer
-    ): SwappableAdapter = object : SwappableAdapter {
-        override fun swapItems(fromPosition: Int, toPosition: Int) {
-            adapter(recyclerView).swapItems(
-                fromPosition,
-                toPosition
-            )
-        }
+        viewSerializer: ViewPreferencesSerializer,
+    ): SwappableAdapter =
+        object : SwappableAdapter {
+            override fun swapItems(
+                fromPosition: Int,
+                toPosition: Int,
+            ) {
+                adapter(recyclerView).swapItems(
+                    fromPosition,
+                    toPosition,
+                )
+            }
 
-        override fun storePreferences(context: Context) {
-            viewSerializer.store(adapter(recyclerView).data.map { it.source.command.pid.id })
-        }
+            override fun storePreferences(context: Context) {
+                viewSerializer.store(adapter(recyclerView).data.map { it.source.command.pid.id })
+            }
 
-        override fun deleteItems(fromPosition: Int) {
-            val data = adapter(recyclerView).data
-            val itemId: Metric = data[fromPosition]
-            data.remove(itemId)
+            override fun deleteItems(fromPosition: Int) {
+                val data = adapter(recyclerView).data
+                val itemId: Metric = data[fromPosition]
+                data.remove(itemId)
 
-            Prefs.updateLongSet(
-                metricsIdsPref,
-                data.map { obdMetric -> obdMetric.source.command.pid.id }.toList()
-            )
-            sendBroadcastEvent(configureChangeEventId)
+                Prefs.updateLongSet(
+                    metricsIdsPref,
+                    data.map { obdMetric -> obdMetric.source.command.pid.id }.toList(),
+                )
+                sendBroadcastEvent(configureChangeEventId)
+            }
         }
-    }
 
     private fun attachOnTouchListener(
         enableOnTouchListener: Boolean,
-        recyclerView: RecyclerView
+        recyclerView: RecyclerView,
     ) {
         if (enableOnTouchListener) {
             recyclerView.addOnItemTouchListener(
                 ToggleToolbarDoubleClickListener(
-                    requireContext()
-                )
+                    requireContext(),
+                ),
             )
         }
     }
@@ -155,29 +163,31 @@ open class RefreshableFragment : Fragment() {
         enableSwipeToDelete: Boolean = false,
         recyclerView: RecyclerView,
         metricsIdsPref: String,
-        viewPreferences: ViewPreferencesSerializer
+        viewPreferences: ViewPreferencesSerializer,
     ) {
         if (enableDragManager) {
             val swappableAdapter = createSwappableAdapter(configureChangeEventId, recyclerView, metricsIdsPref, viewPreferences)
 
-            val callback = if (enableSwipeToDelete)
-                DragManageAdapter(
-                    requireContext(),
-                    ItemTouchHelper.UP or ItemTouchHelper.DOWN,
-                    ItemTouchHelper.START or ItemTouchHelper.END, swappableAdapter
-                )
-            else
-                DragManageAdapter(
-                    requireContext(),
-                    ItemTouchHelper.UP or ItemTouchHelper.DOWN,
-                    ItemTouchHelper.ACTION_STATE_DRAG, swappableAdapter
-                )
+            val callback =
+                if (enableSwipeToDelete) {
+                    DragManageAdapter(
+                        requireContext(),
+                        ItemTouchHelper.UP or ItemTouchHelper.DOWN,
+                        ItemTouchHelper.START or ItemTouchHelper.END,
+                        swappableAdapter,
+                    )
+                } else {
+                    DragManageAdapter(
+                        requireContext(),
+                        ItemTouchHelper.UP or ItemTouchHelper.DOWN,
+                        ItemTouchHelper.ACTION_STATE_DRAG,
+                        swappableAdapter,
+                    )
+                }
 
             ItemTouchHelper(callback).attachToRecyclerView(recyclerView)
         }
     }
 
-    private fun adapter(recyclerView: RecyclerView) =
-        (recyclerView.adapter as RecyclerViewAdapter)
-
+    private fun adapter(recyclerView: RecyclerView) = (recyclerView.adapter as RecyclerViewAdapter)
 }
diff --git a/app/src/main/java/org/obd/graphs/ui/trip_info/TripInfoFragment.kt b/app/src/main/java/org/obd/graphs/ui/trip_info/TripInfoFragment.kt
index 63ffd40d..b96f39c2 100644
--- a/app/src/main/java/org/obd/graphs/ui/trip_info/TripInfoFragment.kt
+++ b/app/src/main/java/org/obd/graphs/ui/trip_info/TripInfoFragment.kt
@@ -22,23 +22,27 @@ import android.content.Context
 import android.content.Intent
 import android.content.res.Configuration
 import android.os.Bundle
-import android.view.*
+import android.view.LayoutInflater
+import android.view.SurfaceView
+import android.view.View
+import android.view.ViewGroup
 import androidx.fragment.app.Fragment
 import org.obd.graphs.R
 import org.obd.graphs.RenderingThread
 import org.obd.graphs.bl.collector.MetricsCollector
-import org.obd.graphs.bl.query.Query
 import org.obd.graphs.bl.datalogger.DATA_LOGGER_CONNECTED_EVENT
 import org.obd.graphs.bl.datalogger.DATA_LOGGER_STOPPED_EVENT
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
+import org.obd.graphs.bl.query.Query
 import org.obd.graphs.bl.query.QueryStrategyType
-import org.obd.graphs.bl.datalogger.dataLogger
 import org.obd.graphs.registerReceiver
 import org.obd.graphs.renderer.Fps
 import org.obd.graphs.renderer.SurfaceRenderer
 import org.obd.graphs.renderer.SurfaceRendererType
 import org.obd.graphs.renderer.ViewSettings
+import org.obd.graphs.ui.configureActionButton
 import org.obd.graphs.ui.common.SurfaceController
-import org.obd.graphs.ui.common.attachToFloatingButton
+import org.obd.graphs.ui.withDataLogger
 
 open class TripInfoFragment : Fragment() {
     private lateinit var root: View
@@ -65,13 +69,15 @@ open class TripInfoFragment : Fragment() {
             when (intent?.action) {
 
                 DATA_LOGGER_CONNECTED_EVENT -> {
-                    dataLogger.updateQuery(query)
+                    withDataLogger {
+                        updateQuery(query)
+                    }
                     renderingThread.start()
                 }
 
                 DATA_LOGGER_STOPPED_EVENT -> {
                     renderingThread.stop()
-                    attachToFloatingButton(activity, query)
+                    configureActionButton(query)
                 }
             }
         }
@@ -86,7 +92,7 @@ open class TripInfoFragment : Fragment() {
     override fun onAttach(context: Context) {
         super.onAttach(context)
 
-        registerReceiver(activity, broadcastReceiver){
+        registerReceiver(activity, broadcastReceiver) {
             it.addAction(DATA_LOGGER_CONNECTED_EVENT)
             it.addAction(DATA_LOGGER_STOPPED_EVENT)
         }
@@ -110,7 +116,7 @@ open class TripInfoFragment : Fragment() {
         savedInstanceState: Bundle?
     ): View {
 
-        root  = inflater.inflate(R.layout.fragment_drag_racing, container, false)
+        root = inflater.inflate(R.layout.fragment_drag_racing, container, false)
 
         val surfaceView = root.findViewById<SurfaceView>(R.id.surface_view)
         val renderer = SurfaceRenderer.allocate(
@@ -125,18 +131,21 @@ open class TripInfoFragment : Fragment() {
             enabled = query.getIDs()
         )
 
-        dataLogger.observe(viewLifecycleOwner) {
+        DataLoggerRepository.observe(viewLifecycleOwner) {
             it.run {
                 metricsCollector.append(it)
             }
         }
 
-        if (dataLogger.isRunning()) {
-            dataLogger.updateQuery(query)
+        if (DataLoggerRepository.isRunning()) {
+            withDataLogger {
+                updateQuery(query)
+            }
+
             renderingThread.start()
         }
 
-        attachToFloatingButton(activity, query)
+        configureActionButton(query)
         return root
     }
 }
diff --git a/automotive/src/main/java/org/obd/graphs/aa/CarSession.kt b/automotive/src/main/java/org/obd/graphs/aa/CarSession.kt
index 1b26be09..f4e6e641 100644
--- a/automotive/src/main/java/org/obd/graphs/aa/CarSession.kt
+++ b/automotive/src/main/java/org/obd/graphs/aa/CarSession.kt
@@ -23,6 +23,7 @@ import androidx.car.app.Session
 import org.obd.graphs.aa.screen.CarScreen
 import org.obd.graphs.aa.screen.CarScreenFactory
 import org.obd.graphs.bl.collector.MetricsCollector
+import org.obd.graphs.preferences.initPrefs
 import org.obd.graphs.renderer.Fps
 import org.obd.graphs.setCarContext
 
@@ -35,6 +36,7 @@ internal class CarSession : Session() {
 
     override fun onCreateScreen(intent: Intent): Screen {
         setCarContext(carContext)
+        initPrefs(carContext)
         screen = CarScreenFactory.instance(carContext, settings, metricsCollector, fps)
         return screen
     }
diff --git a/automotive/src/main/java/org/obd/graphs/aa/screen/CarScreen.kt b/automotive/src/main/java/org/obd/graphs/aa/screen/CarScreen.kt
index ad489e47..15d7c445 100644
--- a/automotive/src/main/java/org/obd/graphs/aa/screen/CarScreen.kt
+++ b/automotive/src/main/java/org/obd/graphs/aa/screen/CarScreen.kt
@@ -32,13 +32,12 @@ import org.obd.graphs.aa.screen.nav.CHANGE_SCREEN_EVENT
 import org.obd.graphs.aa.screen.nav.FeatureDescription
 import org.obd.graphs.aa.toast
 import org.obd.graphs.bl.collector.MetricsCollector
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.bl.datalogger.WorkflowStatus
-import org.obd.graphs.bl.datalogger.dataLogger
 import org.obd.graphs.renderer.Fps
 import org.obd.graphs.renderer.Identity
 import org.obd.graphs.sendBroadcastEvent
 
-
 const val GIULIA_VIRTUAL_SCREEN_1_SETTINGS_CHANGED = "pref.aa.pids.profile_1.event.changed"
 const val GIULIA_VIRTUAL_SCREEN_2_SETTINGS_CHANGED = "pref.aa.pids.profile_2.event.changed"
 const val GIULIA_VIRTUAL_SCREEN_3_SETTINGS_CHANGED = "pref.aa.pids.profile_3.event.changed"
@@ -50,10 +49,11 @@ internal abstract class CarScreen(
     carContext: CarContext,
     protected val settings: CarSettings,
     protected val metricsCollector: MetricsCollector,
-    protected val fps: Fps = Fps()
-) : Screen(carContext), DefaultLifecycleObserver {
-
+    protected val fps: Fps = Fps(),
+) : Screen(carContext),
+    DefaultLifecycleObserver {
     open fun getFeatureDescription(): List<FeatureDescription> = emptyList()
+
     abstract fun actionStartDataLogging()
 
     protected open fun gotoScreen(identity: Identity) {}
@@ -66,77 +66,91 @@ internal abstract class CarScreen(
 
     open fun onCarConfigurationChanged() {}
 
-    protected val renderingThread: RenderingThread = RenderingThread(
-        id = "CarScreenRenderingThread",
-        renderAction = {
-            renderAction()
-        },
-        perfFrameRate = {
-            settings.getSurfaceFrameRate()
-        }
-    )
+    protected val renderingThread: RenderingThread =
+        RenderingThread(
+            id = "CarScreenRenderingThread",
+            renderAction = {
+                renderAction()
+            },
+            perfFrameRate = {
+                settings.getSurfaceFrameRate()
+            },
+        )
 
     protected fun registerConnectionStateReceiver() {
         CarConnection(carContext).type.observe(this, ::onConnectionStateUpdated)
     }
 
-
     protected fun actionStopDataLogging() {
         Log.i(LOG_TAG, "Stopping data logging process")
-        dataLogger.stop()
+        withDataLogger {
+            stop()
+        }
         cancelRenderingTask()
     }
 
     protected open fun getHorizontalActionStrip(
         preferencesEnabled: Boolean = true,
         exitEnabled: Boolean = true,
-        featureListsEnabledSetting: Boolean = true
+        featureListsEnabledSetting: Boolean = true,
     ): ActionStrip {
         var builder = ActionStrip.Builder()
 
-        builder = if (dataLogger.status() == WorkflowStatus.Connecting || dataLogger.status() == WorkflowStatus.Connected) {
-            builder.addAction(
-                createAction(
-                    carContext,
-                    R.drawable.action_disconnect,
-                    mapColor(settings.getColorTheme().actionsBtnDisconnectColor)
-                ) {
-                    actionStopDataLogging()
-                    toast.show(carContext, R.string.toast_connection_disconnect)
-                })
-        } else {
-            builder.addAction(
-                createAction(
-                    carContext,
-                    R.drawable.actions_connect,
-                    mapColor(settings.getColorTheme().actionsBtnConnectColor)
-                ) {
-                    actionStartDataLogging()
-                })
-        }
+        builder =
+            if (DataLoggerRepository.status() == WorkflowStatus.Connecting || DataLoggerRepository.status() == WorkflowStatus.Connected) {
+                builder.addAction(
+                    createAction(
+                        carContext,
+                        R.drawable.action_disconnect,
+                        mapColor(settings.getColorTheme().actionsBtnDisconnectColor),
+                    ) {
+                        actionStopDataLogging()
+                        toast.show(carContext, R.string.toast_connection_disconnect)
+                    },
+                )
+            } else {
+                builder.addAction(
+                    createAction(
+                        carContext,
+                        R.drawable.actions_connect,
+                        mapColor(settings.getColorTheme().actionsBtnConnectColor),
+                    ) {
+                        actionStartDataLogging()
+                    },
+                )
+            }
 
         if (featureListsEnabledSetting) {
-            builder = builder.addAction(createAction(carContext, android.R.drawable.ic_dialog_dialer, CarColor.BLUE) {
-                sendBroadcastEvent(CHANGE_SCREEN_EVENT)
-            })
+            builder =
+                builder.addAction(
+                    createAction(carContext, android.R.drawable.ic_dialog_dialer, CarColor.BLUE) {
+                        sendBroadcastEvent(CHANGE_SCREEN_EVENT)
+                    },
+                )
         }
 
         if (preferencesEnabled) {
-            builder = builder.addAction(createAction(carContext, R.drawable.config, CarColor.BLUE) {
-                sendBroadcastEvent(AA_EDIT_PREF_SCREEN)
-                toast.show(carContext, R.string.pref_aa_get_to_app_conf)
-            })
+            builder =
+                builder.addAction(
+                    createAction(carContext, R.drawable.config, CarColor.BLUE) {
+                        sendBroadcastEvent(AA_EDIT_PREF_SCREEN)
+                        toast.show(carContext, R.string.pref_aa_get_to_app_conf)
+                    },
+                )
         }
 
         if (exitEnabled) {
-            builder = builder.addAction(createAction(carContext, R.drawable.action_exit, CarColor.RED) {
-                try {
-                    actionStopDataLogging()
-                } finally {
-                    Log.i(LOG_TAG, "Exiting the app. Closing the context")
-                    carContext.finishCarApp()
-                }
-            })
+            builder =
+                builder.addAction(
+                    createAction(carContext, R.drawable.action_exit, CarColor.RED) {
+                        try {
+                            actionStopDataLogging()
+                        } finally {
+                            Log.i(LOG_TAG, "Exiting the app. Closing the context")
+                            carContext.finishCarApp()
+                        }
+                    },
+                )
         }
 
         return builder.build()
@@ -148,7 +162,7 @@ internal abstract class CarScreen(
     }
 
     protected fun submitRenderingTask() {
-        if (!renderingThread.isRunning() && dataLogger.status() == WorkflowStatus.Connected) {
+        if (!renderingThread.isRunning() && DataLoggerRepository.status() == WorkflowStatus.Connected) {
             renderingThread.start()
             fps.start()
         }
@@ -158,12 +172,12 @@ internal abstract class CarScreen(
         when (connectionState) {
             CarConnection.CONNECTION_TYPE_PROJECTION -> {
                 if (settings.isLoadLastVisitedScreenEnabled()) {
-                    Log.i(LOG_TAG,"Load last visited screen flag is enabled. Loading last visited screen....")
+                    Log.i(LOG_TAG, "Load last visited screen flag is enabled. Loading last visited screen....")
                     gotoScreen(settings.getLastVisitedScreen())
                 }
 
-                if (settings.isAutomaticConnectEnabled() && !dataLogger.isRunning()) {
-                    Log.i(LOG_TAG,"Auto connection enabled. Auto start data logging.....")
+                if (settings.isAutomaticConnectEnabled() && !DataLoggerRepository.isRunning()) {
+                    Log.i(LOG_TAG, "Auto connection enabled. Auto start data logging.....")
                     actionStartDataLogging()
                 }
             }
diff --git a/automotive/src/main/java/org/obd/graphs/aa/screen/Extensions.kt b/automotive/src/main/java/org/obd/graphs/aa/screen/Extensions.kt
new file mode 100644
index 00000000..ce238b76
--- /dev/null
+++ b/automotive/src/main/java/org/obd/graphs/aa/screen/Extensions.kt
@@ -0,0 +1,25 @@
+ /**
+ * Copyright 2019-2026, Tomasz Żebrowski
+ *
+ * <p>Licensed to the Apache Software Foundation (ASF) under one or more contributor license
+ * agreements. See the NOTICE file distributed with this work for additional information regarding
+ * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License. You may obtain a
+ * copy of the License at
+ *
+ * <p>http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * <p>Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.obd.graphs.aa.screen
+
+import androidx.car.app.Screen
+import org.obd.graphs.bl.datalogger.DataLoggerService
+
+fun Screen.withDataLogger(action: DataLoggerService.() -> Unit) {
+    org.obd.graphs.bl.datalogger
+        .withDataLogger(carContext, action)
+}
diff --git a/automotive/src/main/java/org/obd/graphs/aa/screen/iot/IotTemplateCarScreen.kt b/automotive/src/main/java/org/obd/graphs/aa/screen/iot/IotTemplateCarScreen.kt
index 11bb122f..589958cf 100644
--- a/automotive/src/main/java/org/obd/graphs/aa/screen/iot/IotTemplateCarScreen.kt
+++ b/automotive/src/main/java/org/obd/graphs/aa/screen/iot/IotTemplateCarScreen.kt
@@ -22,130 +22,162 @@ import android.content.Intent
 import android.text.SpannableString
 import android.util.Log
 import androidx.car.app.CarContext
-import androidx.car.app.model.*
+import androidx.car.app.model.Action
+import androidx.car.app.model.GridTemplate
 import androidx.car.app.model.Metadata
+import androidx.car.app.model.Pane
+import androidx.car.app.model.PaneTemplate
+import androidx.car.app.model.Row
+import androidx.car.app.model.Template
 import androidx.lifecycle.LifecycleOwner
-import org.obd.graphs.*
-import org.obd.graphs.aa.*
+import org.obd.graphs.AA_VIRTUAL_SCREEN_RENDERER_CHANGED_EVENT
+import org.obd.graphs.MAIN_ACTIVITY_EVENT_DESTROYED
+import org.obd.graphs.MAIN_ACTIVITY_EVENT_PAUSE
+import org.obd.graphs.SCREEN_REFRESH_EVENT
 import org.obd.graphs.aa.CarSettings
+import org.obd.graphs.aa.R
 import org.obd.graphs.aa.mapColor
-import org.obd.graphs.aa.screen.*
 import org.obd.graphs.aa.screen.CarScreen
+import org.obd.graphs.aa.screen.EVENT_DYNAMIC_SELECTOR_MODE_ECO
+import org.obd.graphs.aa.screen.EVENT_DYNAMIC_SELECTOR_MODE_NORMAL
+import org.obd.graphs.aa.screen.EVENT_DYNAMIC_SELECTOR_MODE_RACE
+import org.obd.graphs.aa.screen.EVENT_DYNAMIC_SELECTOR_MODE_SPORT
+import org.obd.graphs.aa.screen.GIULIA_VIRTUAL_SCREEN_1_SETTINGS_CHANGED
+import org.obd.graphs.aa.screen.GIULIA_VIRTUAL_SCREEN_2_SETTINGS_CHANGED
+import org.obd.graphs.aa.screen.GIULIA_VIRTUAL_SCREEN_3_SETTINGS_CHANGED
+import org.obd.graphs.aa.screen.GIULIA_VIRTUAL_SCREEN_4_SETTINGS_CHANGED
+import org.obd.graphs.aa.screen.createAction
+import org.obd.graphs.aa.screen.dynamicSelectorModeEventBroadcaster
+import org.obd.graphs.aa.screen.withDataLogger
 import org.obd.graphs.aa.toast
 import org.obd.graphs.bl.collector.Metric
 import org.obd.graphs.bl.collector.MetricsCollector
-import org.obd.graphs.bl.datalogger.*
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_ADAPTER_NOT_SET_EVENT
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_CONNECTED_EVENT
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_CONNECTING_EVENT
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_ERROR_CONNECT_EVENT
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_ERROR_EVENT
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_NO_NETWORK_EVENT
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_STOPPED_EVENT
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
+import org.obd.graphs.bl.datalogger.WorkflowStatus
+import org.obd.graphs.bl.datalogger.dataLoggerSettings
 import org.obd.graphs.bl.query.Query
 import org.obd.graphs.bl.query.QueryStrategyType
 import org.obd.graphs.format
 import org.obd.graphs.profile.PROFILE_CHANGED_EVENT
+import org.obd.graphs.registerReceiver
 import org.obd.graphs.renderer.DynamicSelectorMode
 
 private const val LOG_TAG = "IotTemplateCarScreen"
+
 internal class IotTemplateCarScreen(
     carContext: CarContext,
     settings: CarSettings,
     metricsCollector: MetricsCollector,
 ) : CarScreen(carContext, settings, metricsCollector) {
-
     private val valueDrawable = ValueDrawable(carContext)
     private val query = Query.instance(QueryStrategyType.INDIVIDUAL_QUERY)
 
-    private var broadcastReceiver = object : BroadcastReceiver() {
-        override fun onReceive(context: Context?, intent: Intent?) {
+    private var broadcastReceiver =
+        object : BroadcastReceiver() {
+            override fun onReceive(
+                context: Context?,
+                intent: Intent?,
+            ) {
+                when (intent?.action) {
+                    EVENT_DYNAMIC_SELECTOR_MODE_NORMAL -> settings.dynamicSelectorChangedEvent(DynamicSelectorMode.NORMAL)
+                    EVENT_DYNAMIC_SELECTOR_MODE_RACE -> settings.dynamicSelectorChangedEvent(DynamicSelectorMode.RACE)
+                    EVENT_DYNAMIC_SELECTOR_MODE_ECO -> settings.dynamicSelectorChangedEvent(DynamicSelectorMode.ECO)
+                    EVENT_DYNAMIC_SELECTOR_MODE_SPORT -> settings.dynamicSelectorChangedEvent(DynamicSelectorMode.SPORT)
+
+                    SCREEN_REFRESH_EVENT -> invalidate()
+
+                    MAIN_ACTIVITY_EVENT_DESTROYED -> {
+                        Log.v(LOG_TAG, "Main activity has been destroyed.")
+                        invalidate()
+                    }
 
-            when (intent?.action) {
-                EVENT_DYNAMIC_SELECTOR_MODE_NORMAL -> settings.dynamicSelectorChangedEvent(DynamicSelectorMode.NORMAL)
-                EVENT_DYNAMIC_SELECTOR_MODE_RACE -> settings.dynamicSelectorChangedEvent(DynamicSelectorMode.RACE)
-                EVENT_DYNAMIC_SELECTOR_MODE_ECO -> settings.dynamicSelectorChangedEvent(DynamicSelectorMode.ECO)
-                EVENT_DYNAMIC_SELECTOR_MODE_SPORT -> settings.dynamicSelectorChangedEvent(DynamicSelectorMode.SPORT)
+                    MAIN_ACTIVITY_EVENT_PAUSE -> {
+                        Log.v(LOG_TAG, "Main activity is going to the background.")
+                        invalidate()
+                    }
 
-                SCREEN_REFRESH_EVENT -> invalidate()
+                    GIULIA_VIRTUAL_SCREEN_1_SETTINGS_CHANGED -> {
+                        if (settings.getGiuliaRendererSetting().getVirtualScreen() == 1) {
+                            settings.getGiuliaRendererSetting().setVirtualScreen(1)
+                            applyMetricsFilter()
+                            invalidate()
+                        }
+                    }
 
-                MAIN_ACTIVITY_EVENT_DESTROYED -> {
-                    Log.v(LOG_TAG, "Main activity has been destroyed.")
-                    invalidate()
-                }
-                MAIN_ACTIVITY_EVENT_PAUSE -> {
-                    Log.v(LOG_TAG, "Main activity is going to the background.")
-                    invalidate()
-                }
+                    GIULIA_VIRTUAL_SCREEN_2_SETTINGS_CHANGED -> {
+                        if (settings.getGiuliaRendererSetting().getVirtualScreen() == 2) {
+                            settings.getGiuliaRendererSetting().setVirtualScreen(2)
+                            applyMetricsFilter()
+                            invalidate()
+                        }
+                    }
 
-                GIULIA_VIRTUAL_SCREEN_1_SETTINGS_CHANGED -> {
-                    if (settings.getGiuliaRendererSetting().getVirtualScreen() == 1) {
-                        settings.getGiuliaRendererSetting().setVirtualScreen(1)
-                        applyMetricsFilter()
-                        invalidate()
+                    GIULIA_VIRTUAL_SCREEN_3_SETTINGS_CHANGED -> {
+                        if (settings.getGiuliaRendererSetting().getVirtualScreen() == 3) {
+                            settings.getGiuliaRendererSetting().setVirtualScreen(3)
+                            applyMetricsFilter()
+                            invalidate()
+                        }
                     }
-                }
 
-                GIULIA_VIRTUAL_SCREEN_2_SETTINGS_CHANGED -> {
-                    if (settings.getGiuliaRendererSetting().getVirtualScreen() == 2) {
-                        settings.getGiuliaRendererSetting().setVirtualScreen(2)
-                        applyMetricsFilter()
-                        invalidate()
+                    GIULIA_VIRTUAL_SCREEN_4_SETTINGS_CHANGED -> {
+                        if (settings.getGiuliaRendererSetting().getVirtualScreen() == 4) {
+                            settings.getGiuliaRendererSetting().setVirtualScreen(4)
+                            applyMetricsFilter()
+                            invalidate()
+                        }
                     }
-                }
 
-                GIULIA_VIRTUAL_SCREEN_3_SETTINGS_CHANGED -> {
-                    if (settings.getGiuliaRendererSetting().getVirtualScreen() == 3) {
-                        settings.getGiuliaRendererSetting().setVirtualScreen(3)
+                    PROFILE_CHANGED_EVENT -> {
                         applyMetricsFilter()
                         invalidate()
                     }
-                }
 
-                GIULIA_VIRTUAL_SCREEN_4_SETTINGS_CHANGED -> {
-                    if (settings.getGiuliaRendererSetting().getVirtualScreen() == 4) {
-                        settings.getGiuliaRendererSetting().setVirtualScreen(4)
-                        applyMetricsFilter()
+                    DATA_LOGGER_CONNECTING_EVENT -> {
                         invalidate()
+                        metricsCollector.reset()
                     }
-                }
-
-                PROFILE_CHANGED_EVENT -> {
-                    applyMetricsFilter()
-                    invalidate()
-                }
-
-                DATA_LOGGER_CONNECTING_EVENT -> {
-                    invalidate()
-                    metricsCollector.reset()
-                }
 
-                DATA_LOGGER_NO_NETWORK_EVENT -> {
-                    toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_connection_no_network)
-                }
+                    DATA_LOGGER_NO_NETWORK_EVENT -> {
+                        toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_connection_no_network)
+                    }
 
-                DATA_LOGGER_ERROR_EVENT -> {
-                    invalidate()
-                    toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_connection_error)
-                }
+                    DATA_LOGGER_ERROR_EVENT -> {
+                        invalidate()
+                        toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_connection_error)
+                    }
 
-                DATA_LOGGER_STOPPED_EVENT -> {
-                    toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_connection_stopped)
-                    renderingThread.stop()
-                    invalidate()
-                }
+                    DATA_LOGGER_STOPPED_EVENT -> {
+                        toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_connection_stopped)
+                        renderingThread.stop()
+                        invalidate()
+                    }
 
-                DATA_LOGGER_CONNECTED_EVENT -> {
-                    toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_connection_established)
-                    renderingThread.start()
-                    invalidate()
-                }
+                    DATA_LOGGER_CONNECTED_EVENT -> {
+                        toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_connection_established)
+                        renderingThread.start()
+                        invalidate()
+                    }
 
-                DATA_LOGGER_ERROR_CONNECT_EVENT -> {
-                    invalidate()
-                    toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_connection_connect_error)
-                }
+                    DATA_LOGGER_ERROR_CONNECT_EVENT -> {
+                        invalidate()
+                        toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_connection_connect_error)
+                    }
 
-                DATA_LOGGER_ADAPTER_NOT_SET_EVENT -> {
-                    invalidate()
-                    toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_adapter_is_not_selected)
+                    DATA_LOGGER_ADAPTER_NOT_SET_EVENT -> {
+                        invalidate()
+                        toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_adapter_is_not_selected)
+                    }
                 }
             }
         }
-    }
 
     override fun onCreate(owner: LifecycleOwner) {
         super.onCreate(owner)
@@ -182,8 +214,12 @@ internal class IotTemplateCarScreen(
         } else {
             query.setStrategy(QueryStrategyType.SHARED_QUERY)
         }
-        dataLogger.start(query)
+
+        withDataLogger {
+            start(query)
+        }
     }
+
     override fun renderAction() {
         invalidate()
     }
@@ -194,67 +230,81 @@ internal class IotTemplateCarScreen(
     }
 
     override fun onGetTemplate(): Template =
-            if (dataLogger.status() == WorkflowStatus.Connecting) {
-                GridTemplate.Builder()
-                    .setTitle(carContext.resources.getString(R.string.app_name))
-                    .setLoading(true)
-                    .setActionStrip(getHorizontalActionStrip(preferencesEnabled = false))
-                    .setHeaderAction(Action.APP_ICON)
-                    .build()
-            } else {
-
-                applyMetricsFilter()
-                var paneBuilder = Pane.Builder()
-
-                paneBuilder = paneBuilder.addAction(createAction(carContext,
-                    R.drawable.action_virtual_screen_1,
-                    mapColor(settings.getColorTheme().actionsBtnVirtualScreensColor)
-                ) {
-
-                    settings.getGiuliaRendererSetting().setVirtualScreen(1)
-                    applyMetricsFilter()
-                    invalidate()
-                })
-
-                paneBuilder = paneBuilder.addAction(createAction(carContext,
-                    R.drawable.action_virtual_screen_2,
-                    mapColor(settings.getColorTheme().actionsBtnVirtualScreensColor)
-                ) {
-
-                    settings.getGiuliaRendererSetting().setVirtualScreen(2)
-                    applyMetricsFilter()
-                    invalidate()
-                })
-
-                metricsCollector.getMetrics().forEach {
-                    paneBuilder.addRow(
-                        Row.Builder()
-                        .setImage(valueDrawable.draw(it.source.format(castToInt = false),settings.getColorTheme().progressColor),
-                            Row.IMAGE_TYPE_LARGE
-                        )
-                        .setMetadata(Metadata.Builder().build())
+        if (DataLoggerRepository.status() == WorkflowStatus.Connecting) {
+            GridTemplate
+                .Builder()
+                .setTitle(carContext.resources.getString(R.string.app_name))
+                .setLoading(true)
+                .setActionStrip(getHorizontalActionStrip(preferencesEnabled = false))
+                .setHeaderAction(Action.APP_ICON)
+                .build()
+        } else {
+            applyMetricsFilter()
+            var paneBuilder = Pane.Builder()
+
+            paneBuilder =
+                paneBuilder.addAction(
+                    createAction(
+                        carContext,
+                        R.drawable.action_virtual_screen_1,
+                        mapColor(settings.getColorTheme().actionsBtnVirtualScreensColor),
+                    ) {
+                        settings.getGiuliaRendererSetting().setVirtualScreen(1)
+                        applyMetricsFilter()
+                        invalidate()
+                    },
+                )
+
+            paneBuilder =
+                paneBuilder.addAction(
+                    createAction(
+                        carContext,
+                        R.drawable.action_virtual_screen_2,
+                        mapColor(settings.getColorTheme().actionsBtnVirtualScreensColor),
+                    ) {
+                        settings.getGiuliaRendererSetting().setVirtualScreen(2)
+                        applyMetricsFilter()
+                        invalidate()
+                    },
+                )
+
+            metricsCollector.getMetrics().forEach {
+                paneBuilder.addRow(
+                    Row
+                        .Builder()
+                        .setImage(
+                            valueDrawable.draw(it.source.format(castToInt = false), settings.getColorTheme().progressColor),
+                            Row.IMAGE_TYPE_LARGE,
+                        ).setMetadata(Metadata.Builder().build())
                         .setTitle(getTitleFor(it))
-                        .build())
-                }
-
-                PaneTemplate.Builder(paneBuilder.build())
-                    .setTitle(carContext.resources.getString(R.string.app_name))
-                    .setActionStrip(getHorizontalActionStrip(preferencesEnabled = false))
-                    .build()
+                        .build(),
+                )
             }
 
+            PaneTemplate
+                .Builder(paneBuilder.build())
+                .setTitle(carContext.resources.getString(R.string.app_name))
+                .setActionStrip(getHorizontalActionStrip(preferencesEnabled = false))
+                .build()
+        }
+
     private fun applyMetricsFilter() {
         metricsCollector.applyFilter(settings.getGiuliaRendererSetting().selectedPIDs)
 
         if (dataLoggerSettings.instance().adapter.individualQueryStrategyEnabled) {
-            query.update(metricsCollector.getMetrics().map { p-> p.source.command.pid.id }.toSet())
-            dataLogger.updateQuery(query)
+            query.update(metricsCollector.getMetrics().map { p -> p.source.command.pid.id }.toSet())
+            withDataLogger {
+                updateQuery(query)
+            }
         }
     }
 
     private fun getTitleFor(metric: Metric): SpannableString {
         val title = StringBuilder()
-        title.append(metric.source.command.pid.description.replace("\n",""))
+        title.append(
+            metric.source.command.pid.description
+                .replace("\n", ""),
+        )
         title.append("\n")
         val pid = metric.pid()
         title.append("· min:${metric.min.format(pid)} avg: ${metric.mean.format(pid)} max: ${metric.max.format(pid)}")
@@ -264,10 +314,10 @@ internal class IotTemplateCarScreen(
     init {
         Log.i(LOG_TAG, "IotTemplate Screen Init")
         lifecycle.addObserver(this)
-        dataLogger.observe(this) {
+        DataLoggerRepository.observe(this) {
             metricsCollector.append(it)
         }
-        dataLogger.observe(dynamicSelectorModeEventBroadcaster)
+        DataLoggerRepository.observe(dynamicSelectorModeEventBroadcaster)
         submitRenderingTask()
         registerConnectionStateReceiver()
     }
diff --git a/automotive/src/main/java/org/obd/graphs/aa/screen/nav/AvailableFeaturesScreen.kt b/automotive/src/main/java/org/obd/graphs/aa/screen/nav/AvailableFeaturesScreen.kt
index 25b29b7f..01f04afb 100644
--- a/automotive/src/main/java/org/obd/graphs/aa/screen/nav/AvailableFeaturesScreen.kt
+++ b/automotive/src/main/java/org/obd/graphs/aa/screen/nav/AvailableFeaturesScreen.kt
@@ -36,7 +36,7 @@ internal class AvailableFeaturesScreen(
 ) : Screen(carContext) {
 
     override fun onGetTemplate(): Template  = try {
-        if (dataLogger.status() == WorkflowStatus.Connecting) {
+        if (DataLoggerRepository.status() == WorkflowStatus.Connecting) {
              ListTemplate.Builder()
                 .setHeaderAction(Action.BACK)
                 .setActionStrip(getHorizontalActionStrip())
diff --git a/automotive/src/main/java/org/obd/graphs/aa/screen/nav/NavTemplateCarScreen.kt b/automotive/src/main/java/org/obd/graphs/aa/screen/nav/NavTemplateCarScreen.kt
index 84fe9c16..9bd1e6c4 100644
--- a/automotive/src/main/java/org/obd/graphs/aa/screen/nav/NavTemplateCarScreen.kt
+++ b/automotive/src/main/java/org/obd/graphs/aa/screen/nav/NavTemplateCarScreen.kt
@@ -188,7 +188,9 @@ internal class NavTemplateCarScreen(
                 EVENT_VEHICLE_STATUS_IGNITION_OFF -> {
                     if (dataLoggerSettings.instance().vehicleStatusDisconnectWhenOff){
                         Log.i(LOG_TAG,"Received vehicle status OFF event. Closing the session.")
-                        dataLogger.stop()
+                        withDataLogger {
+                            stop()
+                        }
                     }
                 }
             }
@@ -284,7 +286,7 @@ internal class NavTemplateCarScreen(
     override fun onGetTemplate(): Template  = try {
         settings.initItemsSortOrder()
 
-        if (settings.isConnectionDialogEnabled() && dataLogger.status() == WorkflowStatus.Connecting) {
+        if (settings.isConnectionDialogEnabled() && DataLoggerRepository.status() == WorkflowStatus.Connecting) {
             NavigationTemplate.Builder()
                 .setNavigationInfo(RoutingInfo.Builder().setLoading(true).build())
                 .setActionStrip(getHorizontalActionStrip())
@@ -311,13 +313,13 @@ internal class NavTemplateCarScreen(
 
         lifecycle.addObserver(surfaceRendererScreen.getLifecycleObserver())
 
-        dataLogger.observe(this) {
+        DataLoggerRepository.observe(this) {
             metricsCollector.append(it, forceAppend = false)
         }
 
-        dataLogger.observe(dynamicSelectorModeEventBroadcaster)
+        DataLoggerRepository.observe(dynamicSelectorModeEventBroadcaster)
 
-        dataLogger
+        DataLoggerRepository
             .observe(dragRacingMetricsProcessor)
             .observe(tripManager)
             .observe(vehicleStatusMetricsProcessor)
diff --git a/automotive/src/main/java/org/obd/graphs/aa/screen/nav/RoutinesScreen.kt b/automotive/src/main/java/org/obd/graphs/aa/screen/nav/RoutinesScreen.kt
index 2b826499..e4783db6 100644
--- a/automotive/src/main/java/org/obd/graphs/aa/screen/nav/RoutinesScreen.kt
+++ b/automotive/src/main/java/org/obd/graphs/aa/screen/nav/RoutinesScreen.kt
@@ -21,7 +21,16 @@ import android.content.Context
 import android.content.Intent
 import android.util.Log
 import androidx.car.app.CarContext
-import androidx.car.app.model.*
+import androidx.car.app.model.Action
+import androidx.car.app.model.ActionStrip
+import androidx.car.app.model.CarColor
+import androidx.car.app.model.CarIcon
+import androidx.car.app.model.ItemList
+import androidx.car.app.model.ListTemplate
+import androidx.car.app.model.Pane
+import androidx.car.app.model.PaneTemplate
+import androidx.car.app.model.Row
+import androidx.car.app.model.Template
 import androidx.core.graphics.drawable.IconCompat
 import androidx.lifecycle.LifecycleOwner
 import org.obd.graphs.aa.CarSettings
@@ -29,9 +38,24 @@ import org.obd.graphs.aa.R
 import org.obd.graphs.aa.mapColor
 import org.obd.graphs.aa.screen.CarScreen
 import org.obd.graphs.aa.screen.createAction
+import org.obd.graphs.aa.screen.withDataLogger
 import org.obd.graphs.aa.toast
 import org.obd.graphs.bl.collector.MetricsCollector
-import org.obd.graphs.bl.datalogger.*
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_ADAPTER_NOT_SET_EVENT
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_CONNECTED_EVENT
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_CONNECTING_EVENT
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_ERROR_CONNECT_EVENT
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_ERROR_EVENT
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_NO_NETWORK_EVENT
+import org.obd.graphs.bl.datalogger.DATA_LOGGER_STOPPED_EVENT
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
+import org.obd.graphs.bl.datalogger.ROUTINE_EXECUTED_SUCCESSFULLY_EVENT
+import org.obd.graphs.bl.datalogger.ROUTINE_EXECUTION_FAILED_EVENT
+import org.obd.graphs.bl.datalogger.ROUTINE_EXECUTION_NO_DATA_RECEIVED_EVENT
+import org.obd.graphs.bl.datalogger.ROUTINE_REJECTED_EVENT
+import org.obd.graphs.bl.datalogger.ROUTINE_UNKNOWN_STATUS_EVENT
+import org.obd.graphs.bl.datalogger.ROUTINE_WORKFLOW_NOT_RUNNING_EVENT
+import org.obd.graphs.bl.datalogger.WorkflowStatus
 import org.obd.graphs.bl.query.Query
 import org.obd.graphs.bl.query.QueryStrategyType
 import org.obd.graphs.registerReceiver
@@ -40,9 +64,11 @@ import org.obd.graphs.renderer.Identity
 import org.obd.metrics.pid.PIDsGroup
 import org.obd.metrics.pid.PidDefinition
 
-
-private enum class RoutineScreen(private val code: Int): Identity {
-    ROUTINES(222);
+private enum class RoutineScreen(
+    private val code: Int,
+) : Identity {
+    ROUTINES(222),
+    ;
 
     override fun id(): Int = this.code
 }
@@ -53,92 +79,108 @@ internal class RoutinesScreen(
     carContext: CarContext,
     settings: CarSettings,
     metricsCollector: MetricsCollector,
-    fps: Fps
+    fps: Fps,
 ) : CarScreen(carContext, settings, metricsCollector, fps) {
     private var routineExecuting = false
     private var routineId = -1L
     private var routineExecutionSuccessfully = false
     private val query: Query = Query.instance(QueryStrategyType.ROUTINES_QUERY)
 
-    private var broadcastReceiver = object : BroadcastReceiver() {
-        override fun onReceive(context: Context?, intent: Intent?) {
-            Log.i(LOG_TAG, "Received event=${intent?.action}")
-            try {
-                when (intent?.action) {
-                    ROUTINE_WORKFLOW_NOT_RUNNING_EVENT -> {
-                        toast.show(carContext, R.string.routine_workflow_is_not_running)
-                        routineExecuting = false
-                        routineExecutionSuccessfully = false
-                        invalidate()
-                    }
-                    ROUTINE_UNKNOWN_STATUS_EVENT -> {
-                        toast.show(carContext, R.string.routine_unknown_error)
-                        routineExecuting = false
-                        routineExecutionSuccessfully = false
-                        invalidate()
-                    }
-                    ROUTINE_EXECUTION_FAILED_EVENT -> {
-                        routineExecuting = false
-                        routineExecutionSuccessfully = false
-                        invalidate()
-                        toast.show(carContext, R.string.routine_execution_failed)
-                    }
+    private var broadcastReceiver =
+        object : BroadcastReceiver() {
+            override fun onReceive(
+                context: Context?,
+                intent: Intent?,
+            ) {
+                Log.i(LOG_TAG, "Received event=${intent?.action}")
+                try {
+                    when (intent?.action) {
+                        ROUTINE_WORKFLOW_NOT_RUNNING_EVENT -> {
+                            toast.show(carContext, R.string.routine_workflow_is_not_running)
+                            routineExecuting = false
+                            routineExecutionSuccessfully = false
+                            invalidate()
+                        }
 
-                    ROUTINE_EXECUTED_SUCCESSFULLY_EVENT -> {
-                        toast.show(carContext, R.string.routine_executed_successfully)
-                        routineExecuting = false
-                        routineExecutionSuccessfully = true
-                        invalidate()
-                    }
+                        ROUTINE_UNKNOWN_STATUS_EVENT -> {
+                            toast.show(carContext, R.string.routine_unknown_error)
+                            routineExecuting = false
+                            routineExecutionSuccessfully = false
+                            invalidate()
+                        }
 
-                    ROUTINE_EXECUTION_NO_DATA_RECEIVED_EVENT -> {
-                        routineExecuting = false
-                        routineExecutionSuccessfully = false
-                        invalidate()
-                        toast.show(carContext, R.string.routine_no_data)
-                    }
+                        ROUTINE_EXECUTION_FAILED_EVENT -> {
+                            routineExecuting = false
+                            routineExecutionSuccessfully = false
+                            invalidate()
+                            toast.show(carContext, R.string.routine_execution_failed)
+                        }
 
-                    DATA_LOGGER_CONNECTING_EVENT -> invalidate()
+                        ROUTINE_EXECUTED_SUCCESSFULLY_EVENT -> {
+                            toast.show(carContext, R.string.routine_executed_successfully)
+                            routineExecuting = false
+                            routineExecutionSuccessfully = true
+                            invalidate()
+                        }
 
-                    DATA_LOGGER_NO_NETWORK_EVENT -> toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_connection_no_network)
-                    DATA_LOGGER_ERROR_EVENT -> {
-                        invalidate()
-                        toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_connection_error)
-                    }
+                        ROUTINE_EXECUTION_NO_DATA_RECEIVED_EVENT -> {
+                            routineExecuting = false
+                            routineExecutionSuccessfully = false
+                            invalidate()
+                            toast.show(carContext, R.string.routine_no_data)
+                        }
 
-                    DATA_LOGGER_STOPPED_EVENT -> {
-                        toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_connection_stopped)
-                        invalidate()
-                    }
+                        DATA_LOGGER_CONNECTING_EVENT -> invalidate()
 
-                    DATA_LOGGER_CONNECTED_EVENT -> {
-                        toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_connection_established)
-                        invalidate()
-                    }
+                        DATA_LOGGER_NO_NETWORK_EVENT ->
+                            toast.show(
+                                carContext,
+                                org.obd.graphs.commons.R.string.main_activity_toast_connection_no_network,
+                            )
 
-                    DATA_LOGGER_ERROR_CONNECT_EVENT -> {
-                        invalidate()
-                        toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_connection_connect_error)
-                    }
+                        DATA_LOGGER_ERROR_EVENT -> {
+                            invalidate()
+                            toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_connection_error)
+                        }
+
+                        DATA_LOGGER_STOPPED_EVENT -> {
+                            toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_connection_stopped)
+                            invalidate()
+                        }
+
+                        DATA_LOGGER_CONNECTED_EVENT -> {
+                            toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_connection_established)
+                            invalidate()
+                        }
 
-                    DATA_LOGGER_ADAPTER_NOT_SET_EVENT -> {
-                        invalidate()
-                        toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_adapter_is_not_selected)
+                        DATA_LOGGER_ERROR_CONNECT_EVENT -> {
+                            invalidate()
+                            toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_connection_connect_error)
+                        }
+
+                        DATA_LOGGER_ADAPTER_NOT_SET_EVENT -> {
+                            invalidate()
+                            toast.show(carContext, org.obd.graphs.commons.R.string.main_activity_toast_adapter_is_not_selected)
+                        }
                     }
+                } catch (e: Exception) {
+                    Log.w(LOG_TAG, "Failed event ${intent?.action} processing", e)
                 }
-            } catch (e: Exception) {
-                Log.w(LOG_TAG, "Failed event ${intent?.action} processing", e)
             }
         }
-    }
 
-    override fun getFeatureDescription(): List<FeatureDescription>  = mutableListOf<FeatureDescription>().apply {
-        if (settings.getRoutinesScreenSettings().viewEnabled) {
-            add(FeatureDescription( RoutineScreen.ROUTINES,
-                R.drawable.action_features,
-                carContext.getString(R.string.available_features_routine_screen_title)))
+    override fun getFeatureDescription(): List<FeatureDescription> =
+        mutableListOf<FeatureDescription>().apply {
+            if (settings.getRoutinesScreenSettings().viewEnabled) {
+                add(
+                    FeatureDescription(
+                        RoutineScreen.ROUTINES,
+                        R.drawable.action_features,
+                        carContext.getString(R.string.available_features_routine_screen_title),
+                    ),
+                )
+            }
         }
-    }
 
     override fun onResume(owner: LifecycleOwner) {
         super.onResume(owner)
@@ -165,84 +207,101 @@ internal class RoutinesScreen(
         carContext.unregisterReceiver(broadcastReceiver)
     }
 
-    override fun actionStartDataLogging(){
-        dataLogger.start(query)
+    override fun actionStartDataLogging() {
+        withDataLogger {
+            start(query)
+        }
     }
 
+    override fun onGetTemplate(): Template =
+        try {
+            if (routineExecuting) {
+                ListTemplate
+                    .Builder()
+                    .setLoading(true)
+                    .setTitle(carContext.getString(R.string.routine_execution_start))
+                    .setActionStrip(getHorizontalActionStrip())
+                    .build()
+            } else if (DataLoggerRepository.status() == WorkflowStatus.Connecting) {
+                ListTemplate
+                    .Builder()
+                    .setLoading(true)
+                    .setTitle(carContext.getString(R.string.routine_page_connecting))
+                    .setActionStrip(getHorizontalActionStrip())
+                    .build()
+            } else {
+                var items = ItemList.Builder()
+                DataLoggerRepository
+                    .getPidDefinitionRegistry()
+                    .findBy(PIDsGroup.ROUTINE)
+                    .sortedBy { it.description }
+                    .sortedBy { it.id != routineId }
+                    .forEach {
+                        items = items.addItem(buildItem(it))
+                    }
 
-    override fun onGetTemplate(): Template = try {
-        if (routineExecuting) {
-            ListTemplate.Builder()
-                .setLoading(true)
-                .setTitle(carContext.getString(R.string.routine_execution_start))
-                .setActionStrip(getHorizontalActionStrip()).build()
-        } else if (dataLogger.status() == WorkflowStatus.Connecting) {
-            ListTemplate.Builder()
-                .setLoading(true)
-                .setTitle(carContext.getString(R.string.routine_page_connecting))
-                .setActionStrip(getHorizontalActionStrip()).build()
-        } else {
-            var items = ItemList.Builder()
-            dataLogger.getPidDefinitionRegistry().findBy(PIDsGroup.ROUTINE)
-                .sortedBy { it.description }
-                .sortedBy { it.id != routineId }
-                .forEach {
-                    items = items.addItem(buildItem(it))
-                }
-
-            ListTemplate.Builder()
-                .setLoading(false)
-                .setTitle(carContext.getString(R.string.routine_page_title))
-                .setSingleList(items.build())
+                ListTemplate
+                    .Builder()
+                    .setLoading(false)
+                    .setTitle(carContext.getString(R.string.routine_page_title))
+                    .setSingleList(items.build())
+                    .setHeaderAction(Action.BACK)
+                    .setActionStrip(getHorizontalActionStrip())
+                    .build()
+            }
+        } catch (e: Exception) {
+            Log.e(LOG_TAG, "Failed to build template", e)
+            PaneTemplate
+                .Builder(Pane.Builder().setLoading(true).build())
                 .setHeaderAction(Action.BACK)
-                .setActionStrip(getHorizontalActionStrip())
+                .setTitle(carContext.getString(R.string.pref_aa_car_error))
                 .build()
         }
-    } catch (e: Exception) {
-        Log.e(LOG_TAG, "Failed to build template", e)
-        PaneTemplate.Builder(Pane.Builder().setLoading(true).build())
-            .setHeaderAction(Action.BACK)
-            .setTitle(carContext.getString(R.string.pref_aa_car_error))
-            .build()
-    }
 
     private fun buildItem(data: PidDefinition): Row {
-        var rowBuilder = Row.Builder()
-            .setOnClickListener {
-                Log.i(LOG_TAG, "Executing routine ${data.description}")
-
-                if (dataLogger.isRunning()) {
-                    routineExecuting = true
-                    routineId = data.id
-                } else {
-                    routineId = -1L
-                }
-                invalidate()
-                dataLogger.executeRoutine(Query.instance(QueryStrategyType.ROUTINES_QUERY).update(setOf(data.id)))
-            }
-            .setBrowsable(false)
+        var rowBuilder =
+            Row
+                .Builder()
+                .setOnClickListener {
+                    Log.i(LOG_TAG, "Executing routine ${data.description}")
 
-            .addText(data.longDescription ?: data.description)
-            .setTitle(data.description)
+                    if (DataLoggerRepository.isRunning()) {
+                        routineExecuting = true
+                        routineId = data.id
+                    } else {
+                        routineId = -1L
+                    }
+                    invalidate()
+                    withDataLogger {
+                        executeRoutine(Query.instance(QueryStrategyType.ROUTINES_QUERY).update(setOf(data.id)))
+                    }
+                }.setBrowsable(false)
+                .addText(data.longDescription ?: data.description)
+                .setTitle(data.description)
 
         if (data.id == routineId) {
-            rowBuilder = if (routineExecutionSuccessfully) {
-                rowBuilder.setImage(
-                    CarIcon.Builder(
-                        IconCompat.createWithResource(
-                            carContext, android.R.drawable.ic_input_add
-                        )
-                    ).build()
-                )
-            } else {
-                rowBuilder.setImage(
-                    CarIcon.Builder(
-                        IconCompat.createWithResource(
-                            carContext, android.R.drawable.ic_delete
-                        )
-                    ).build()
-                )
-            }
+            rowBuilder =
+                if (routineExecutionSuccessfully) {
+                    rowBuilder.setImage(
+                        CarIcon
+                            .Builder(
+                                IconCompat.createWithResource(
+                                    carContext,
+                                    android.R.drawable.ic_input_add,
+                                ),
+                            ).build(),
+                    )
+                } else {
+                    rowBuilder.setImage(
+                        CarIcon
+                            .Builder(
+                                IconCompat.createWithResource(
+                                    carContext,
+                                    android.R.drawable.ic_delete,
+                                ),
+                            ).build(),
+                    )
+                }
         }
         return rowBuilder.build()
     }
@@ -250,30 +309,43 @@ internal class RoutinesScreen(
     private fun getHorizontalActionStrip(): ActionStrip {
         var builder = ActionStrip.Builder()
 
-        builder = if (dataLogger.isRunning()) {
-            builder.addAction(
-                createAction(
-                    carContext,
-                    R.drawable.action_disconnect,
-                    mapColor(settings.getColorTheme().actionsBtnDisconnectColor)
-                ) {
-                    actionStopDataLogging()
-                    toast.show(carContext, R.string.toast_connection_disconnect)
-                })
-        } else {
-            builder.addAction(createAction(carContext, R.drawable.actions_connect, mapColor(settings.getColorTheme().actionsBtnConnectColor)) {
-                dataLogger.start(query)
-            })
-        }
-
-        builder = builder.addAction(createAction(carContext, R.drawable.action_exit, CarColor.RED) {
-            try {
-                actionStopDataLogging()
-            } finally {
-                Log.i(LOG_TAG, "Exiting the app. Closing the context")
-                carContext.finishCarApp()
+        builder =
+            if (DataLoggerRepository.isRunning()) {
+                builder.addAction(
+                    createAction(
+                        carContext,
+                        R.drawable.action_disconnect,
+                        mapColor(settings.getColorTheme().actionsBtnDisconnectColor),
+                    ) {
+                        actionStopDataLogging()
+                        toast.show(carContext, R.string.toast_connection_disconnect)
+                    },
+                )
+            } else {
+                builder.addAction(
+                    createAction(
+                        carContext,
+                        R.drawable.actions_connect,
+                        mapColor(settings.getColorTheme().actionsBtnConnectColor),
+                    ) {
+                        withDataLogger {
+                            start(query)
+                        }
+                    },
+                )
             }
-        })
+
+        builder =
+            builder.addAction(
+                createAction(carContext, R.drawable.action_exit, CarColor.RED) {
+                    try {
+                        actionStopDataLogging()
+                    } finally {
+                        Log.i(LOG_TAG, "Exiting the app. Closing the context")
+                        carContext.finishCarApp()
+                    }
+                },
+            )
 
         return builder.build()
     }
diff --git a/automotive/src/main/java/org/obd/graphs/aa/screen/nav/SurfaceRendererScreen.kt b/automotive/src/main/java/org/obd/graphs/aa/screen/nav/SurfaceRendererScreen.kt
index b27d2873..21e0a30b 100644
--- a/automotive/src/main/java/org/obd/graphs/aa/screen/nav/SurfaceRendererScreen.kt
+++ b/automotive/src/main/java/org/obd/graphs/aa/screen/nav/SurfaceRendererScreen.kt
@@ -26,19 +26,29 @@ import androidx.car.app.model.CarColor
 import androidx.car.app.model.Template
 import androidx.car.app.navigation.model.NavigationTemplate
 import androidx.lifecycle.LifecycleOwner
-import org.obd.graphs.*
-import org.obd.graphs.aa.*
-import org.obd.graphs.aa.screen.*
+import org.obd.graphs.AA_HIGH_FREQ_PID_SELECTION_CHANGED_EVENT
+import org.obd.graphs.AA_VIRTUAL_SCREEN_RENDERER_CHANGED_EVENT
+import org.obd.graphs.SCREEN_REFRESH_EVENT
+import org.obd.graphs.aa.CarSettings
+import org.obd.graphs.aa.R
+import org.obd.graphs.aa.mapColor
+import org.obd.graphs.aa.screen.CarScreen
+import org.obd.graphs.aa.screen.GIULIA_VIRTUAL_SCREEN_1_SETTINGS_CHANGED
+import org.obd.graphs.aa.screen.GIULIA_VIRTUAL_SCREEN_2_SETTINGS_CHANGED
+import org.obd.graphs.aa.screen.GIULIA_VIRTUAL_SCREEN_3_SETTINGS_CHANGED
+import org.obd.graphs.aa.screen.GIULIA_VIRTUAL_SCREEN_4_SETTINGS_CHANGED
+import org.obd.graphs.aa.screen.createAction
+import org.obd.graphs.aa.screen.withDataLogger
 import org.obd.graphs.bl.collector.MetricsCollector
-import org.obd.graphs.bl.datalogger.dataLogger
 import org.obd.graphs.bl.datalogger.dataLoggerSettings
 import org.obd.graphs.bl.query.Query
 import org.obd.graphs.bl.query.QueryStrategyType
 import org.obd.graphs.profile.PROFILE_CHANGED_EVENT
 import org.obd.graphs.profile.PROFILE_RESET_EVENT
+import org.obd.graphs.registerReceiver
 import org.obd.graphs.renderer.Fps
-import org.obd.graphs.renderer.SurfaceRendererType
 import org.obd.graphs.renderer.Identity
+import org.obd.graphs.renderer.SurfaceRendererType
 
 const val GAUGE_VIRTUAL_SCREEN_1_SETTINGS_CHANGED = "pref.aa.gauge.pids.profile_1.event.changed"
 const val GAUGE_VIRTUAL_SCREEN_2_SETTINGS_CHANGED = "pref.aa.gauge.pids.profile_2.event.changed"
@@ -48,12 +58,13 @@ const val GAUGE_VIRTUAL_SCREEN_4_SETTINGS_CHANGED = "pref.aa.gauge.pids.profile_
 private const val AA_TRIP_INFO_PID_SELECTION_CHANGED_EVENT = "pref.aa.trip_info.pids.selected.event.changed"
 private const val AA_PERFORMANCE_PID_SELECTION_CHANGED_EVENT = "pref.aa.performance.pids.selected.event.changed"
 
-private enum class DefaultScreen(private val code: Int): Identity {
-    NOT_SET(-1);
+private enum class DefaultScreen(
+    private val code: Int,
+) : Identity {
+    NOT_SET(-1),
+    ;
 
-    override fun id(): Int {
-        return this.code
-    }
+    override fun id(): Int = this.code
 }
 
 private const val LOW_FREQ_PID_SELECTION_CHANGED_EVENT = "pref.pids.generic.low.event.changed"
@@ -64,83 +75,83 @@ internal class SurfaceRendererScreen(
     settings: CarSettings,
     metricsCollector: MetricsCollector,
     fps: Fps,
-    private val parent: NavTemplateCarScreen
+    private val parent: NavTemplateCarScreen,
 ) : CarScreen(carContext, settings, metricsCollector, fps) {
-
     private val query = Query.instance()
 
-    private var screenId : Identity = SurfaceRendererType.GIULIA
+    private var screenId: Identity = SurfaceRendererType.GIULIA
     private val surfaceRendererController = SurfaceRendererController(carContext, settings, metricsCollector, fps, query)
 
-    private var broadcastReceiver = object : BroadcastReceiver() {
-        override fun onReceive(context: Context?, intent: Intent?) {
-
-            when (intent?.action) {
-                AA_VIRTUAL_SCREEN_RENDERER_CHANGED_EVENT -> surfaceRendererController.allocateSurfaceRenderer(getSurfaceRendererType())
-
-                SCREEN_REFRESH_EVENT -> {
-                    updateQuery()
-                    renderFrame()
-                }
-
-                AA_TRIP_INFO_PID_SELECTION_CHANGED_EVENT, AA_PERFORMANCE_PID_SELECTION_CHANGED_EVENT -> {
-                    updateQuery()
-                    renderFrame()
-                }
-
-                AA_HIGH_FREQ_PID_SELECTION_CHANGED_EVENT -> {
-                    updateQuery()
-                    renderFrame()
-                }
-
-                LOW_FREQ_PID_SELECTION_CHANGED_EVENT -> {
-                    updateQuery()
-                    renderFrame()
-                }
-
-                GIULIA_VIRTUAL_SCREEN_1_SETTINGS_CHANGED, GAUGE_VIRTUAL_SCREEN_1_SETTINGS_CHANGED -> handlePIDsListChangedEvent(1)
-                GIULIA_VIRTUAL_SCREEN_2_SETTINGS_CHANGED, GAUGE_VIRTUAL_SCREEN_2_SETTINGS_CHANGED -> handlePIDsListChangedEvent(2)
-                GIULIA_VIRTUAL_SCREEN_3_SETTINGS_CHANGED, GAUGE_VIRTUAL_SCREEN_3_SETTINGS_CHANGED -> handlePIDsListChangedEvent(3)
-                GIULIA_VIRTUAL_SCREEN_4_SETTINGS_CHANGED, GAUGE_VIRTUAL_SCREEN_4_SETTINGS_CHANGED ->  handlePIDsListChangedEvent(4)
-
-                PROFILE_CHANGED_EVENT -> {
-                    settings.handleProfileChanged()
-                    updateQuery()
-                    surfaceRendererController.allocateSurfaceRenderer(getSurfaceRendererType())
-                    renderFrame()
+    private var broadcastReceiver =
+        object : BroadcastReceiver() {
+            override fun onReceive(
+                context: Context?,
+                intent: Intent?,
+            ) {
+                when (intent?.action) {
+                    AA_VIRTUAL_SCREEN_RENDERER_CHANGED_EVENT -> surfaceRendererController.allocateSurfaceRenderer(getSurfaceRendererType())
+
+                    SCREEN_REFRESH_EVENT -> {
+                        updateQuery()
+                        renderFrame()
+                    }
+
+                    AA_TRIP_INFO_PID_SELECTION_CHANGED_EVENT, AA_PERFORMANCE_PID_SELECTION_CHANGED_EVENT -> {
+                        updateQuery()
+                        renderFrame()
+                    }
+
+                    AA_HIGH_FREQ_PID_SELECTION_CHANGED_EVENT -> {
+                        updateQuery()
+                        renderFrame()
+                    }
+
+                    LOW_FREQ_PID_SELECTION_CHANGED_EVENT -> {
+                        updateQuery()
+                        renderFrame()
+                    }
+
+                    GIULIA_VIRTUAL_SCREEN_1_SETTINGS_CHANGED, GAUGE_VIRTUAL_SCREEN_1_SETTINGS_CHANGED -> handlePIDsListChangedEvent(1)
+                    GIULIA_VIRTUAL_SCREEN_2_SETTINGS_CHANGED, GAUGE_VIRTUAL_SCREEN_2_SETTINGS_CHANGED -> handlePIDsListChangedEvent(2)
+                    GIULIA_VIRTUAL_SCREEN_3_SETTINGS_CHANGED, GAUGE_VIRTUAL_SCREEN_3_SETTINGS_CHANGED -> handlePIDsListChangedEvent(3)
+                    GIULIA_VIRTUAL_SCREEN_4_SETTINGS_CHANGED, GAUGE_VIRTUAL_SCREEN_4_SETTINGS_CHANGED -> handlePIDsListChangedEvent(4)
+
+                    PROFILE_CHANGED_EVENT -> {
+                        settings.handleProfileChanged()
+                        updateQuery()
+                        surfaceRendererController.allocateSurfaceRenderer(getSurfaceRendererType())
+                        renderFrame()
+                    }
+
+                    PROFILE_RESET_EVENT -> {
+                        updateQuery()
+                        surfaceRendererController.allocateSurfaceRenderer(getSurfaceRendererType())
+                        renderFrame()
+                    }
                 }
+            }
 
-                PROFILE_RESET_EVENT -> {
-                    updateQuery()
-                    surfaceRendererController.allocateSurfaceRenderer(getSurfaceRendererType())
-                    renderFrame()
+            private fun handlePIDsListChangedEvent(id: Int) {
+                if (getCurrentVirtualScreen() == id) {
+                    setCurrentVirtualScreen(id)
                 }
+                updateQuery()
+                renderFrame()
             }
         }
-        private fun handlePIDsListChangedEvent(id: Int) {
-            if (getCurrentVirtualScreen() == id) {
-                setCurrentVirtualScreen(id)
-            }
-            updateQuery()
-            renderFrame()
-        }
-    }
-
 
     fun getLifecycleObserver() = surfaceRendererController
 
-    fun resetSurfaceRenderer(){
+    fun resetSurfaceRenderer() {
         screenId = DefaultScreen.NOT_SET
     }
 
-
     fun switchSurfaceRenderer(screenId: Identity) {
         this.screenId = screenId
         Log.i(LOG_TAG, "Switch to new surface renderer screen: ${this.screenId} and updating query...")
 
-        when (this.screenId as SurfaceRendererType){
+        when (this.screenId as SurfaceRendererType) {
             SurfaceRendererType.GIULIA, SurfaceRendererType.GAUGE -> {
-
                 metricsCollector.applyFilter(enabled = getSelectedPIDs())
 
                 if (dataLoggerSettings.instance().adapter.individualQueryStrategyEnabled) {
@@ -149,31 +160,46 @@ internal class SurfaceRendererScreen(
                 } else {
                     query.setStrategy(QueryStrategyType.SHARED_QUERY)
                 }
-
-                dataLogger.updateQuery(query = query)
+                withDataLogger {
+                    updateQuery(query = query)
+                }
                 surfaceRendererController.allocateSurfaceRenderer(screenId as SurfaceRendererType)
             }
 
             SurfaceRendererType.DRAG_RACING -> {
-                dataLogger.updateQuery(query = query.apply {
-                    setStrategy(QueryStrategyType.DRAG_RACING_QUERY)
-                })
+                withDataLogger {
+                    updateQuery(
+                        query =
+                            query.apply {
+                                setStrategy(QueryStrategyType.DRAG_RACING_QUERY)
+                            },
+                    )
+                }
+
                 surfaceRendererController.allocateSurfaceRenderer(surfaceRendererType = SurfaceRendererType.DRAG_RACING)
             }
 
             SurfaceRendererType.TRIP_INFO -> {
-
-                dataLogger.updateQuery(query = query.apply {
-                    setStrategy(QueryStrategyType.TRIP_INFO_QUERY)
-                })
+                withDataLogger {
+                    updateQuery(
+                        query =
+                            query.apply {
+                                setStrategy(QueryStrategyType.TRIP_INFO_QUERY)
+                            },
+                    )
+                }
                 surfaceRendererController.allocateSurfaceRenderer(surfaceRendererType = SurfaceRendererType.TRIP_INFO)
             }
 
             SurfaceRendererType.PERFORMANCE -> {
-
-                dataLogger.updateQuery(query = query.apply {
-                    setStrategy(QueryStrategyType.PERFORMANCE_QUERY)
-                })
+                withDataLogger {
+                    updateQuery(
+                        query =
+                            query.apply {
+                                setStrategy(QueryStrategyType.PERFORMANCE_QUERY)
+                            },
+                    )
+                }
                 surfaceRendererController.allocateSurfaceRenderer(surfaceRendererType = SurfaceRendererType.PERFORMANCE)
             }
         }
@@ -181,58 +207,88 @@ internal class SurfaceRendererScreen(
         renderFrame()
     }
 
-    override fun actionStartDataLogging(){
+    override fun actionStartDataLogging() {
         when (screenId) {
-            SurfaceRendererType.GIULIA , SurfaceRendererType.GAUGE -> {
+            SurfaceRendererType.GIULIA, SurfaceRendererType.GAUGE -> {
                 if (dataLoggerSettings.instance().adapter.individualQueryStrategyEnabled) {
                     query.setStrategy(QueryStrategyType.INDIVIDUAL_QUERY)
                     query.update(metricsCollector.getMetrics().map { p -> p.source.command.pid.id }.toSet())
                 } else {
                     query.setStrategy(QueryStrategyType.SHARED_QUERY)
                 }
-                dataLogger.start(query)
+                withDataLogger {
+                    start(query)
+                }
             }
 
             SurfaceRendererType.DRAG_RACING ->
-                dataLogger.start(query.apply{
-                    setStrategy(QueryStrategyType.DRAG_RACING_QUERY)
-                })
+                withDataLogger {
+                    start(
+                        query.apply {
+                            setStrategy(QueryStrategyType.DRAG_RACING_QUERY)
+                        },
+                    )
+                }
 
             SurfaceRendererType.TRIP_INFO ->
-                dataLogger.start(query.apply{
-                    setStrategy(QueryStrategyType.TRIP_INFO_QUERY)
-                })
+                withDataLogger {
+                    start(
+                        query.apply {
+                            setStrategy(QueryStrategyType.TRIP_INFO_QUERY)
+                        },
+                    )
+                }
 
             SurfaceRendererType.PERFORMANCE ->
-                dataLogger.start(query.apply{
-                    setStrategy(QueryStrategyType.PERFORMANCE_QUERY)
-                })
+                withDataLogger {
+                    start(
+                        query.apply {
+                            setStrategy(QueryStrategyType.PERFORMANCE_QUERY)
+                        },
+                    )
+                }
         }
     }
 
     fun isSurfaceRendererScreen(identity: Identity) = identity is SurfaceRendererType
-    override fun getFeatureDescription(): List<FeatureDescription>  = mutableListOf(
-        FeatureDescription(SurfaceRendererType.DRAG_RACING, org.obd.graphs.commons.R.drawable.action_drag_race,
-            carContext.getString(R.string.available_features_drag_race_screen_title)),
-        FeatureDescription(SurfaceRendererType.GAUGE, R.drawable.action_gauge, carContext.getString(R.string.available_features_gauge_screen_title)),
-        FeatureDescription(SurfaceRendererType.GIULIA, R.drawable.action_giulia_metics, carContext.getString(R.string.available_features_giulia_screen_title)))
-            .apply {
-                if (settings.getTripInfoScreenSettings().viewEnabled) {
-                    add(
-                        FeatureDescription(
-                            SurfaceRendererType.TRIP_INFO,
-                            R.drawable.action_giulia,
-                            carContext.getString(R.string.available_features_trip_info_screen_title)
-                        )
-                    )
-                }
-                if (settings.getPerformanceScreenSettings().viewEnabled) {
-                    add(
-                        FeatureDescription(SurfaceRendererType.PERFORMANCE, org.obd.graphs.commons.R.drawable.action_drag_race,
-                            carContext.getString(R.string.available_features_performance_screen_title)),
-                    )
-                }
-             }
+
+    override fun getFeatureDescription(): List<FeatureDescription> =
+        mutableListOf(
+            FeatureDescription(
+                SurfaceRendererType.DRAG_RACING,
+                org.obd.graphs.commons.R.drawable.action_drag_race,
+                carContext.getString(R.string.available_features_drag_race_screen_title),
+            ),
+            FeatureDescription(
+                SurfaceRendererType.GAUGE,
+                R.drawable.action_gauge,
+                carContext.getString(R.string.available_features_gauge_screen_title),
+            ),
+            FeatureDescription(
+                SurfaceRendererType.GIULIA,
+                R.drawable.action_giulia_metics,
+                carContext.getString(R.string.available_features_giulia_screen_title),
+            ),
+        ).apply {
+            if (settings.getTripInfoScreenSettings().viewEnabled) {
+                add(
+                    FeatureDescription(
+                        SurfaceRendererType.TRIP_INFO,
+                        R.drawable.action_giulia,
+                        carContext.getString(R.string.available_features_trip_info_screen_title),
+                    ),
+                )
+            }
+            if (settings.getPerformanceScreenSettings().viewEnabled) {
+                add(
+                    FeatureDescription(
+                        SurfaceRendererType.PERFORMANCE,
+                        org.obd.graphs.commons.R.drawable.action_drag_race,
+                        carContext.getString(R.string.available_features_performance_screen_title),
+                    ),
+                )
+            }
+        }
 
     fun renderFrame() {
         if (isSurfaceRendererScreen(screenId)) {
@@ -259,7 +315,7 @@ internal class SurfaceRendererScreen(
     }
 
     override fun onCreate(owner: LifecycleOwner) {
-        registerReceiver(carContext,broadcastReceiver) {
+        registerReceiver(carContext, broadcastReceiver) {
             it.addAction(AA_HIGH_FREQ_PID_SELECTION_CHANGED_EVENT)
             it.addAction(LOW_FREQ_PID_SELECTION_CHANGED_EVENT)
             it.addAction(GIULIA_VIRTUAL_SCREEN_1_SETTINGS_CHANGED)
@@ -285,9 +341,7 @@ internal class SurfaceRendererScreen(
     }
 
     private fun updateQuery() {
-
         if (isSurfaceRendererScreen(screenId)) {
-
             val selectedPIDs = getSelectedPIDs()
 
             metricsCollector.applyFilter(enabled = selectedPIDs)
@@ -298,24 +352,27 @@ internal class SurfaceRendererScreen(
                 query.setStrategy(QueryStrategyType.DRAG_RACING_QUERY)
                 metricsCollector.applyFilter(enabled = query.getIDs())
                 Log.i(LOG_TAG, "User selection PIDs=${query.getIDs()}")
-                dataLogger.updateQuery(query)
-
+                withDataLogger {
+                    updateQuery(query)
+                }
             } else if (screenId == SurfaceRendererType.TRIP_INFO) {
                 Log.i(LOG_TAG, "Updating query for  TRIP_INFO_SCREEN_ID screen")
 
                 query.setStrategy(QueryStrategyType.TRIP_INFO_QUERY)
                 metricsCollector.applyFilter(enabled = query.getIDs())
                 Log.i(LOG_TAG, "User selection PIDs=${query.getIDs()}")
-                dataLogger.updateQuery(query)
-
+                withDataLogger {
+                    updateQuery(query)
+                }
             } else if (screenId == SurfaceRendererType.PERFORMANCE) {
                 Log.i(LOG_TAG, "Updating query for  DYNAMIC_SCREEN_ID screen")
 
                 query.setStrategy(QueryStrategyType.PERFORMANCE_QUERY)
                 metricsCollector.applyFilter(enabled = query.getIDs())
                 Log.i(LOG_TAG, "User selection PIDs=${query.getIDs()}")
-                dataLogger.updateQuery(query)
-
+                withDataLogger {
+                    updateQuery(query)
+                }
             } else if (dataLoggerSettings.instance().adapter.individualQueryStrategyEnabled) {
                 Log.i(LOG_TAG, "Updating query for  individualQueryStrategyEnabled")
 
@@ -323,9 +380,10 @@ internal class SurfaceRendererScreen(
 
                 query.setStrategy(QueryStrategyType.INDIVIDUAL_QUERY)
                 query.update(metricsCollector.getMetrics().map { p -> p.source.command.pid.id }.toSet())
-                Log.i(LOG_TAG, "User selection PIDs=${selectedPIDs}")
-
-                dataLogger.updateQuery(query)
+                Log.i(LOG_TAG, "User selection PIDs=$selectedPIDs")
+                withDataLogger {
+                    updateQuery(query)
+                }
             } else {
                 Log.i(LOG_TAG, "Updating query to SHARED_QUERY strategy")
 
@@ -342,50 +400,56 @@ internal class SurfaceRendererScreen(
         }
     }
 
+    private fun setCurrentVirtualScreen(id: Int) =
+        when (screenId) {
+            SurfaceRendererType.GIULIA -> settings.getGiuliaRendererSetting().setVirtualScreen(id)
+            SurfaceRendererType.GAUGE -> settings.getGaugeRendererSetting().setVirtualScreen(id)
+            else -> {}
+        }
 
-    private fun setCurrentVirtualScreen(id: Int) = when (screenId) {
-        SurfaceRendererType.GIULIA -> settings.getGiuliaRendererSetting().setVirtualScreen(id)
-        SurfaceRendererType.GAUGE -> settings.getGaugeRendererSetting().setVirtualScreen(id)
-        else -> {}
-    }
-
-    private fun getCurrentVirtualScreen() = when (screenId) {
-        SurfaceRendererType.GIULIA ->  settings.getGiuliaRendererSetting().getVirtualScreen()
-        SurfaceRendererType.GAUGE -> settings.getGaugeRendererSetting().getVirtualScreen()
-        else -> -1
-    }
-
+    private fun getCurrentVirtualScreen() =
+        when (screenId) {
+            SurfaceRendererType.GIULIA -> settings.getGiuliaRendererSetting().getVirtualScreen()
+            SurfaceRendererType.GAUGE -> settings.getGaugeRendererSetting().getVirtualScreen()
+            else -> -1
+        }
 
-    private fun getSelectedPIDs(): Set<Long>  =  if (screenId == SurfaceRendererType.GIULIA) {
+    private fun getSelectedPIDs(): Set<Long> =
+        if (screenId == SurfaceRendererType.GIULIA) {
             settings.getGiuliaRendererSetting().selectedPIDs
         } else {
             settings.getGaugeRendererSetting().selectedPIDs
         }
 
     private fun getVerticalActionStrip(): ActionStrip? {
-
         var added = false
         var builder = ActionStrip.Builder()
 
-        mapOf(1 to R.drawable.action_virtual_screen_1,
+        mapOf(
+            1 to R.drawable.action_virtual_screen_1,
             2 to R.drawable.action_virtual_screen_2,
             3 to R.drawable.action_virtual_screen_3,
-            4 to R.drawable.action_virtual_screen_4).forEach { (k, v) ->
+            4 to R.drawable.action_virtual_screen_4,
+        ).forEach { (k, v) ->
             if (settings.isVirtualScreenEnabled(k)) {
                 added = true
 
-                val color = if (getCurrentVirtualScreen() == k) {
-                    CarColor.GREEN
-                } else {
-                    mapColor(settings.getColorTheme().actionsBtnVirtualScreensColor)
-                }
-
-                builder = builder.addAction(createAction(carContext, v, color) {
-                    parent.invalidate()
-                    setCurrentVirtualScreen(k)
-                    updateQuery()
-                    renderFrame()
-                })
+                val color =
+                    if (getCurrentVirtualScreen() == k) {
+                        CarColor.GREEN
+                    } else {
+                        mapColor(settings.getColorTheme().actionsBtnVirtualScreensColor)
+                    }
+
+                builder =
+                    builder.addAction(
+                        createAction(carContext, v, color) {
+                            parent.invalidate()
+                            setCurrentVirtualScreen(k)
+                            updateQuery()
+                            renderFrame()
+                        },
+                    )
             }
         }
 
@@ -396,12 +460,13 @@ internal class SurfaceRendererScreen(
         }
     }
 
-    private fun getSurfaceRendererType (): SurfaceRendererType =
-        if (screenId is SurfaceRendererType) screenId as SurfaceRendererType else  SurfaceRendererType.GIULIA
+    private fun getSurfaceRendererType(): SurfaceRendererType =
+        if (screenId is SurfaceRendererType) screenId as SurfaceRendererType else SurfaceRendererType.GIULIA
 
-    private fun sortOrder(): Map<Long, Int>?  = if (this.screenId == SurfaceRendererType.GIULIA) {
-        settings.getGiuliaRendererSetting().getPIDsSortOrder()
-    } else {
-        settings.getGaugeRendererSetting().getPIDsSortOrder()
-    }
+    private fun sortOrder(): Map<Long, Int>? =
+        if (this.screenId == SurfaceRendererType.GIULIA) {
+            settings.getGiuliaRendererSetting().getPIDsSortOrder()
+        } else {
+            settings.getGaugeRendererSetting().getPIDsSortOrder()
+        }
 }
diff --git a/common/src/main/java/org/obd/graphs/Context.kt b/common/src/main/java/org/obd/graphs/Context.kt
index 502c749c..151de11c 100644
--- a/common/src/main/java/org/obd/graphs/Context.kt
+++ b/common/src/main/java/org/obd/graphs/Context.kt
@@ -32,7 +32,6 @@ fun setCarContext(carContext: ContextWrapper) {
 
 fun getContext(): ContextWrapper? =
     when {
-        //Application context has priority over Car context
         ::activityContext.isInitialized -> {
             activityContext.get()
         }
diff --git a/common/src/main/java/org/obd/graphs/preferences/Preferences.kt b/common/src/main/java/org/obd/graphs/preferences/Preferences.kt
index fec0a628..b11f9fee 100644
--- a/common/src/main/java/org/obd/graphs/preferences/Preferences.kt
+++ b/common/src/main/java/org/obd/graphs/preferences/Preferences.kt
@@ -17,14 +17,17 @@
 package org.obd.graphs.preferences
 
 import android.annotation.SuppressLint
+import android.content.Context
 import android.content.SharedPreferences
 import androidx.preference.PreferenceManager
-import org.obd.graphs.getContext
 
-val Prefs: SharedPreferences by lazy {
-   PreferenceManager.getDefaultSharedPreferences(
-       getContext()!!
-    )
+lateinit var Prefs: SharedPreferences
+    private set
+
+fun initPrefs(context: Context) {
+    if (!::Prefs.isInitialized) {
+        Prefs = PreferenceManager.getDefaultSharedPreferences(context.applicationContext)
+    }
 }
 
 fun SharedPreferences.Editor.updatePreference(
@@ -36,12 +39,15 @@ fun SharedPreferences.Editor.updatePreference(
         is String -> {
             putString(prefName, value)
         }
+
         is Set<*> -> {
             putStringSet(prefName, value as MutableSet<String>?)
         }
+
         is Int -> {
             putInt(prefName, value)
         }
+
         is Boolean -> {
             putBoolean(prefName, value)
         }
@@ -59,8 +65,8 @@ fun SharedPreferences.updateString(key: String, value: String?): SharedPreferenc
 }
 
 @SuppressLint("ApplySharedPref")
-fun SharedPreferences.updateInt(key: String, value: Int){
-   edit().putInt(key, value).commit()
+fun SharedPreferences.updateInt(key: String, value: Int) {
+    edit().putInt(key, value).commit()
 }
 
 @SuppressLint("ApplySharedPref")
@@ -74,7 +80,7 @@ fun SharedPreferences.updateLongSet(key: String, list: List<Long>) {
 }
 
 fun SharedPreferences.getLongSet(key: String, defaults: MutableSet<String> = mutableSetOf()): Set<Long> {
-    return getStringSet(key,defaults)?.map { s -> s.toLong() }?.toSet()!!
+    return getStringSet(key, defaults)?.map { s -> s.toLong() }?.toSet()!!
 }
 
 fun SharedPreferences.getStringSet(key: String): MutableSet<String> {
diff --git a/datalogger/build.gradle b/datalogger/build.gradle
index 11258c06..24563947 100644
--- a/datalogger/build.gradle
+++ b/datalogger/build.gradle
@@ -43,6 +43,9 @@ dependencies {
     implementation project(":common")
     implementation project(':profile')
 
+    // This specific library provides lifecycleScope
+    implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.6.2"
+
     implementation 'com.google.android.gms:play-services-location:21.0.1'
     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
     implementation 'androidx.core:core-ktx:1.2.0'
diff --git a/datalogger/src/main/java/org/obd/graphs/bl/collector/InMemoryCarMetricsCollector.kt b/datalogger/src/main/java/org/obd/graphs/bl/collector/InMemoryCarMetricsCollector.kt
index 9a813065..a47d1c0d 100644
--- a/datalogger/src/main/java/org/obd/graphs/bl/collector/InMemoryCarMetricsCollector.kt
+++ b/datalogger/src/main/java/org/obd/graphs/bl/collector/InMemoryCarMetricsCollector.kt
@@ -17,7 +17,7 @@
 package org.obd.graphs.bl.collector
 
 import android.util.Log
-import org.obd.graphs.bl.datalogger.dataLogger
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.bl.datalogger.Pid
 import org.obd.metrics.api.model.ObdMetric
 import java.util.*
@@ -91,8 +91,8 @@ internal class InMemoryCarMetricsCollector : MetricsCollector {
                 it.source = metric
 
                 it.value = metric.value
-                val hist = dataLogger.findHistogramFor(metric)
-                val rate = dataLogger.findRateFor(metric)
+                val hist = DataLoggerRepository.findHistogramFor(metric)
+                val rate = DataLoggerRepository.findRateFor(metric)
 
                 if (metric.isLowerAlert) {
                     it.inLowerAlertRisedHist = metric.isLowerAlert
diff --git a/datalogger/src/main/java/org/obd/graphs/bl/collector/MetricsBuilder.kt b/datalogger/src/main/java/org/obd/graphs/bl/collector/MetricsBuilder.kt
index 55949fcb..5126d669 100644
--- a/datalogger/src/main/java/org/obd/graphs/bl/collector/MetricsBuilder.kt
+++ b/datalogger/src/main/java/org/obd/graphs/bl/collector/MetricsBuilder.kt
@@ -17,7 +17,7 @@
 package org.obd.graphs.bl.collector
 
 
-import org.obd.graphs.bl.datalogger.dataLogger
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.metrics.api.model.ObdMetric
 import org.obd.metrics.command.obd.ObdCommand
 import org.obd.metrics.pid.PidDefinitionRegistry
@@ -39,7 +39,7 @@ class MetricsBuilder {
 
 
     fun buildFor(obdMetric: ObdMetric): Metric {
-        val histogramSupplier = dataLogger.getDiagnostics().histogram()
+        val histogramSupplier = DataLoggerRepository.getDiagnostics().histogram()
         val histogram = histogramSupplier.findBy(obdMetric.command.pid)
         return Metric
             .newInstance(
@@ -74,8 +74,8 @@ class MetricsBuilder {
 
 
     private fun buildMetrics(ids: Set<Long>): MutableList<Metric> {
-        val pidRegistry: PidDefinitionRegistry = dataLogger.getPidDefinitionRegistry()
-        val histogramSupplier = dataLogger.getDiagnostics().histogram()
+        val pidRegistry: PidDefinitionRegistry = DataLoggerRepository.getPidDefinitionRegistry()
+        val histogramSupplier = DataLoggerRepository.getDiagnostics().histogram()
 
         return ids.mapNotNull {
             pidRegistry.findBy(it)?.let { pid ->
diff --git a/datalogger/src/main/java/org/obd/graphs/bl/datalogger/DataLogger.kt b/datalogger/src/main/java/org/obd/graphs/bl/datalogger/DataLogger.kt
deleted file mode 100644
index 15714012..00000000
--- a/datalogger/src/main/java/org/obd/graphs/bl/datalogger/DataLogger.kt
+++ /dev/null
@@ -1,49 +0,0 @@
- /**
- * Copyright 2019-2026, Tomasz Żebrowski
- *
- * <p>Licensed to the Apache Software Foundation (ASF) under one or more contributor license
- * agreements. See the NOTICE file distributed with this work for additional information regarding
- * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License. You may obtain a
- * copy of the License at
- *
- * <p>http://www.apache.org/licenses/LICENSE-2.0
- *
- * <p>Unless required by applicable law or agreed to in writing, software distributed under the
- * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
- * express or implied. See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.obd.graphs.bl.datalogger
-
-import android.content.BroadcastReceiver
-import androidx.lifecycle.LifecycleOwner
-import org.obd.graphs.bl.query.Query
-import org.obd.metrics.alert.Alert
-import org.obd.metrics.api.model.ObdMetric
-import org.obd.metrics.diagnostic.Diagnostics
-import org.obd.metrics.diagnostic.Histogram
-import org.obd.metrics.diagnostic.Rate
-import org.obd.metrics.pid.PidDefinitionRegistry
-import java.util.*
-
-interface DataLogger {
-    val eventsReceiver: BroadcastReceiver
-    fun status(): WorkflowStatus
-    fun observe(lifecycleOwner: LifecycleOwner, observer: (metric: ObdMetric) -> Unit)
-    fun observe(metricsProcessor: MetricsProcessor): DataLogger
-    fun isRunning(): Boolean
-    fun getDiagnostics(): Diagnostics
-    fun findHistogramFor(metric: ObdMetric): Histogram
-    fun findRateFor(metric: ObdMetric): Optional<Rate>
-    fun getPidDefinitionRegistry(): PidDefinitionRegistry
-    fun isDTCEnabled(): Boolean
-    fun scheduleStart(delay: Long, query: Query)
-    fun scheduledStop()
-    fun executeRoutine(query: Query)
-    fun start(query: Query)
-    fun updateQuery(query: Query)
-    fun stop()
-    fun getCurrentQuery(): Query?
-    fun findAlertFor(metric: ObdMetric): List<Alert>
-}
diff --git a/datalogger/src/main/java/org/obd/graphs/bl/datalogger/DataLoggerConnector.kt b/datalogger/src/main/java/org/obd/graphs/bl/datalogger/DataLoggerConnector.kt
new file mode 100644
index 00000000..851cb49c
--- /dev/null
+++ b/datalogger/src/main/java/org/obd/graphs/bl/datalogger/DataLoggerConnector.kt
@@ -0,0 +1,93 @@
+ /**
+ * Copyright 2019-2026, Tomasz Żebrowski
+ *
+ * <p>Licensed to the Apache Software Foundation (ASF) under one or more contributor license
+ * agreements. See the NOTICE file distributed with this work for additional information regarding
+ * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License. You may obtain a
+ * copy of the License at
+ *
+ * <p>http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * <p>Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.obd.graphs.bl.datalogger
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.ServiceConnection
+import android.os.IBinder
+import android.util.Log
+
+private const val TAG = "DataLoggerConnector"
+
+fun withDataLogger(
+    context: Context,
+    action: DataLoggerService.() -> Unit,
+) {
+    DataLoggerConnector.run(context, action)
+}
+
+internal object DataLoggerConnector {
+    private var service: DataLoggerService? = null
+    private var isBound = false
+    private val pendingTasks = mutableListOf<DataLoggerService.() -> Unit>()
+
+    private val serviceConnection =
+        object : ServiceConnection {
+            override fun onServiceConnected(
+                className: ComponentName,
+                binder: IBinder,
+            ) {
+                Log.i(TAG, "Service connected globally.")
+                val localBinder = binder as DataLoggerService.LocalBinder
+                service = localBinder.getService()
+                isBound = true
+
+                synchronized(pendingTasks) {
+                    pendingTasks.forEach { task ->
+                        service?.apply(task)
+                    }
+                    pendingTasks.clear()
+                }
+            }
+
+            override fun onServiceDisconnected(className: ComponentName) {
+                service = null
+                isBound = false
+            }
+        }
+
+    /**
+     * The core function. Binds lazily (on first use) and executes the action.
+     */
+    fun run(
+        context: Context,
+        action: DataLoggerService.() -> Unit,
+    ) {
+        val currentService = service
+
+        if (currentService == null) {
+            Log.i(TAG, "Service not ready. Queueing task...")
+            synchronized(pendingTasks) {
+                pendingTasks.add(action)
+            }
+            bind(context)
+        } else {
+            currentService.apply(action)
+        }
+    }
+
+    private fun bind(context: Context) {
+        if (!isBound) {
+            val appContext = context.applicationContext
+            val intent = Intent(appContext, DataLoggerService::class.java)
+            appContext.bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)
+            isBound = true
+        }
+    }
+}
diff --git a/datalogger/src/main/java/org/obd/graphs/bl/datalogger/DataLoggerConstants.kt b/datalogger/src/main/java/org/obd/graphs/bl/datalogger/DataLoggerConstants.kt
index 849db693..e2b028f3 100644
--- a/datalogger/src/main/java/org/obd/graphs/bl/datalogger/DataLoggerConstants.kt
+++ b/datalogger/src/main/java/org/obd/graphs/bl/datalogger/DataLoggerConstants.kt
@@ -23,6 +23,8 @@ const val DATA_LOGGER_WIFI_INCORRECT = "data.logger.error.wifi.incorrect"
 const val DATA_LOGGER_WIFI_NOT_CONNECTED = "data.logger.error.wifi.not.connected"
 const val DATA_LOGGER_CONNECTED_EVENT = "data.logger.connected"
 const val DATA_LOGGER_SCHEDULED_START_EVENT = "data.logger.scheduled.start"
+const val DATA_LOGGER_SCHEDULED_STOP_EVENT = "data.logger.scheduled.stop"
+
 const val DATA_LOGGER_DTC_AVAILABLE = "data.logger.dtc.available"
 const val DATA_LOGGER_CONNECTING_EVENT = "data.logger.connecting"
 const val DATA_LOGGER_STOPPED_EVENT = "data.logger.stopped"
diff --git a/datalogger/src/main/java/org/obd/graphs/bl/datalogger/DataLoggerJobScheduler.kt b/datalogger/src/main/java/org/obd/graphs/bl/datalogger/DataLoggerJobScheduler.kt
index 8062c1ec..8030000e 100644
--- a/datalogger/src/main/java/org/obd/graphs/bl/datalogger/DataLoggerJobScheduler.kt
+++ b/datalogger/src/main/java/org/obd/graphs/bl/datalogger/DataLoggerJobScheduler.kt
@@ -23,7 +23,7 @@ import java.util.concurrent.ScheduledExecutorService
 import java.util.concurrent.ScheduledFuture
 import java.util.concurrent.TimeUnit
 
-internal class DataLoggerJobScheduler {
+internal class DataLoggerJobScheduler(private val dataLogger: DataLoggerService) {
 
     private val scheduleService: ScheduledExecutorService = Executors.newScheduledThreadPool(1)
     private var future: ScheduledFuture<*>? = null
diff --git a/datalogger/src/main/java/org/obd/graphs/bl/datalogger/DataLoggerRepository.kt b/datalogger/src/main/java/org/obd/graphs/bl/datalogger/DataLoggerRepository.kt
new file mode 100644
index 00000000..5caab80c
--- /dev/null
+++ b/datalogger/src/main/java/org/obd/graphs/bl/datalogger/DataLoggerRepository.kt
@@ -0,0 +1,69 @@
+ /**
+ * Copyright 2019-2026, Tomasz Żebrowski
+ *
+ * <p>Licensed to the Apache Software Foundation (ASF) under one or more contributor license
+ * agreements. See the NOTICE file distributed with this work for additional information regarding
+ * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License. You may obtain a
+ * copy of the License at
+ *
+ * <p>http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * <p>Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.obd.graphs.bl.datalogger
+
+import android.content.BroadcastReceiver
+import android.util.Log
+import androidx.annotation.VisibleForTesting
+import androidx.lifecycle.LifecycleOwner
+import org.obd.graphs.bl.query.Query
+import org.obd.metrics.api.model.ObdMetric
+import org.obd.metrics.diagnostic.Diagnostics
+import org.obd.metrics.diagnostic.Histogram
+import org.obd.metrics.diagnostic.Rate
+import org.obd.metrics.pid.PidDefinitionRegistry
+import java.util.Optional
+
+object DataLoggerRepository {
+    private var _workflowOrchestrator: WorkflowOrchestrator? = null
+
+    internal val workflowOrchestrator: WorkflowOrchestrator
+        get() {
+            if (_workflowOrchestrator == null) {
+                Log.i(LOG_TAG, "Initializing WorkflowOrchestrator")
+                _workflowOrchestrator = WorkflowOrchestrator()
+            }
+            return _workflowOrchestrator!!
+        }
+
+    @VisibleForTesting
+    internal fun setWorkflowOrchestrator(mock: WorkflowOrchestrator) {
+        _workflowOrchestrator = mock
+    }
+
+    fun getCurrentQuery(): Query? = workflowOrchestrator.getCurrentQuery()
+    fun isRunning(): Boolean = workflowOrchestrator.isRunning()
+    fun getDiagnostics(): Diagnostics = workflowOrchestrator.diagnostics()
+    fun findHistogramFor(metric: ObdMetric): Histogram = workflowOrchestrator.findHistogramFor(metric)
+    fun findRateFor(metric: ObdMetric): Optional<Rate> = workflowOrchestrator.findRateFor(metric)
+    fun getPidDefinitionRegistry(): PidDefinitionRegistry = workflowOrchestrator.pidDefinitionRegistry()
+    fun isDTCEnabled(): Boolean = workflowOrchestrator.isDTCEnabled()
+    fun status(): WorkflowStatus = workflowOrchestrator.status()
+
+    fun observe(lifecycleOwner: LifecycleOwner, observer: (metric: ObdMetric) -> Unit) {
+        workflowOrchestrator.observe(lifecycleOwner, observer)
+    }
+
+    fun observe(metricsProcessor: MetricsProcessor): DataLoggerRepository {
+        workflowOrchestrator.observe(metricsProcessor)
+        return this
+    }
+
+
+    val eventsReceiver: BroadcastReceiver
+        get() = workflowOrchestrator.eventsReceiver
+}
diff --git a/datalogger/src/main/java/org/obd/graphs/bl/datalogger/DataLoggerService.kt b/datalogger/src/main/java/org/obd/graphs/bl/datalogger/DataLoggerService.kt
index 314b7aeb..3f89d54c 100644
--- a/datalogger/src/main/java/org/obd/graphs/bl/datalogger/DataLoggerService.kt
+++ b/datalogger/src/main/java/org/obd/graphs/bl/datalogger/DataLoggerService.kt
@@ -22,28 +22,19 @@ import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.app.PendingIntent
 import android.app.Service
-import android.content.BroadcastReceiver
 import android.content.Intent
+import android.content.pm.ServiceInfo
 import android.os.Binder
 import android.os.Build
 import android.os.IBinder
 import android.util.Log
-import androidx.annotation.VisibleForTesting
 import androidx.core.app.NotificationCompat
-import androidx.lifecycle.LifecycleOwner
 import org.obd.graphs.Permissions
+import org.obd.graphs.REQUEST_LOCATION_PERMISSIONS
 import org.obd.graphs.REQUEST_NOTIFICATION_PERMISSIONS
 import org.obd.graphs.bl.query.Query
 import org.obd.graphs.datalogger.R
-import org.obd.graphs.getContext
 import org.obd.graphs.sendBroadcastEvent
-import org.obd.metrics.alert.Alert
-import org.obd.metrics.api.model.ObdMetric
-import org.obd.metrics.diagnostic.Diagnostics
-import org.obd.metrics.diagnostic.Histogram
-import org.obd.metrics.diagnostic.Rate
-import org.obd.metrics.pid.PidDefinitionRegistry
-import java.util.Optional
 
 private const val SCHEDULED_ACTION_START = "org.obd.graphs.logger.scheduled.START"
 private const val SCHEDULED_ACTION_STOP = "org.obd.graphs.logger.scheduled.STOP"
@@ -58,72 +49,34 @@ private const val EXECUTE_ROUTINE = "org.obd.graphs.logger.EXECUTE_ROUTINE"
 private const val NOTIFICATION_CHANNEL_ID = "data_logger_channel_v2"
 private const val NOTIFICATION_ID = 12345
 
-// Thread-safe Singleton Management
-private var _workflowOrchestrator: WorkflowOrchestrator? = null
-private val orchestratorLock = Any()
-
-internal val workflowOrchestrator: WorkflowOrchestrator
-    get() {
-        synchronized(orchestratorLock) {
-            if (_workflowOrchestrator == null) {
-                Log.i(LOG_TAG, "Initializing WorkflowOrchestrator")
-                _workflowOrchestrator = WorkflowOrchestrator()
-            }
-            return _workflowOrchestrator!!
-        }
-    }
-
-@VisibleForTesting
-internal fun setWorkflowOrchestrator(mock: WorkflowOrchestrator) {
-    synchronized(orchestratorLock) {
-        _workflowOrchestrator = mock
-    }
-}
-
-val dataLogger: DataLogger = DataLoggerService()
-
-internal class DataLoggerService : Service(), DataLogger {
-
-    private val jobScheduler = DataLoggerJobScheduler()
+class DataLoggerService : Service() {
+    private val jobScheduler = DataLoggerJobScheduler(this)
     private val binder = LocalBinder()
 
-    inner class LocalBinder : Binder() {
+    internal inner class LocalBinder : Binder() {
         fun getService(): DataLoggerService = this@DataLoggerService
     }
 
-    override fun onBind(intent: Intent?): IBinder {
-        return binder
-    }
+    override fun onBind(intent: Intent?): IBinder = binder
 
     override fun onDestroy() {
         super.onDestroy()
         Log.i(LOG_TAG, "Destroying DataLoggerService")
-        // Check for null to avoid initializing it just to stop it
-        _workflowOrchestrator?.stop()
     }
 
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+    override fun onStartCommand(
+        intent: Intent?,
+        flags: Int,
+        startId: Int,
+    ): Int {
         Log.i(LOG_TAG, "Starting DataLoggerService in the Foreground Mode")
 
         createNotificationChannel()
 
-        // Handle Foreground Service Types (Android 10+)
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-            var serviceTypes = android.content.pm.ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE
-
-            if (Permissions.hasLocationPermissions(this)) {
-                serviceTypes = serviceTypes or android.content.pm.ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION
-            } else {
-                Log.w(LOG_TAG, "Location permission missing. Starting Service without GPS capabilities.")
-            }
-
-            startForeground(NOTIFICATION_ID, createNotification(), serviceTypes)
-        } else {
-            startForeground(NOTIFICATION_ID, createNotification())
-        }
+        startForegroundServiceSafe()
 
         // Fail-fast if permissions are missing
-        if (!Permissions.hasNotificationPermissions(getContext()!!)) {
+        if (!Permissions.hasNotificationPermissions(this)) {
             Log.e(LOG_TAG, "CRITICAL: Missing required permissions. Service cannot start.")
             serviceStop()
             sendBroadcastEvent(REQUEST_NOTIFICATION_PERMISSIONS)
@@ -136,20 +89,24 @@ internal class DataLoggerService : Service(), DataLogger {
         when (action) {
             UPDATE_QUERY -> {
                 val query = intent.extras?.get(QUERY) as? Query
-                query?.let { workflowOrchestrator.updateQuery(query = it) }
+                query?.let { DataLoggerRepository.workflowOrchestrator.updateQuery(query = it) }
             }
+
             ACTION_START -> {
                 val query = intent.extras?.get(QUERY) as? Query
-                query?.let { workflowOrchestrator.start(it) }
+                query?.let { DataLoggerRepository.workflowOrchestrator.start(it) }
             }
+
             EXECUTE_ROUTINE -> {
                 val query = intent.extras?.get(QUERY) as? Query
-                query?.let { workflowOrchestrator.executeRoutine(it) }
+                query?.let { DataLoggerRepository.workflowOrchestrator.executeRoutine(it) }
             }
+
             ACTION_STOP -> {
-                workflowOrchestrator.stop()
+                DataLoggerRepository.workflowOrchestrator.stop()
                 serviceStop()
             }
+
             SCHEDULED_ACTION_STOP -> jobScheduler.stop()
             SCHEDULED_ACTION_START -> {
                 val delay = intent.extras?.getLong(SCHEDULED_START_DELAY) ?: 0L
@@ -161,78 +118,93 @@ internal class DataLoggerService : Service(), DataLogger {
         return START_STICKY
     }
 
-    override fun updateQuery(query: Query) {
-        isRunning()
+    fun updateQuery(query: Query) {
         Log.i(LOG_TAG, "Updating query for strategy=${query.getStrategy()}. PIDs=${query.getIDs()}")
-        if (isRunning()) {
+        if (DataLoggerRepository.isRunning()) {
             enqueueWork(UPDATE_QUERY) { it.putExtra(QUERY, query) }
         } else {
             Log.w(LOG_TAG, "No workflow is currently running. Query won't be updated.")
         }
     }
 
-    override fun status(): WorkflowStatus = workflowOrchestrator.status()
-
-    override fun scheduleStart(delay: Long, query: Query) {
+    fun scheduleStart(
+        delay: Long,
+        query: Query,
+    ) {
         enqueueWork(SCHEDULED_ACTION_START) {
             it.putExtra(SCHEDULED_START_DELAY, delay)
             it.putExtra(QUERY, query)
         }
     }
 
-    override fun scheduledStop() {
+    fun scheduledStop() {
         enqueueWork(SCHEDULED_ACTION_STOP)
     }
 
-    override fun executeRoutine(query: Query) {
+    fun executeRoutine(query: Query) {
         enqueueWork(EXECUTE_ROUTINE) { it.putExtra(QUERY, query) }
     }
 
-    override fun start(query: Query) {
+    fun start(query: Query) {
         enqueueWork(ACTION_START) { it.putExtra(QUERY, query) }
     }
 
-    override fun stop() {
+    fun stop() {
         enqueueWork(ACTION_STOP)
     }
 
-    override val eventsReceiver: BroadcastReceiver
-        get() = workflowOrchestrator.eventsReceiver
+    private fun startForegroundServiceSafe() {
+        val notification = createNotification()
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                var serviceTypes = ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE
 
-    override fun observe(lifecycleOwner: LifecycleOwner, observer: (metric: ObdMetric) -> Unit) {
-        workflowOrchestrator.observe(lifecycleOwner, observer)
-    }
+                // Only add LOCATION type if we actually have runtime permission
+                if (Permissions.hasLocationPermissions(this)) {
+                    serviceTypes = serviceTypes or ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION
+                } else {
+                    Log.w(LOG_TAG, "Location permission missing. Starting Service without GPS capabilities.")
+                }
 
-    override fun observe(metricsProcessor: MetricsProcessor): DataLogger {
-        workflowOrchestrator.observe(metricsProcessor)
-        return this
+                startForeground(NOTIFICATION_ID, notification, serviceTypes)
+            } else {
+                startForeground(NOTIFICATION_ID, notification)
+            }
+        } catch (e: SecurityException) {
+            Log.e(LOG_TAG, "Failed to start FGS with requested types. Retrying with basic type.", e)
+            // Fallback: Try starting without Location to keep the service alive
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                try {
+                    startForeground(
+                        NOTIFICATION_ID,
+                        notification,
+                        ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE,
+                    )
+                } catch (e2: Exception) {
+                    Log.e(LOG_TAG, "CRITICAL: Failed to start FGS even with fallback.", e2)
+                    sendBroadcastEvent(REQUEST_LOCATION_PERMISSIONS)
+                    serviceStop()
+                }
+            }
+        }
     }
 
-    override fun getCurrentQuery(): Query? = workflowOrchestrator.getCurrentQuery()
-    override fun findAlertFor(metric: ObdMetric): List<Alert> = workflowOrchestrator.findAlertFor(metric)
-    override fun isRunning(): Boolean = workflowOrchestrator.isRunning()
-    override fun getDiagnostics(): Diagnostics = workflowOrchestrator.diagnostics()
-    override fun findHistogramFor(metric: ObdMetric): Histogram = workflowOrchestrator.findHistogramFor(metric)
-    override fun findRateFor(metric: ObdMetric): Optional<Rate> = workflowOrchestrator.findRateFor(metric)
-    override fun getPidDefinitionRegistry(): PidDefinitionRegistry = workflowOrchestrator.pidDefinitionRegistry()
-    override fun isDTCEnabled(): Boolean = workflowOrchestrator.isDTCEnabled()
-
-    // --- Helper Methods ---
-
-    private fun enqueueWork(intentAction: String, func: (p: Intent) -> Unit = {}) {
+    private fun enqueueWork(
+        intentAction: String,
+        func: (p: Intent) -> Unit = {},
+    ) {
         try {
-            getContext()?.let { context ->
-                val intent = Intent(context, DataLoggerService::class.java).apply {
+            val intent =
+                Intent(this, DataLoggerService::class.java).apply {
                     action = intentAction
                     putExtra("init", 1)
                 }
-                func(intent)
+            func(intent)
 
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                    context.startForegroundService(intent)
-                } else {
-                    context.startService(intent)
-                }
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                startForegroundService(intent)
+            } else {
+                startService(intent)
             }
         } catch (e: IllegalStateException) {
             Log.e(LOG_TAG, "Failed to enqueue the work", e)
@@ -241,33 +213,35 @@ internal class DataLoggerService : Service(), DataLogger {
 
     private fun createNotification(): Notification {
         // Fix for NullPointerException in tests/edge cases where LaunchIntent is null
-        val contentIntent = packageManager.getLaunchIntentForPackage(packageName)?.let {
-            PendingIntent.getActivity(
-                this,
-                0,
-                it,
-                PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
-            )
-        }
+        val contentIntent =
+            packageManager.getLaunchIntentForPackage(packageName)?.let {
+                PendingIntent.getActivity(
+                    this,
+                    0,
+                    it,
+                    PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
+                )
+            }
 
-        return NotificationCompat.Builder(this, NOTIFICATION_CHANNEL_ID)
+        return NotificationCompat
+            .Builder(this, NOTIFICATION_CHANNEL_ID)
             .setContentTitle("Vehicle Telemetry Service")
             .setContentText("Logging OBD & GPS data in background...")
             .setSmallIcon(R.drawable.ic_mygiulia_logo)
             .apply {
                 contentIntent?.let { setContentIntent(it) }
-            }
-            .setOngoing(true)
+            }.setOngoing(true)
             .build()
     }
 
     private fun createNotificationChannel() {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val serviceChannel = NotificationChannel(
-                NOTIFICATION_CHANNEL_ID,
-                "OBD Logger Service",
-                NotificationManager.IMPORTANCE_LOW
-            )
+            val serviceChannel =
+                NotificationChannel(
+                    NOTIFICATION_CHANNEL_ID,
+                    "OBD Logger Service",
+                    NotificationManager.IMPORTANCE_LOW,
+                )
             val manager = getSystemService(NotificationManager::class.java)
             manager.createNotificationChannel(serviceChannel)
         }
diff --git a/datalogger/src/main/java/org/obd/graphs/bl/datalogger/VehicleCapabilitiesManager.kt b/datalogger/src/main/java/org/obd/graphs/bl/datalogger/VehicleCapabilitiesManager.kt
index 7aefecb8..3da309b0 100644
--- a/datalogger/src/main/java/org/obd/graphs/bl/datalogger/VehicleCapabilitiesManager.kt
+++ b/datalogger/src/main/java/org/obd/graphs/bl/datalogger/VehicleCapabilitiesManager.kt
@@ -63,7 +63,7 @@ class VehicleCapabilitiesManager {
     }
 
     fun getCapabilities(): MutableList<String> {
-        val pidList = dataLogger.getPidDefinitionRegistry().findAll()
+        val pidList = DataLoggerRepository.getPidDefinitionRegistry().findAll()
         return Prefs.getStringSet(PREF_VEHICLE_CAPABILITIES, emptySet())!!.toMutableList()
             .sortedWith(compareBy { t -> pidList.firstOrNull { a -> a.pid == t.uppercase() } }).toMutableList()
     }
diff --git a/datalogger/src/main/java/org/obd/graphs/bl/datalogger/WorkflowOrchestrator.kt b/datalogger/src/main/java/org/obd/graphs/bl/datalogger/WorkflowOrchestrator.kt
index b3877f47..44b1b3d2 100644
--- a/datalogger/src/main/java/org/obd/graphs/bl/datalogger/WorkflowOrchestrator.kt
+++ b/datalogger/src/main/java/org/obd/graphs/bl/datalogger/WorkflowOrchestrator.kt
@@ -26,7 +26,6 @@ import org.obd.graphs.bl.datalogger.connectors.ConnectionManager
 import org.obd.graphs.bl.query.Query
 import org.obd.graphs.bl.trip.tripManager
 import org.obd.graphs.profile.PROFILE_CHANGED_EVENT
-import org.obd.metrics.alert.Alert
 import org.obd.metrics.api.Workflow
 import org.obd.metrics.api.WorkflowExecutionStatus
 import org.obd.metrics.api.model.*
@@ -165,8 +164,6 @@ internal class WorkflowOrchestrator internal constructor() {
 
     fun findRateFor(metric: ObdMetric): Optional<Rate> = workflow.diagnostics.rate().findBy(RateType.MEAN, metric.command.pid)
 
-    fun findAlertFor(metric: ObdMetric): List<Alert> = workflow.alerts.findBy(metric.command.pid)
-
     fun pidDefinitionRegistry(): PidDefinitionRegistry = workflow.pidRegistry
 
     fun stop() {
diff --git a/datalogger/src/main/java/org/obd/graphs/bl/generator/MetricGeneratorDefinition.kt b/datalogger/src/main/java/org/obd/graphs/bl/generator/MetricGeneratorDefinition.kt
index c4a864a3..c6961bac 100644
--- a/datalogger/src/main/java/org/obd/graphs/bl/generator/MetricGeneratorDefinition.kt
+++ b/datalogger/src/main/java/org/obd/graphs/bl/generator/MetricGeneratorDefinition.kt
@@ -16,7 +16,7 @@
  */
 package org.obd.graphs.bl.generator
 
-import org.obd.graphs.bl.datalogger.dataLogger
+
 import org.obd.graphs.bl.datalogger.Pid
 import org.obd.metrics.pid.PidDefinition
 import org.obd.metrics.pid.PidDefinitionRegistry
diff --git a/datalogger/src/main/java/org/obd/graphs/bl/generator/MetricsGenerator.kt b/datalogger/src/main/java/org/obd/graphs/bl/generator/MetricsGenerator.kt
index bb65a7a2..a2db76bf 100644
--- a/datalogger/src/main/java/org/obd/graphs/bl/generator/MetricsGenerator.kt
+++ b/datalogger/src/main/java/org/obd/graphs/bl/generator/MetricsGenerator.kt
@@ -18,8 +18,8 @@ package org.obd.graphs.bl.generator
 
 import android.os.Handler
 import android.os.Looper
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.bl.datalogger.MetricsProcessor
-import org.obd.graphs.bl.datalogger.dataLogger
 import org.obd.graphs.bl.query.Query
 import org.obd.graphs.preferences.Prefs
 import org.obd.metrics.api.model.ObdMetric
@@ -59,8 +59,8 @@ class MetricsGenerator(private val debugBuild: Boolean) : MetricsProcessor {
     override fun onRunning(vehicleCapabilities: VehicleCapabilities?) {
 
         if (isGeneratorEnabled()) {
-            val metrics = generateMetricsFor(dataLogger.getPidDefinitionRegistry(),
-                dataLogger.getCurrentQuery())
+            val metrics = generateMetricsFor(DataLoggerRepository.getPidDefinitionRegistry(),
+                DataLoggerRepository.getCurrentQuery())
 
             if (!broadcasterLaunched) {
                 broadcasterLaunched = true
@@ -93,7 +93,7 @@ class MetricsGenerator(private val debugBuild: Boolean) : MetricsProcessor {
             if (metrics.containsKey(id)) {
                 add(metrics[id]!!)
             } else {
-                val pid = dataLogger.getPidDefinitionRegistry().findBy(id)
+                val pid = DataLoggerRepository.getPidDefinitionRegistry().findBy(id)
                 val metric = MetricGeneratorDefinition(
                     pid = pid,
                     data = generateSequenceFor(pid)
diff --git a/datalogger/src/main/java/org/obd/graphs/bl/gps/GpsMetricsEmitter.kt b/datalogger/src/main/java/org/obd/graphs/bl/gps/GpsMetricsEmitter.kt
index 74ff10fd..3d230550 100644
--- a/datalogger/src/main/java/org/obd/graphs/bl/gps/GpsMetricsEmitter.kt
+++ b/datalogger/src/main/java/org/obd/graphs/bl/gps/GpsMetricsEmitter.kt
@@ -30,9 +30,9 @@ import android.os.Looper
 import android.util.Log
 import org.obd.graphs.LOCATION_IS_DISABLED
 import org.obd.graphs.Permissions
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.bl.datalogger.MetricsProcessor
 import org.obd.graphs.bl.datalogger.Pid
-import org.obd.graphs.bl.datalogger.dataLogger
 import org.obd.graphs.bl.datalogger.dataLoggerSettings
 import org.obd.graphs.getContext
 import org.obd.graphs.sendBroadcastEvent
@@ -72,7 +72,7 @@ internal class GpsMetricsEmitter : MetricsProcessor {
 
     override fun init(replyObserver: ReplyObserver<Reply<*>>) {
         this.replyObserver = replyObserver
-        val registry = dataLogger.getPidDefinitionRegistry()
+        val registry = DataLoggerRepository.getPidDefinitionRegistry()
         locationCommand = ObdCommand(registry.findBy(Pid.GPS_LOCATION_PID_ID.id))
     }
 
diff --git a/datalogger/src/main/java/org/obd/graphs/bl/query/QueryStrategyOrchestrator.kt b/datalogger/src/main/java/org/obd/graphs/bl/query/QueryStrategyOrchestrator.kt
index 5e60e6c5..3c61178c 100644
--- a/datalogger/src/main/java/org/obd/graphs/bl/query/QueryStrategyOrchestrator.kt
+++ b/datalogger/src/main/java/org/obd/graphs/bl/query/QueryStrategyOrchestrator.kt
@@ -23,41 +23,46 @@ import org.obd.graphs.preferences.Prefs
 import org.obd.graphs.preferences.getLongSet
 import org.obd.graphs.runAsync
 
-private const val LOG_KEY = "QueryStrategyOrchestrator"
-
-internal class QueryStrategyOrchestrator : java.io.Serializable, Query {
-
-    private val strategies: Map<QueryStrategyType, QueryStrategy> = mutableMapOf<QueryStrategyType, QueryStrategy>().apply {
-        runAsync {
-            this[QueryStrategyType.SHARED_QUERY] = SharedQueryStrategy()
-            this[QueryStrategyType.DRAG_RACING_QUERY] = DragRacingQueryStrategy()
-            this[QueryStrategyType.INDIVIDUAL_QUERY] = IndividualQueryStrategy()
-            this[QueryStrategyType.ROUTINES_QUERY] = RoutinesQueryStrategy()
-            this[QueryStrategyType.TRIP_INFO_QUERY] = TripInfoQueryStrategy()
-            this[QueryStrategyType.PERFORMANCE_QUERY] = PerformanceQueryStrategy()
+private const val LOG_KEY = "QueryOrchestrator"
+
+internal class QueryStrategyOrchestrator :
+    java.io.Serializable,
+    Query {
+    private val strategies: Map<QueryStrategyType, QueryStrategy> =
+        mutableMapOf<QueryStrategyType, QueryStrategy>().apply {
+            runAsync {
+                this[QueryStrategyType.SHARED_QUERY] = SharedQueryStrategy()
+                this[QueryStrategyType.DRAG_RACING_QUERY] = DragRacingQueryStrategy()
+                this[QueryStrategyType.INDIVIDUAL_QUERY] = IndividualQueryStrategy()
+                this[QueryStrategyType.ROUTINES_QUERY] = RoutinesQueryStrategy()
+                this[QueryStrategyType.TRIP_INFO_QUERY] = TripInfoQueryStrategy()
+                this[QueryStrategyType.PERFORMANCE_QUERY] = PerformanceQueryStrategy()
+            }
         }
-    }
 
     private var strategy: QueryStrategyType = QueryStrategyType.SHARED_QUERY
+
     override fun getDefaults(): Set<Long> = strategies[strategy]?.getDefaults() ?: emptySet()
 
-    override fun getIDs(): MutableSet<Long>  {
+    override fun getIDs(): MutableSet<Long> {
         val pids = strategies[strategy]?.getPIDs() ?: mutableSetOf()
 
-        //decorate with Vehicle Status PID
+        // decorate with Vehicle Status PID
         if (dataLoggerSettings.instance().vehicleStatusPanelEnabled ||
-            dataLoggerSettings.instance().vehicleStatusDisconnectWhenOff){
+            dataLoggerSettings.instance().vehicleStatusDisconnectWhenOff
+        ) {
             pids.add(Pid.VEHICLE_STATUS_PID_ID.id)
         }
-
-        Log.d(LOG_KEY,"Gets PIDs '$pids' for current strategy $strategy")
+        if (Log.isLoggable(LOG_KEY, Log.DEBUG)) {
+            Log.d(LOG_KEY, "Gets PIDs '$pids' for current strategy $strategy")
+        }
         return pids
     }
 
     override fun getStrategy(): QueryStrategyType = strategy
 
     override fun setStrategy(queryStrategyType: QueryStrategyType): Query {
-        Log.d(LOG_KEY,"Sets new strategy $queryStrategyType")
+        Log.d(LOG_KEY, "Sets new strategy $queryStrategyType")
         this.strategy = queryStrategyType
         return this
     }
@@ -70,19 +75,23 @@ internal class QueryStrategyOrchestrator : java.io.Serializable, Query {
     override fun filterBy(filter: String): Set<Long> {
         val query = getIDs()
         val selection = Prefs.getLongSet(filter)
-        val intersection =  selection.filter { query.contains(it) }.toSet()
+        val intersection = selection.filter { query.contains(it) }.toSet()
 
-        Log.i(LOG_KEY,"Individual query enabled:${isIndividualQuerySelected()}, " +
-                " key:$filter, query=$query,selection=$selection, intersection=$intersection")
+        Log.i(
+            LOG_KEY,
+            "Individual query enabled:${isIndividualQuerySelected()}, " +
+                " key:$filter, query=$query,selection=$selection, intersection=$intersection",
+        )
 
         return if (isIndividualQuerySelected()) {
-            Log.i(LOG_KEY,"Returning selection=$selection")
+            Log.i(LOG_KEY, "Returning selection=$selection")
             selection
         } else {
-            Log.i(LOG_KEY,"Returning intersection=$intersection")
+            Log.i(LOG_KEY, "Returning intersection=$intersection")
             intersection
         }
     }
+
     override fun apply(filter: String): Query =
         if (isIndividualQuerySelected()) {
             setStrategy(QueryStrategyType.INDIVIDUAL_QUERY)
diff --git a/datalogger/src/main/java/org/obd/graphs/bl/trip/DefaultTripManager.kt b/datalogger/src/main/java/org/obd/graphs/bl/trip/DefaultTripManager.kt
index c1cadb24..b8e2968a 100644
--- a/datalogger/src/main/java/org/obd/graphs/bl/trip/DefaultTripManager.kt
+++ b/datalogger/src/main/java/org/obd/graphs/bl/trip/DefaultTripManager.kt
@@ -18,8 +18,8 @@ package org.obd.graphs.bl.trip
 
 import android.content.Context
 import android.util.Log
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.bl.datalogger.MetricsProcessor
-import org.obd.graphs.bl.datalogger.dataLogger
 import org.obd.graphs.bl.datalogger.scaleToRange
 import org.obd.graphs.getContext
 import org.obd.graphs.isNumber
@@ -125,8 +125,8 @@ internal class DefaultTripManager :
                 } else {
                     try {
                         f()
-                        val histogram = dataLogger.getDiagnostics().histogram()
-                        val pidDefinitionRegistry = dataLogger.getPidDefinitionRegistry()
+                        val histogram = DataLoggerRepository.getDiagnostics().histogram()
+                        val pidDefinitionRegistry = DataLoggerRepository.getPidDefinitionRegistry()
 
                         trip.entries.forEach { (t, u) ->
                             val p = pidDefinitionRegistry.findBy(t)
diff --git a/datalogger/src/main/java/org/obd/graphs/bl/trip/TripManager.kt b/datalogger/src/main/java/org/obd/graphs/bl/trip/TripManager.kt
index 2a11ded4..1c512bf2 100644
--- a/datalogger/src/main/java/org/obd/graphs/bl/trip/TripManager.kt
+++ b/datalogger/src/main/java/org/obd/graphs/bl/trip/TripManager.kt
@@ -19,8 +19,8 @@ package org.obd.graphs.bl.trip
 import android.content.Context
 import android.util.Log
 import org.obd.graphs.*
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.bl.datalogger.MetricsProcessor
-import org.obd.graphs.bl.datalogger.dataLogger
 import org.obd.graphs.commons.R
 
 private const val LOG_TAG = "TripManager"
@@ -48,7 +48,7 @@ interface TripManager : MetricsProcessor {
     fun deleteTrip(trip: TripFileDesc)
     fun loadTrip(tripName: String)
     fun loadTripAsync(tripName: String){
-        if (!dataLogger.isRunning()) {
+        if (!DataLoggerRepository.isRunning()) {
             sendBroadcastEvent(SCREEN_LOCK_PROGRESS_EVENT, getContext()?.getText(R.string.dialog_screen_lock_trip_load_message) as String)
             runAsync (wait = false) {
                 try {
diff --git a/datalogger/src/test/java/org/obd/graphs/bl/DataLoggerServiceTest.kt b/datalogger/src/test/java/org/obd/graphs/bl/DataLoggerServiceTest.kt
index d5f3659f..c8209e2a 100644
--- a/datalogger/src/test/java/org/obd/graphs/bl/DataLoggerServiceTest.kt
+++ b/datalogger/src/test/java/org/obd/graphs/bl/DataLoggerServiceTest.kt
@@ -32,9 +32,9 @@ import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.obd.graphs.Permissions
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.bl.datalogger.DataLoggerService
 import org.obd.graphs.bl.datalogger.WorkflowOrchestrator
-import org.obd.graphs.bl.datalogger.setWorkflowOrchestrator
 import org.obd.graphs.bl.query.Query
 import org.robolectric.Robolectric
 import org.robolectric.RobolectricTestRunner
@@ -50,7 +50,7 @@ class DataLoggerServiceTest : TestSetup() {
     @Before
     override fun setup() {
         super.setup()
-        setWorkflowOrchestrator(mockOrchestrator)
+        DataLoggerRepository.setWorkflowOrchestrator(mockOrchestrator)
     }
 
     @After
@@ -159,12 +159,12 @@ class DataLoggerServiceTest : TestSetup() {
             }
 
         // Inject the mock (Ensures the service uses OUR object, not a real one)
-        setWorkflowOrchestrator(mockOrchestrator)
+        DataLoggerRepository.setWorkflowOrchestrator(mockOrchestrator)
 
         val controller = Robolectric.buildService(DataLoggerService::class.java, intent)
 
         // Act
-        val service = controller.create().get()
+        controller.create().get()
         controller.startCommand(0, 1)
 
         // Assert
diff --git a/datalogger/src/test/java/org/obd/graphs/bl/gps/GpsMetricsEmitterTest.kt b/datalogger/src/test/java/org/obd/graphs/bl/gps/GpsMetricsEmitterTest.kt
index f2a87cb8..8ab7ed5b 100644
--- a/datalogger/src/test/java/org/obd/graphs/bl/gps/GpsMetricsEmitterTest.kt
+++ b/datalogger/src/test/java/org/obd/graphs/bl/gps/GpsMetricsEmitterTest.kt
@@ -29,7 +29,7 @@ import org.junit.Test
 import org.junit.runner.RunWith
 import org.obd.graphs.Permissions
 import org.obd.graphs.bl.TestSetup
-import org.obd.graphs.bl.datalogger.dataLogger
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.bl.datalogger.dataLoggerSettings
 import org.obd.metrics.api.model.ObdMetric
 import org.obd.metrics.api.model.Reply
@@ -62,7 +62,7 @@ class GpsMetricsEmitterTest : TestSetup() {
         super.setup()
         mockkObject(Permissions)
         mockkObject(dataLoggerSettings)
-        mockkObject(dataLogger)
+        mockkObject(DataLoggerRepository)
 
 
         // Mock System Service retrieval
@@ -86,7 +86,7 @@ class GpsMetricsEmitterTest : TestSetup() {
         every { mockLocationManager.removeUpdates(any<LocationListener>()) } just Runs
 
         // Mock Registry & Settings
-        every { dataLogger.getPidDefinitionRegistry() } returns mockRegistry
+        every { DataLoggerRepository.getPidDefinitionRegistry() } returns mockRegistry
         // Return dummy PID definition so the command initialization succeeds
         val dummyPid = mockk<PidDefinition>(relaxed = true) {
             every { id } returns 100L
diff --git a/dragracing/src/test/java/org/obd/graphs/bl/drag/InMemoryDragRacingRegistryTest.kt b/dragracing/src/test/java/org/obd/graphs/bl/drag/InMemoryDragRacingRegistryTest.kt
index 07eb5a89..37558353 100644
--- a/dragracing/src/test/java/org/obd/graphs/bl/drag/InMemoryDragRacingRegistryTest.kt
+++ b/dragracing/src/test/java/org/obd/graphs/bl/drag/InMemoryDragRacingRegistryTest.kt
@@ -24,6 +24,7 @@ import org.junit.After
 import org.junit.Before
 import org.junit.Test
 import org.obd.graphs.preferences.Prefs
+import org.obd.graphs.preferences.initPrefs
 import org.obd.graphs.preferences.updateString
 import java.lang.ref.WeakReference
 
@@ -45,10 +46,7 @@ class InMemoryDragRacingRegistryTest {
         mockkStatic("org.obd.graphs.preferences.PreferencesKt")
         mockkStatic("org.obd.graphs.ContextKt")
 
-        val field = Class.forName("org.obd.graphs.ContextKt")
-            .getDeclaredField("activityContext")
-        field.isAccessible = true
-        field.set(null, WeakReference(mockContext))
+        initPrefs(mockContext)
 
         mockkObject(Prefs)
         every { Prefs.getString(any(), any()) } returns null
diff --git a/integrations/src/main/java/org/obd/graphs.integrations/gcp/gdrive/DefaultTripLogDriveManager.kt b/integrations/src/main/java/org/obd/graphs.integrations/gcp/gdrive/DefaultTripLogDriveManager.kt
index 53af82df..9eb52017 100644
--- a/integrations/src/main/java/org/obd/graphs.integrations/gcp/gdrive/DefaultTripLogDriveManager.kt
+++ b/integrations/src/main/java/org/obd/graphs.integrations/gcp/gdrive/DefaultTripLogDriveManager.kt
@@ -17,13 +17,12 @@
 package org.obd.graphs.integrations.gcp.gdrive
 
 import android.app.Activity
-import android.util.Log
 import androidx.fragment.app.Fragment
 import org.obd.graphs.SCREEN_UNLOCK_PROGRESS_EVENT
 import org.obd.graphs.TRIPS_UPLOAD_FAILED
 import org.obd.graphs.TRIPS_UPLOAD_NO_FILES_SELECTED
 import org.obd.graphs.TRIPS_UPLOAD_SUCCESSFUL
-import org.obd.graphs.bl.datalogger.dataLogger
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.bl.datalogger.scaleToRange
 import org.obd.graphs.bl.trip.TripDescParser
 import org.obd.graphs.integrations.log.OutputType
@@ -48,7 +47,7 @@ internal open class DefaultTripLogDriveManager(
                     sendBroadcastEvent(TRIPS_UPLOAD_NO_FILES_SELECTED)
                 } else {
                     val folderId = drive.findFolderIdRecursive("mygiulia/trips")
-                    val definitions = dataLogger.getPidDefinitionRegistry().findAll()
+                    val definitions = DataLoggerRepository.getPidDefinitionRegistry().findAll()
                     val signalsMapper = definitions.associate { it.id.toInt() to it.description.replace("\n", " ") }
                     val pidMap = definitions.associateBy { it.id.toInt() }
                     val transformer =
diff --git a/profile/src/test/java/org/obd/graphs/profile/TestSetup.kt b/profile/src/test/java/org/obd/graphs/profile/TestSetup.kt
index 3127020b..306324cb 100644
--- a/profile/src/test/java/org/obd/graphs/profile/TestSetup.kt
+++ b/profile/src/test/java/org/obd/graphs/profile/TestSetup.kt
@@ -31,6 +31,7 @@ import io.mockk.unmockkAll
 import org.junit.After
 import org.junit.Before
 import org.obd.graphs.preferences.Prefs
+import org.obd.graphs.preferences.initPrefs
 import org.obd.graphs.runAsync
 import org.obd.graphs.sendBroadcastEvent
 import java.io.File
@@ -74,7 +75,9 @@ import java.util.Properties
         mockIntent()
         mockEnvironment()
         profileService = DefaultProfileService()
-  }
+
+        initPrefs(context)
+    }
 
     protected fun mockPropertiesFiles(assetFilenames: List<String> = listOf("alfa_2_0_gme.properties")) {
         val basePath = "src/test/assets"
diff --git a/screen_renderer/src/main/java/org/obd/graphs/renderer/AbstractDrawer.kt b/screen_renderer/src/main/java/org/obd/graphs/renderer/AbstractDrawer.kt
index d7d3d766..3f8cba4f 100644
--- a/screen_renderer/src/main/java/org/obd/graphs/renderer/AbstractDrawer.kt
+++ b/screen_renderer/src/main/java/org/obd/graphs/renderer/AbstractDrawer.kt
@@ -26,9 +26,9 @@ import android.graphics.Rect
 import android.graphics.Typeface
 import org.obd.graphs.bl.collector.Metric
 import org.obd.graphs.bl.collector.MetricsCollector
+import org.obd.graphs.bl.datalogger.DataLoggerRepository
 import org.obd.graphs.bl.datalogger.Pid
 import org.obd.graphs.bl.datalogger.WorkflowStatus
-import org.obd.graphs.bl.datalogger.dataLogger
 import org.obd.graphs.commons.R
 import org.obd.graphs.format
 import org.obd.graphs.mapRange
@@ -195,7 +195,7 @@ internal abstract class AbstractDrawer(
 
         val color: Int
         val colorTheme = settings.getColorTheme()
-        text = dataLogger.status().name.lowercase()
+        text = DataLoggerRepository.status().name.lowercase()
 
         color = mapColor(colorTheme)
 
@@ -316,7 +316,7 @@ internal abstract class AbstractDrawer(
     }
 
     private fun mapColor(colorTheme: ColorTheme) =
-        when (dataLogger.status()) {
+        when (DataLoggerRepository.status()) {
             WorkflowStatus.Disconnected -> {
                 colorTheme.statusDisconnectedColor
             }