diff --git a/.idea/deploymentTargetSelector.xml b/.idea/deploymentTargetSelector.xml
index 5fbb504..1f57fec 100644
--- a/.idea/deploymentTargetSelector.xml
+++ b/.idea/deploymentTargetSelector.xml
@@ -4,10 +4,10 @@
     <selectionStates>
       <SelectionState runConfigName="app">
         <option name="selectionMode" value="DROPDOWN" />
-        <DropdownSelection timestamp="2025-01-19T01:43:52.867352300Z">
+        <DropdownSelection timestamp="2025-01-20T20:16:20.979872700Z">
           <Target type="DEFAULT_BOOT">
             <handle>
-              <DeviceId pluginId="Default" identifier="serial=192.168.1.123:39989;connection=1581a863" />
+              <DeviceId pluginId="Default" identifier="serial=192.168.1.123:38149;connection=04202950" />
             </handle>
           </Target>
         </DropdownSelection>
diff --git a/README.md b/README.md
index 0b94272..f364a4e 100644
--- a/README.md
+++ b/README.md
@@ -4,40 +4,52 @@ OnePlus Flash Control is an Android application designed specifically for rooted
 
 By leveraging root access, the app allows direct modification of system-level files to control the LED behavior, enabling a customized and enhanced flashlight experience on your OnePlus device.
 
+## Support project
+
+[!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://buymeacoffee.com/bartixxx32)
 ## Features
 
 - **Master Brightness Control:** Adjust overall LED brightness with a single slider.
 - **Individual LED Control:** Independently control the brightness of white and yellow LEDs.
-- **"Eye Destroyer" Mode:** A feature to momentarily turn on the LEDs at maximum brightness for both white and yellow LEDs. Use with caution as it emits very intense light!
+- **"Eye Destroyer" Mode:** A feature to momentarily turn on the LEDs at maximum brightness for both white and yellow LEDs.
+- ⚠️ Use with caution as it emits very intense light and generates significant heat! ⚠️
+- Safety features to prevent prolonged high brightness usage:
+  - If brightness exceeds 120 (on a scale of 0-255) for more than 20 seconds, it automatically reduces back to the default Android brightness value to prevent overheating or damage.
+  - "Eye Destroyer" Mode enforces a 5-second cooldown between uses to ensure safety and prevent excessive heat buildup.
+
 - **Compatibility:** Designed for rooted OnePlus devices only.
 - **Quad LED Control:** Control up to four LEDs on supported OnePlus devices (OnePlus 9 series and newer). Currently in development:
   - Support for controlling additional LED modules (warm and cool tones)
   - Brightness synchronization across all LEDs
+- **Quick Settings Tile:** Conveniently control LED brightness and state using a Quick Settings tile:
+  - Single tap cycles through brightness levels.
+  - Double tap when LEDs are off to turn them on at 80% brightness.
+  - Double tap when LEDs are on to turn them off.
+- **Secret Action:** Unlock hidden features by tapping the app's title 5 times within 5 seconds, enabling a fun experimental mode.
 
-
-  Testing needed: If you have a OnePlus 9/10/11 series device, please help by:
-  - Confirming the number and types of LED modules on your device
-  - Testing brightness control functionality and reporting any issues
-  - Sharing your device model and OxygenOS/Custom ROM version in GitHub Issues
+**Testing needed:** If you have a OnePlus 9/10/11/12 series device, please help by:
+- Confirming the number and types of LED modules on your device
+- Testing brightness control functionality and reporting any issues
+- Sharing your device model and OxygenOS/Custom ROM version in GitHub Issues
 
 ## Preview Screenshot
 
 [![Preview Screenshot](https://ik.imagekit.io/bartixxx32/ghmirror/tr:w-0.2,r-20/Bartixxx32/Opflashcontrol-app/master/metadata/en-US/images/phoneScreenshots/screenshot1.png)](https://ik.imagekit.io/bartixxx32/ghmirror/Bartixxx32/Opflashcontrol-app/master/metadata/en-US/images/phoneScreenshots/screenshot1.png)
 [![Preview Screenshot](https://ik.imagekit.io/bartixxx32/ghmirror/tr:w-0.2,r-20/Bartixxx32/Opflashcontrol-app/master/metadata/en-US/images/phoneScreenshots/screenshot2.png)](https://ik.imagekit.io/bartixxx32/ghmirror/Bartixxx32/Opflashcontrol-app/master/metadata/en-US/images/phoneScreenshots/screenshot1.png)
+[![Preview Screenshot](https://ik.imagekit.io/bartixxx32/ghmirror/tr:w-0.2,r-20/Bartixxx32/Opflashcontrol-app/master/metadata/en-US/images/phoneScreenshots/screenshot3.png)](https://ik.imagekit.io/bartixxx32/ghmirror/Bartixxx32/Opflashcontrol-app/master/metadata/en-US/images/phoneScreenshots/screenshot3.png)
 
-## Support project
-
-[!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://buymeacoffee.com/bartixxx32)
 
 
 ## Download
 
-[<img src="https://fdroid.gitlab.io/artwork/badge/get-it-on.png"
-     alt="Get it on F-Droid"
-     height="80">](https://f-droid.org/packages/com.bartixxx.opflashcontrol/)
 
-[<img src="https://www.openapk.net/images/badge_obtainium.png"
-     alt="Get it on Obtainium"
-     height="80">](https://apps.obtainium.imranr.dev/redirect?r=obtainium://app/%7B%22id%22%3A%22com.bartixxx.opflashcontrol%22%2C%22url%22%3A%22https%3A%2F%2Fgithub.com%2FBartixxx32%2FOpflashcontrol-app%22%2C%22author%22%3A%22Bartixxx32%22%2C%22name%22%3A%22OnePlus%20Flash%20Control%22%2C%22preferredApkIndex%22%3A0%2C%22additionalSettings%22%3A%22%7B%5C%22includePrereleases%5C%22%3Atrue%2C%5C%22fallbackToOlderReleases%5C%22%3Atrue%2C%5C%22filterReleaseTitlesByRegEx%5C%22%3A%5C%22%5C%22%2C%5C%22filterReleaseNotesByRegEx%5C%22%3A%5C%22%5C%22%2C%5C%22verifyLatestTag%5C%22%3Afalse%2C%5C%22dontSortReleasesList%5C%22%3Afalse%2C%5C%22useLatestAssetDateAsReleaseDate%5C%22%3Afalse%2C%5C%22releaseTitleAsVersion%5C%22%3Afalse%2C%5C%22trackOnly%5C%22%3Afalse%2C%5C%22versionExtractionRegEx%5C%22%3A%5C%22%5C%22%2C%5C%22matchGroupToUse%5C%22%3A%5C%22%5C%22%2C%5C%22versionDetection%5C%22%3Atrue%2C%5C%22releaseDateAsVersion%5C%22%3Afalse%2C%5C%22useVersionCodeAsOSVersion%5C%22%3Afalse%2C%5C%22apkFilterRegEx%5C%22%3A%5C%22%5C%22%2C%5C%22invertAPKFilter%5C%22%3Afalse%2C%5C%22autoApkFilterByArch%5C%22%3Atrue%2C%5C%22appName%5C%22%3A%5C%22%5C%22%2C%5C%22shizukuPretendToBeGooglePlay%5C%22%3Afalse%2C%5C%22allowInsecure%5C%22%3Afalse%2C%5C%22exemptFromBackgroundUpdates%5C%22%3Afalse%2C%5C%22skipUpdateNotifications%5C%22%3Afalse%2C%5C%22about%5C%22%3A%5C%22%5C%22%2C%5C%22refreshBeforeDownload%5C%22%3Afalse%7D%22%2C%22overrideSource%22%3Anull%7D)
+
+[<img src="https://github.com/ImranR98/Obtainium/blob/main/assets/graphics/badge_obtainium.png"
+alt="Get it on Obtainium"
+height="80">](https://apps.obtainium.imranr.dev/redirect?r=obtainium://app/%7B%22id%22%3A%22com.bartixxx.opflashcontrol%22%2C%22url%22%3A%22https%3A%2F%2Fgithub.com%2FBartixxx32%2FOpflashcontrol-app%22%2C%22author%22%3A%22Bartixxx32%22%2C%22name%22%3A%22OnePlus%20Flash%20Control%22%2C%22preferredApkIndex%22%3A0%2C%22additionalSettings%22%3A%22%7B%5C%22includePrereleases%5C%22%3Atrue%2C%5C%22fallbackToOlderReleases%5C%22%3Atrue%2C%5C%22filterReleaseTitlesByRegEx%5C%22%3A%5C%22%5C%22%2C%5C%22filterReleaseNotesByRegEx%5C%22%3A%5C%22%5C%22%2C%5C%22verifyLatestTag%5C%22%3Afalse%2C%5C%22dontSortReleasesList%5C%22%3Afalse%2C%5C%22useLatestAssetDateAsReleaseDate%5C%22%3Afalse%2C%5C%22releaseTitleAsVersion%5C%22%3Afalse%2C%5C%22trackOnly%5C%22%3Afalse%2C%5C%22versionExtractionRegEx%5C%22%3A%5C%22%5C%22%2C%5C%22matchGroupToUse%5C%22%3A%5C%22%5C%22%2C%5C%22versionDetection%5C%22%3Atrue%2C%5C%22releaseDateAsVersion%5C%22%3Afalse%2C%5C%22useVersionCodeAsOSVersion%5C%22%3Afalse%2C%5C%22apkFilterRegEx%5C%22%3A%5C%22%5C%22%2C%5C%22invertAPKFilter%5C%22%3Afalse%2C%5C%22autoApkFilterByArch%5C%22%3Atrue%2C%5C%22appName%5C%22%3A%5C%22%5C%22%2C%5C%22shizukuPretendToBeGooglePlay%5C%22%3Afalse%2C%5C%22allowInsecure%5C%22%3Afalse%2C%5C%22exemptFromBackgroundUpdates%5C%22%3Afalse%2C%5C%22skipUpdateNotifications%5C%22%3Afalse%2C%5C%22about%5C%22%3A%5C%22%5C%22%2C%5C%22refreshBeforeDownload%5C%22%3Afalse%7D%22%2C%22overrideSource%22%3Anull%7D)
+
+[<img src="https://fdroid.gitlab.io/artwork/badge/get-it-on.png"
+alt="Get it on F-Droid"
+height="80">](https://f-droid.org/packages/com.bartixxx.opflashcontrol/)
 
 Or download the latest APK from the [Releases Section](https://github.com/Bartixxx32/Opflashcontrol-app/releases/latest).
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index ef62519..b72b474 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -14,8 +14,8 @@ android {
         minSdk = 31
         targetSdk = 35
 
-        versionCode = 26
-        versionName = "1.2.3"
+        versionCode = 27
+        versionName = "1.3.0"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index be16486..dd9956e 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -18,6 +18,14 @@
         android:supportsRtl="true"
         android:theme="@style/Theme.Opflashcontrol"
         tools:targetApi="31" >
+        <service
+            android:name=".LEDControlTileService"
+            android:permission="android.permission.BIND_QUICK_SETTINGS_TILE"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.service.quicksettings.action.QS_TILE" />
+            </intent-filter>
+        </service>
         <activity
             android:name=".SupportersActivity"
             android:screenOrientation="portrait"
diff --git a/app/src/main/java/com/bartixxx/opflashcontrol/BaseActivity.kt b/app/src/main/java/com/bartixxx/opflashcontrol/BaseActivity.kt
index 45cda98..797d416 100644
--- a/app/src/main/java/com/bartixxx/opflashcontrol/BaseActivity.kt
+++ b/app/src/main/java/com/bartixxx/opflashcontrol/BaseActivity.kt
@@ -5,8 +5,6 @@ import android.util.Log
 import android.widget.*
 import androidx.appcompat.app.AppCompatActivity
 import com.google.android.material.slider.Slider
-import java.io.DataOutputStream
-import java.io.IOException
 
 abstract class BaseActivity : AppCompatActivity() {
 
@@ -26,19 +24,12 @@ abstract class BaseActivity : AppCompatActivity() {
         const val FLASH_YELLOW_LED_PATH = "/sys/class/leds/led:flash_1/brightness"
         const val FLASH_WHITE2_LED_PATH = "/sys/class/leds/led:flash_2/brightness"
         const val FLASH_YELLOW2_LED_PATH = "/sys/class/leds/led:flash_3/brightness"
-        val TOGGLE_PATHS = listOf(
-            "/sys/class/leds/led:switch_2/brightness"
-        )
     }
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
     }
 
-    // Helper method to sanitize brightness values (ensuring no 0 values are written)
-    private fun sanitizeBrightness(brightness: Int): Int {
-        return if (brightness == 0) 1 else brightness
-    }
 
     protected fun setupSlider(
         slider: Slider,
@@ -74,126 +65,4 @@ abstract class BaseActivity : AppCompatActivity() {
             }
         })
     }
-
-    protected fun controlLeds(
-        action: String,
-        whiteLedPath: String,
-        yellowLedPath: String,
-        white2LedPath: String? = null,
-        yellow2LedPath: String? = null,
-        whiteBrightness: Int,
-        yellowBrightness: Int,
-        white2Brightness: Int = 0,
-        yellow2Brightness: Int = 0,
-        showToast: Boolean = true
-    ) {
-        // Sanitize the brightness values to ensure no 0 values are written
-        val sanitizedWhiteBrightness = sanitizeBrightness(whiteBrightness)
-        val sanitizedYellowBrightness = sanitizeBrightness(yellowBrightness)
-        val sanitizedWhite2Brightness = sanitizeBrightness(white2Brightness)
-        val sanitizedYellow2Brightness = sanitizeBrightness(yellow2Brightness)
-
-        val commands = mutableListOf<String>()
-
-        if (action == "on") {
-            commands.addAll(commonOnCommands(whiteLedPath, yellowLedPath, white2LedPath, yellow2LedPath))
-            commands.addAll(listOf(
-                "echo $sanitizedWhiteBrightness > $whiteLedPath",
-                "echo $sanitizedYellowBrightness > $yellowLedPath",
-                white2LedPath?.let { "echo $sanitizedWhite2Brightness > $it" },
-                yellow2LedPath?.let { "echo $sanitizedYellow2Brightness > $it" }
-            ).filterNotNull())
-            TOGGLE_PATHS.forEach { commands.add("echo 255 > $it") }
-        } else if (action == "off") {
-            commands.addAll(commonOffCommands(whiteLedPath, yellowLedPath, white2LedPath, yellow2LedPath))
-        }
-
-        executeRootCommands(commands, showToast)
-    }
-
-    private fun commonOnCommands(white: String, yellow: String, white2: String?, yellow2: String?): List<String> {
-        return listOf(
-            "echo 80 > $white",
-            "echo 80 > $yellow",
-            white2?.let { "echo 80 > $it" },
-            yellow2?.let { "echo 80 > $it" }
-        ).filterNotNull() + TOGGLE_PATHS.map { "echo 0 > $it" }
-    }
-
-    private fun commonOffCommands(white: String, yellow: String, white2: String?, yellow2: String?): List<String> {
-        return listOf(
-            "echo 80 > $white",
-            "echo 80 > $yellow",
-            white2?.let { "echo 80 > $it" },
-            yellow2?.let { "echo 80 > $it" }
-        ).filterNotNull() + TOGGLE_PATHS.map { "echo 0 > $it" }
-    }
-
-    protected fun executeRootCommands(commands: List<String>, showToast: Boolean = true) {
-        val maxRetries = 3 // Maximum number of retries
-        val initialDelay = 1000L // Initial delay in milliseconds
-        val maxDelay = 8000L // Maximum delay (8 seconds) for exponential backoff
-        var attempt = 0
-        var delay = initialDelay
-
-        while (attempt < maxRetries) {
-            try {
-                commands.forEach { Log.d("LEDControlApp", "Executing command: $it") }
-
-                val process = Runtime.getRuntime().exec("su")
-                process.outputStream.use { outputStream ->
-                    DataOutputStream(outputStream).use { dataOutputStream ->
-                        val batchCommands = commands.joinToString("\n") + "\nexit\n"
-                        dataOutputStream.writeBytes(batchCommands)
-                        dataOutputStream.flush()
-                    }
-                }
-                process.waitFor()
-
-                // Show toast on the main thread if allowed
-                if (showToast) {
-                    runOnUiThread {
-                        Toast.makeText(this, getString(R.string.command_executed), Toast.LENGTH_SHORT).show()
-                    }
-                }
-                return // Exit the method if the command was successfully executed
-            } catch (e: IOException) {
-                e.printStackTrace()
-                if (showToast) {
-                    runOnUiThread {
-                        Toast.makeText(this, getString(R.string.error_io), Toast.LENGTH_LONG).show()
-                    }
-                }
-            } catch (e: SecurityException) {
-                e.printStackTrace()
-                if (showToast) {
-                    runOnUiThread {
-                        Toast.makeText(this, getString(R.string.error_permission), Toast.LENGTH_LONG).show()
-                    }
-                }
-            } catch (e: InterruptedException) {
-                e.printStackTrace()
-                if (showToast) {
-                    runOnUiThread {
-                        Toast.makeText(this, getString(R.string.error_interrupted), Toast.LENGTH_LONG).show()
-                    }
-                }
-            }
-
-            // Retry mechanism with exponential backoff
-            attempt++
-            if (attempt < maxRetries) {
-                Log.d("LEDControlApp", "Retrying... attempt #$attempt")
-                Thread.sleep(delay)
-                delay = (delay * 2).coerceAtMost(maxDelay) // Exponential backoff
-            }
-        }
-
-        // If we've exhausted all retries, show toast on the main thread if allowed
-        if (showToast) {
-            runOnUiThread {
-                Toast.makeText(this, getString(R.string.error_retry_failed), Toast.LENGTH_LONG).show()
-            }
-        }
-    }
 }
diff --git a/app/src/main/java/com/bartixxx/opflashcontrol/ExperimentalActivity.kt b/app/src/main/java/com/bartixxx/opflashcontrol/ExperimentalActivity.kt
index 10126b2..45380f9 100644
--- a/app/src/main/java/com/bartixxx/opflashcontrol/ExperimentalActivity.kt
+++ b/app/src/main/java/com/bartixxx/opflashcontrol/ExperimentalActivity.kt
@@ -15,9 +15,11 @@ class ExperimentalActivity : BaseActivity() {
 
     private var lightCycleDelay: Long = 500  // Default delay
     private var lightCycleBrightness: Int = 255  // Default brightness
+    private lateinit var ledController: LedController
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
+        ledController = LedController(this)
         binding = ActivityExperimentalBinding.inflate(layoutInflater)
         setContentView(binding.root)
 
@@ -119,10 +121,10 @@ class ExperimentalActivity : BaseActivity() {
                 try {
                     Log.d("ExperimentalActivity", "Light cycle: white LED on")
                     // Using the brightness from the slider
-                    controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, whiteBrightness = lightCycleBrightness, yellowBrightness = 0, showToast = false)
+                    ledController.controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, whiteBrightness = lightCycleBrightness, yellowBrightness = 0, showToast = false)
                     sleep(lightCycleDelay)  // Use slider value for delay
                     Log.d("ExperimentalActivity", "Light cycle: yellow LED on")
-                    controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, whiteBrightness = 0, yellowBrightness = lightCycleBrightness, showToast = false)
+                    ledController.controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, whiteBrightness = 0, yellowBrightness = lightCycleBrightness, showToast = false)
                     sleep(lightCycleDelay)
                 } catch (e: InterruptedException) {
                     Thread.currentThread().interrupt()
@@ -142,7 +144,7 @@ class ExperimentalActivity : BaseActivity() {
             Log.d("ExperimentalActivity", "Light thread interrupted")
         }
         lightThread = null
-        controlLeds("off", WHITE_LED_PATH, YELLOW_LED_PATH, whiteBrightness = 0, yellowBrightness = 0, showToast = false)  // Turn LEDs off
+        ledController.controlLeds("off", WHITE_LED_PATH, YELLOW_LED_PATH, whiteBrightness = 0, yellowBrightness = 0, showToast = false)  // Turn LEDs off
     }
 
     private fun startBrightnessCycle() {
@@ -157,7 +159,7 @@ class ExperimentalActivity : BaseActivity() {
                 try {
                     Log.d("ExperimentalActivity", "Brightness cycle: setting brightness to $brightness")
                     // Use the brightness from the slider
-                    controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, whiteBrightness = brightness, yellowBrightness = brightness, showToast = false)
+                    ledController.controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, whiteBrightness = brightness, yellowBrightness = brightness, showToast = false)
                     sleep(50) // Small delay for smooth transition
                     brightness += increment
                     if (brightness > 255 || brightness < 1) {
@@ -182,7 +184,7 @@ class ExperimentalActivity : BaseActivity() {
             Log.d("ExperimentalActivity", "Brightness thread interrupted")
         }
         brightnessThread = null
-        controlLeds("off", WHITE_LED_PATH, YELLOW_LED_PATH, whiteBrightness = 0, yellowBrightness = 0, showToast = false)  // Turn LEDs off
+        ledController.controlLeds("off", WHITE_LED_PATH, YELLOW_LED_PATH, whiteBrightness = 0, yellowBrightness = 0, showToast = false)  // Turn LEDs off
     }
 
     private fun navigateBackToMain() {
diff --git a/app/src/main/java/com/bartixxx/opflashcontrol/LEDControlUtil.kt b/app/src/main/java/com/bartixxx/opflashcontrol/LEDControlUtil.kt
new file mode 100644
index 0000000..58fe744
--- /dev/null
+++ b/app/src/main/java/com/bartixxx/opflashcontrol/LEDControlUtil.kt
@@ -0,0 +1,150 @@
+package com.bartixxx.opflashcontrol
+
+import android.content.Context
+import android.util.Log
+import android.widget.Toast
+import java.io.DataOutputStream
+import java.io.IOException
+
+class LedController {
+
+    companion object {
+        const val WHITE_LED_PATH = "/sys/class/leds/led:torch_0/brightness"
+        const val YELLOW_LED_PATH = "/sys/class/leds/led:torch_1/brightness"
+        const val WHITE2_LED_PATH = "/sys/class/leds/led:torch_2/brightness"
+        const val YELLOW2_LED_PATH = "/sys/class/leds/led:torch_3/brightness"
+        val TOGGLE_PATHS = listOf("/sys/class/leds/led:switch_2/brightness")
+    }
+
+    private val context: Context
+
+    constructor(context: Context) {
+        this.context = context
+    }
+
+    private fun sanitizeBrightness(brightness: Int): Int {
+        return if (brightness == 0) 1 else brightness
+    }
+
+    fun controlLeds(
+        action: String,
+        whiteLedPath: String = WHITE_LED_PATH,
+        yellowLedPath: String = YELLOW_LED_PATH,
+        white2LedPath: String? = WHITE2_LED_PATH,
+        yellow2LedPath: String? = YELLOW2_LED_PATH,
+        whiteBrightness: Int,
+        yellowBrightness: Int,
+        white2Brightness: Int = 0,
+        yellow2Brightness: Int = 0,
+        showToast: Boolean = true
+    ) {
+        val sanitizedWhiteBrightness = sanitizeBrightness(whiteBrightness)
+        val sanitizedYellowBrightness = sanitizeBrightness(yellowBrightness)
+        val sanitizedWhite2Brightness = sanitizeBrightness(white2Brightness)
+        val sanitizedYellow2Brightness = sanitizeBrightness(yellow2Brightness)
+
+        val commands = mutableListOf<String>()
+
+        if (action == "on") {
+            commands.addAll(commonOnCommands(whiteLedPath, yellowLedPath, white2LedPath, yellow2LedPath))
+            commands.addAll(listOf(
+                "echo $sanitizedWhiteBrightness > $whiteLedPath",
+                "echo $sanitizedYellowBrightness > $yellowLedPath",
+                white2LedPath?.let { "echo $sanitizedWhite2Brightness > $it" },
+                yellow2LedPath?.let { "echo $sanitizedYellow2Brightness > $it" }
+            ).filterNotNull())
+            TOGGLE_PATHS.forEach { commands.add("echo 255 > $it") }
+        } else if (action == "off") {
+            commands.addAll(commonOffCommands(whiteLedPath, yellowLedPath, white2LedPath, yellow2LedPath))
+        }
+
+        executeRootCommands(commands, showToast)
+    }
+
+    private fun commonOnCommands(
+        white: String, yellow: String, white2: String?, yellow2: String?
+    ): List<String> {
+        return listOf(
+            "echo 80 > $white",
+            "echo 80 > $yellow",
+            white2?.let { "echo 80 > $it" },
+            yellow2?.let { "echo 80 > $it" }
+        ).filterNotNull() + TOGGLE_PATHS.map { "echo 0 > $it" }
+    }
+
+    private fun commonOffCommands(
+        white: String, yellow: String, white2: String?, yellow2: String?
+    ): List<String> {
+        return listOf(
+            "echo 80 > $white",
+            "echo 80 > $yellow",
+            white2?.let { "echo 80 > $it" },
+            yellow2?.let { "echo 80 > $it" }
+        ).filterNotNull() + TOGGLE_PATHS.map { "echo 0 > $it" }
+    }
+
+    private fun executeRootCommands(commands: List<String>, showToast: Boolean = true) {
+        val maxRetries = 3 // Maximum number of retries
+        val initialDelay = 1000L // Initial delay in milliseconds
+        val maxDelay = 8000L // Maximum delay (8 seconds) for exponential backoff
+        var attempt = 0
+        var delay = initialDelay
+
+        while (attempt < maxRetries) {
+            try {
+                commands.forEach { Log.d("LEDControlApp", "Executing command: $it") }
+
+                val process = Runtime.getRuntime().exec("su")
+                process.outputStream.use { outputStream ->
+                    DataOutputStream(outputStream).use { dataOutputStream ->
+                        val batchCommands = commands.joinToString("\n") + "\nexit\n"
+                        dataOutputStream.writeBytes(batchCommands)
+                        dataOutputStream.flush()
+                    }
+                }
+                process.waitFor()
+
+                // Show toast on the main thread if allowed
+                if (showToast) {
+                    Toast.makeText(context, "Command executed", Toast.LENGTH_SHORT).show()
+                }
+                return // Exit the method if the command was successfully executed
+            } catch (e: IOException) {
+                e.printStackTrace()
+                if (showToast) {
+                    Toast.makeText(context, "Network or IO error occurred. Please try again.", Toast.LENGTH_LONG).show()
+                }
+            } catch (e: SecurityException) {
+                e.printStackTrace()
+                if (showToast) {
+                    Toast.makeText(context, "Permission denied. Please check app permissions.", Toast.LENGTH_LONG).show()
+                }
+                break // Exit loop for non-retryable error
+            } catch (e: InterruptedException) {
+                e.printStackTrace()
+                if (showToast) {
+                    Toast.makeText(context, "Operation interrupted. Please try again.", Toast.LENGTH_LONG).show()
+                }
+            } catch (e: Exception) {
+                e.printStackTrace()
+                if (showToast) {
+                    Toast.makeText(context, "An unexpected error occurred.", Toast.LENGTH_LONG).show()
+                }
+                break // Exit loop for unexpected errors
+            }
+
+            // Retry mechanism with exponential backoff
+            attempt++
+            if (attempt < maxRetries) {
+                Log.d("LEDControlApp", "Retrying... attempt #$attempt")
+                Thread.sleep(delay)
+                delay = (delay * 2).coerceAtMost(maxDelay) // Exponential backoff
+            }
+        }
+
+        // If we've exhausted all retries, show toast on the main thread if allowed
+        if (showToast) {
+            Toast.makeText(context, "Retry Failed", Toast.LENGTH_LONG).show()
+        }
+    }
+}
diff --git a/app/src/main/java/com/bartixxx/opflashcontrol/MainActivity.kt b/app/src/main/java/com/bartixxx/opflashcontrol/MainActivity.kt
index 956b7c8..e32b6b3 100644
--- a/app/src/main/java/com/bartixxx/opflashcontrol/MainActivity.kt
+++ b/app/src/main/java/com/bartixxx/opflashcontrol/MainActivity.kt
@@ -23,10 +23,12 @@ class MainActivity : BaseActivity() {
     private val SAFE_BRIGHTNESS = 80
     private val CHECK_INTERVAL = 200L // 200 ms
     private var eyeDestroyerCooldown = false // Flag to track cooldown
+    private lateinit var ledController: LedController
 
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
+        ledController = LedController(this)
         binding = ActivityMainBinding.inflate(layoutInflater)
         setContentView(binding.root)
 
@@ -54,7 +56,7 @@ class MainActivity : BaseActivity() {
                 if (!safetyTriggered) {
                     masterBrightness = progress
                     if (isLedOn && whiteBrightness <= 1 && yellowBrightness <= 1) {
-                        controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, whiteBrightness = progress, yellowBrightness = progress)
+                        ledController.controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, whiteBrightness = progress, yellowBrightness = progress)
                     }
                 }
             }
@@ -63,7 +65,7 @@ class MainActivity : BaseActivity() {
                 if (!safetyTriggered) {
                     whiteBrightness = progress
                     if (isLedOn) {
-                        controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, whiteBrightness = progress, yellowBrightness = yellowBrightness)
+                        ledController.controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, whiteBrightness = progress, yellowBrightness = yellowBrightness)
                     }
                 }
             }
@@ -72,7 +74,7 @@ class MainActivity : BaseActivity() {
                 if (!safetyTriggered) {
                     yellowBrightness = progress
                     if (isLedOn) {
-                        controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, whiteBrightness = whiteBrightness, yellowBrightness = progress)
+                        ledController.controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, whiteBrightness = whiteBrightness, yellowBrightness = progress)
                     }
                 }
             }
@@ -159,12 +161,12 @@ class MainActivity : BaseActivity() {
     private fun toggleLEDs(on: Boolean) {
         isLedOn = on
         if (on) {
-            controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH,
+            ledController.controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH,
                 whiteBrightness = if (whiteBrightness == 0) masterBrightness else whiteBrightness,
                 yellowBrightness = if (yellowBrightness == 0) masterBrightness else yellowBrightness
             )
         } else {
-            controlLeds("off", WHITE_LED_PATH, YELLOW_LED_PATH, whiteBrightness = 1, yellowBrightness = 1)
+            ledController.controlLeds("off", WHITE_LED_PATH, YELLOW_LED_PATH, whiteBrightness = 1, yellowBrightness = 1)
         }
     }
 
@@ -175,8 +177,8 @@ class MainActivity : BaseActivity() {
         }
 
         // Perform the eye destroyer functionality
-        controlLeds("off", FLASH_WHITE_LED_PATH, FLASH_YELLOW_LED_PATH, whiteBrightness = 1000, yellowBrightness = 1000)
-        controlLeds("on", FLASH_WHITE_LED_PATH, FLASH_YELLOW_LED_PATH, whiteBrightness = 1500, yellowBrightness = 1500)
+        ledController.controlLeds("off", FLASH_WHITE_LED_PATH, FLASH_YELLOW_LED_PATH, whiteBrightness = 1000, yellowBrightness = 1000)
+        ledController.controlLeds("on", FLASH_WHITE_LED_PATH, FLASH_YELLOW_LED_PATH, whiteBrightness = 1500, yellowBrightness = 1500)
         isLedOn = true
 
         // Start cooldown
@@ -232,7 +234,7 @@ class MainActivity : BaseActivity() {
 
         // Apply the changes to the LEDs
         if (isLedOn) {
-            controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH,
+            ledController.controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH,
                 whiteBrightness = if (whiteBrightness > MAX_BRIGHTNESS) SAFE_BRIGHTNESS else whiteBrightness,
                 yellowBrightness = if (yellowBrightness > MAX_BRIGHTNESS) SAFE_BRIGHTNESS else yellowBrightness
             )
diff --git a/app/src/main/java/com/bartixxx/opflashcontrol/MainActivity2.kt b/app/src/main/java/com/bartixxx/opflashcontrol/MainActivity2.kt
index e59ae2a..3818396 100644
--- a/app/src/main/java/com/bartixxx/opflashcontrol/MainActivity2.kt
+++ b/app/src/main/java/com/bartixxx/opflashcontrol/MainActivity2.kt
@@ -21,9 +21,11 @@ class MainActivity2 : BaseActivity() {
     private val SAFE_BRIGHTNESS = 80
     private val CHECK_INTERVAL = 200L // 200 ms
     private var eyeDestroyerCooldown = false // Flag to track cooldown
+    private lateinit var ledController: LedController
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
+        ledController = LedController(this)
         binding = ActivityMain2Binding.inflate(layoutInflater)
         setContentView(binding.root)
 
@@ -55,28 +57,28 @@ class MainActivity2 : BaseActivity() {
             setupSlider(masterSeekBar, masterTextView, "Master Brightness") { progress ->
                 masterBrightness = progress
                 if (isLedOn && allBrightnessAtOne()) {
-                    controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, WHITE2_LED_PATH, YELLOW2_LED_PATH, progress, progress, progress, progress)
+                    ledController.controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, WHITE2_LED_PATH, YELLOW2_LED_PATH, progress, progress, progress, progress)
                 }
             }
 
             setupSlider(whiteSeekBar, whiteTextView, "White Brightness") { progress ->
                 whiteBrightness = progress
-                if (isLedOn) controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, WHITE2_LED_PATH, YELLOW2_LED_PATH, progress, yellowBrightness, white2Brightness, yellow2Brightness)
+                if (isLedOn) ledController.controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, WHITE2_LED_PATH, YELLOW2_LED_PATH, progress, yellowBrightness, white2Brightness, yellow2Brightness)
             }
 
             setupSlider(yellowSeekBar, yellowTextView, "Yellow Brightness") { progress ->
                 yellowBrightness = progress
-                if (isLedOn) controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, WHITE2_LED_PATH, YELLOW2_LED_PATH, whiteBrightness, progress, white2Brightness, yellow2Brightness)
+                if (isLedOn) ledController.controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, WHITE2_LED_PATH, YELLOW2_LED_PATH, whiteBrightness, progress, white2Brightness, yellow2Brightness)
             }
 
             setupSlider(white2SeekBar2, white2TextView3, "White2 Brightness") { progress ->
                 white2Brightness = progress
-                if (isLedOn) controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, WHITE2_LED_PATH, YELLOW2_LED_PATH, whiteBrightness, yellowBrightness, progress, yellow2Brightness)
+                if (isLedOn) ledController.controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, WHITE2_LED_PATH, YELLOW2_LED_PATH, whiteBrightness, yellowBrightness, progress, yellow2Brightness)
             }
 
             setupSlider(yellow2SeekBar3, yellow2TextView2, "Yellow2 Brightness") { progress ->
                 yellow2Brightness = progress
-                if (isLedOn) controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, WHITE2_LED_PATH, YELLOW2_LED_PATH, whiteBrightness, yellowBrightness, white2Brightness, progress)
+                if (isLedOn) ledController.controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, WHITE2_LED_PATH, YELLOW2_LED_PATH, whiteBrightness, yellowBrightness, white2Brightness, progress)
             }
 
             on.setOnClickListener {
@@ -153,14 +155,14 @@ class MainActivity2 : BaseActivity() {
     private fun toggleLEDs(on: Boolean) {
         isLedOn = on
         if (on) {
-            controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, WHITE2_LED_PATH, YELLOW2_LED_PATH,
+            ledController.controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, WHITE2_LED_PATH, YELLOW2_LED_PATH,
                 if (whiteBrightness == 0) masterBrightness else whiteBrightness,
                 if (yellowBrightness == 0) masterBrightness else yellowBrightness,
                 if (white2Brightness == 0) masterBrightness else white2Brightness,
                 if (yellow2Brightness == 0) masterBrightness else yellow2Brightness
             )
         } else {
-            controlLeds("off", WHITE_LED_PATH, YELLOW_LED_PATH, WHITE2_LED_PATH, YELLOW2_LED_PATH, 1, 1, 1, 1)
+            ledController.controlLeds("off", WHITE_LED_PATH, YELLOW_LED_PATH, WHITE2_LED_PATH, YELLOW2_LED_PATH, 1, 1, 1, 1)
         }
     }
 
@@ -170,8 +172,8 @@ class MainActivity2 : BaseActivity() {
             return
         }
 
-        controlLeds("off", FLASH_WHITE_LED_PATH, FLASH_YELLOW_LED_PATH, FLASH_WHITE2_LED_PATH, FLASH_YELLOW2_LED_PATH, 1000, 1000, 1000, 1000)
-        controlLeds("on", FLASH_WHITE_LED_PATH, FLASH_YELLOW_LED_PATH, FLASH_WHITE2_LED_PATH, FLASH_YELLOW2_LED_PATH, 1500, 1500, 1500, 1500)
+        ledController.controlLeds("off", FLASH_WHITE_LED_PATH, FLASH_YELLOW_LED_PATH, FLASH_WHITE2_LED_PATH, FLASH_YELLOW2_LED_PATH, 1000, 1000, 1000, 1000)
+        ledController.controlLeds("on", FLASH_WHITE_LED_PATH, FLASH_YELLOW_LED_PATH, FLASH_WHITE2_LED_PATH, FLASH_YELLOW2_LED_PATH, 1500, 1500, 1500, 1500)
         isLedOn = true
 
         startEyeDestroyerCooldown()
@@ -242,7 +244,7 @@ class MainActivity2 : BaseActivity() {
 
         // Apply changes to LEDs only if any value was adjusted
         if (adjusted && isLedOn) {
-            controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, WHITE2_LED_PATH, YELLOW2_LED_PATH,
+            ledController.controlLeds("on", WHITE_LED_PATH, YELLOW_LED_PATH, WHITE2_LED_PATH, YELLOW2_LED_PATH,
                 whiteBrightness, yellowBrightness, white2Brightness, yellow2Brightness)
             Toast.makeText(this, "Brightness exceeded limit! Adjusted to safe levels.", Toast.LENGTH_SHORT).show()
         }
diff --git a/app/src/main/java/com/bartixxx/opflashcontrol/TileService.kt b/app/src/main/java/com/bartixxx/opflashcontrol/TileService.kt
new file mode 100644
index 0000000..593cfc4
--- /dev/null
+++ b/app/src/main/java/com/bartixxx/opflashcontrol/TileService.kt
@@ -0,0 +1,188 @@
+package com.bartixxx.opflashcontrol
+
+import android.os.Handler
+import android.os.Looper
+import android.service.quicksettings.Tile
+import android.service.quicksettings.TileService
+import android.util.Log
+import android.graphics.drawable.Icon
+import com.bartixxx.opflashcontrol.BaseActivity.Companion.WHITE_LED_PATH
+import com.bartixxx.opflashcontrol.BaseActivity.Companion.YELLOW_LED_PATH
+import com.bartixxx.opflashcontrol.BaseActivity.Companion.WHITE2_LED_PATH
+import com.bartixxx.opflashcontrol.BaseActivity.Companion.YELLOW2_LED_PATH
+
+class LEDControlTileService : TileService() {
+    private var currentBrightnessState = 0 // 0 = off, 1 = 10, 2 = 30, ... up to 255
+    private lateinit var ledController: LedController
+    private var brightnessExceededTime: Long = 0L
+    private var safetyTriggered = false
+    private val handler = Handler(Looper.getMainLooper())
+    private val checkInterval = 500L // Check every 500 milliseconds
+    private val brightnessSteps = listOf(10, 30, 50, 80, 100, 120, 150, 180, 210, 240, 255) // Defined brightness steps
+
+    private var lastTapTime: Long = 0L // Track time of last tap for double-tap detection
+    private val doubleTapInterval = 300L // Time window for detecting double-tap (in milliseconds)
+
+    override fun onStartListening() {
+        super.onStartListening()
+        try {
+            ledController = LedController(this)
+            updateTileDescription()
+            startSafetyCheck()
+        } catch (e: Exception) {
+            Log.e("LEDControlTileService", "Error during onStartListening", e)
+        }
+    }
+
+    override fun onStopListening() {
+        super.onStopListening()
+        stopSafetyCheck()
+    }
+
+    override fun onClick() {
+        super.onClick()
+        val currentTime = System.currentTimeMillis()
+
+        try {
+            if (currentTime - lastTapTime < doubleTapInterval) {
+                // Double-tap detected
+                if (currentBrightnessState == 0 || currentBrightnessState == 1) {
+                    // Double-tap while off: Turn LEDs on at 80% brightness
+                    Log.d("LEDControlTileService", "Double-tap detected while off, turning LEDs on at 80%.")
+                    currentBrightnessState = brightnessSteps.indexOf(80) + 1 // Set to 80% brightness
+                    controlAllLeds(80)
+                    updateTileDescription()
+                } else {
+                    // Double-tap while on: Turn off LEDs
+                    Log.d("LEDControlTileService", "Double-tap detected, turning off LEDs.")
+                    turnOffLeds()
+                }
+            } else {
+                // Single tap logic (cycle through brightness levels)
+                VibrationUtil.vibrate(this, 50L)
+                // Ensure we cycle through brightness states
+                currentBrightnessState = (currentBrightnessState + 1) % (brightnessSteps.size + 1) // Includes 0 (off)
+                updateTileDescription()
+
+                // Log the current state
+                Log.d("LEDControlTileService", "Brightness state changed to $currentBrightnessState")
+
+                // Set brightness based on the current state
+                val brightnessLevel = if (currentBrightnessState == 0) 0 else brightnessSteps[currentBrightnessState - 1]
+                controlAllLeds(brightnessLevel)
+            }
+        } catch (e: Exception) {
+            Log.e("LEDControlTileService", "Error during onClick", e)
+            // Handle exception gracefully by turning off the LEDs to avoid leaving them in an inconsistent state
+            turnOffLeds()
+        }
+
+        lastTapTime = currentTime // Update the time of the last tap
+    }
+
+    private fun turnOffLeds() {
+        try {
+            currentBrightnessState = 0
+            controlAllLeds(0) // Turn off LEDs
+            updateTileDescription()
+            VibrationUtil.vibrate(this, 100L) // Provide haptic feedback for turning off
+        } catch (e: Exception) {
+            Log.e("LEDControlTileService", "Error turning off LEDs", e)
+        }
+    }
+
+    private fun startSafetyCheck() {
+        handler.post(object : Runnable {
+            override fun run() {
+                try {
+                    checkBrightnessSafety()
+                } catch (e: Exception) {
+                    Log.e("LEDControlTileService", "Error during safety check", e)
+                }
+                handler.postDelayed(this, checkInterval)
+            }
+        })
+    }
+
+    private fun stopSafetyCheck() {
+        handler.removeCallbacksAndMessages(null)
+    }
+
+    private fun checkBrightnessSafety() {
+        try {
+            val currentTime = System.currentTimeMillis()
+            val brightnessLevel = if (currentBrightnessState == 0) 0 else brightnessSteps[currentBrightnessState - 1]
+
+            if (brightnessLevel >= 120) {
+                if (brightnessExceededTime == 0L) {
+                    brightnessExceededTime = currentTime
+                    Log.d("LEDControlTileService", "Brightness exceeded safe limit, timer started.")
+                } else if (currentTime - brightnessExceededTime > 2000) { // More than 2 seconds
+                    if (!safetyTriggered) {
+                        Log.d("LEDControlTileService", "Safety triggered! Reducing brightness to 80.")
+                        safetyTriggered = true
+                        currentBrightnessState = brightnessSteps.indexOf(80) + 1 // Set to 80%
+                        controlAllLeds(80)
+                        updateTileDescription()
+                    }
+                }
+            } else {
+                brightnessExceededTime = 0L // Reset the timer if within safe range
+                safetyTriggered = false
+            }
+        } catch (e: Exception) {
+            Log.e("LEDControlTileService", "Error during brightness safety check", e)
+        }
+    }
+
+    private fun updateTileDescription() {
+        try {
+            val stateText = when (currentBrightnessState) {
+                0 -> getString(R.string.double_tap_to_turn_off) // Message when LEDs are off
+                else -> (getString(R.string.brightness) + ": " + brightnessSteps[currentBrightnessState - 1]) + "%" // Brightness state
+            }
+
+            // Change the tile label to Flashlight ON/OFF
+            qsTile.label = if (currentBrightnessState == 0) getString(R.string.flashlight_off) else getString(R.string.flashlight_on)
+
+            // Set the icon based on the current state (ON or OFF)
+            qsTile.icon = Icon.createWithResource(
+                this,
+                if (currentBrightnessState == 0) R.drawable.floff else R.drawable.flon
+            )
+
+            // Update tile subtitle and state
+            qsTile.subtitle = stateText
+            qsTile.state = if (currentBrightnessState == 0) Tile.STATE_INACTIVE else Tile.STATE_ACTIVE
+            qsTile.updateTile()
+        } catch (e: Exception) {
+            Log.e("LEDControlTileService", "Error updating tile description", e)
+        }
+    }
+
+    private fun controlAllLeds(brightness: Int) {
+        try {
+            if (brightness == 0) {
+                ledController.controlLeds(
+                    "off",
+                    WHITE_LED_PATH,
+                    YELLOW_LED_PATH,
+                    WHITE2_LED_PATH,
+                    YELLOW2_LED_PATH,
+                    1, 1, 1, 1, showToast = false
+                )
+            } else {
+                ledController.controlLeds(
+                    "on",
+                    WHITE_LED_PATH,
+                    YELLOW_LED_PATH,
+                    WHITE2_LED_PATH,
+                    YELLOW2_LED_PATH,
+                    brightness, brightness, brightness, brightness, showToast = false
+                )
+            }
+        } catch (e: Exception) {
+            Log.e("LEDControlTileService", "Error controlling LEDs", e)
+        }
+    }
+}
diff --git a/app/src/main/res/drawable/floff.png b/app/src/main/res/drawable/floff.png
new file mode 100644
index 0000000..3875424
Binary files /dev/null and b/app/src/main/res/drawable/floff.png differ
diff --git a/app/src/main/res/drawable/flon.png b/app/src/main/res/drawable/flon.png
new file mode 100644
index 0000000..ab17271
Binary files /dev/null and b/app/src/main/res/drawable/flon.png differ
diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml
index d661545..ef5e6ed 100644
--- a/app/src/main/res/values-pl/strings.xml
+++ b/app/src/main/res/values-pl/strings.xml
@@ -27,4 +27,8 @@
     <string name="donate2">Stuknij, aby przejść do strony darowizn, lub przytrzymaj, aby zobaczyć listę wspierających</string>
     <string name="supporters">Wspierający</string>
     <string name="safety">Przywrócono bezpieczne wartości</string>
+    <string name="double_tap_to_turn_off">Tapnij dwa razy aby wyłączyć LEDy</string>
+    <string name="brightness">Jasność</string>
+    <string name="flashlight_off">Latarka OFF</string>
+    <string name="flashlight_on">Latarka ON</string>
 </resources>
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index e8f21a8..dd5dd76 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -35,4 +35,8 @@
     <string name="donate2" translatable="true">Tap to visit the donation page, or press and hold to view the supporters list</string>
     <string name="supporters" translatable="true">Supporters</string>
     <string name="safety" translatable="true">Returned to safe limits</string>
+    <string name="double_tap_to_turn_off">Double-tap to turn off LEDs</string>
+    <string name="brightness">Brightness</string>
+    <string name="flashlight_off">Flashlight OFF</string>
+    <string name="flashlight_on">Flashlight ON</string>
 </resources>
diff --git a/metadata/en-US/full_description.txt b/metadata/en-US/full_description.txt
index bb4f33c..b413014 100644
--- a/metadata/en-US/full_description.txt
+++ b/metadata/en-US/full_description.txt
@@ -1,10 +1,15 @@
-OnePlus Flash Control is an simple LED control application designed specifically for rooted OnePlus devices. With this app, users can control the flashlight and other LED features on their OnePlus phones, including adjusting the brightness and toggling the state of multiple LEDs. The app offers a simple and intuitive interface, allowing users to quickly turn the LED flash on or off, and fine-tune the brightness via a slider.
-
-To ensure the app works seamlessly, root access is required. This is necessary for the app to interact with system-level files to control the LED settings. OnePlus Flash Control is ideal for users who want to customize their OnePlus device's LED functionality beyond the stock settings.
+OnePlus Flash Control is a powerful and intuitive LED control application designed specifically for rooted OnePlus devices. This app allows users to customize their OnePlus device's LED functionality, offering control over the flashlight and other LED features. With features such as adjusting brightness levels and toggling LED states, OnePlus Flash Control provides an easy way to enhance the LED experience beyond the stock settings.
 
 Key Features:
-Master Brightness Control: Adjust overall LED brightness with a single slider.
-Individual LED Control: Independently control the brightness of white and yellow LEDs.
-"Eye Destroyer" Mode: A feature to momentarily turn on the LEDs at maximum brightness for both white and yellow LEDs. Use with caution as it emits very intense light!
-Compatibility: Designed for rooted OnePlus devices with dual-tone LED flash.
-Quad LED Control (WIP): Control the brightness of four LEDs (Quad-LED models). This feature is implemented but untested; reports are needed for further refinement.
\ No newline at end of file
+- Master Brightness Control: Adjust the overall LED brightness using a single slider.
+- Individual LED Control: Independently control the brightness of white, yellow, white2, and yellow2 LEDs for precise customization.
+- Safety Mechanism: The app includes a safety feature that ensures brightness levels never exceed safe thresholds, automatically adjusting brightness to safe levels if necessary.
+- "Eye Destroyer" Mode: A unique feature that flashes the LEDs at maximum brightness, emitting very intense light. This function is protected by a cooldown to prevent excessive use.
+- Quick Settings Tile: A quick settings tile to toggle the LED brightness with ease, including cycling through brightness levels and detecting double-tap gestures.
+- Root Access Required: Root access is required to interact with system-level files to control the LED settings, providing advanced control over the device's LEDs.
+- Support for Rooted OnePlus Devices: Specifically designed for OnePlus devices with dual-tone LED flash, with support for Quad-LED models (work in progress, user feedback welcome).
+- Secret Action: Unlock hidden features by tapping the app's title 5 times within 5 seconds, enabling a fun experimental mode.
+Compatibility:
+- Root Access: Required for controlling LED settings at the system level.
+- OnePlus Devices: Optimized for OnePlus devices, including those with dual-tone or quad-LED flash.
+- Whether you're looking to fine-tune your device's LED functionality or experiment with custom features, OnePlus Flash Control gives you full control over your phone's LEDs.
\ No newline at end of file
diff --git a/metadata/en-US/images/phoneScreenshots/screenshot3.png b/metadata/en-US/images/phoneScreenshots/screenshot3.png
new file mode 100644
index 0000000..699db58
Binary files /dev/null and b/metadata/en-US/images/phoneScreenshots/screenshot3.png differ