Create Custom Quick Settings Tiles on Android

Why Create Your Own Quick Settings Tile?

Quick Settings tiles sit at the top of the notification shade and give you one‑tap access to frequently used actions—Wi‑Fi, Bluetooth, flashlight, and more. Android’s TileService API (available from Android 7.0 Nougat, API 24) lets any app expose a custom tile. This can be handy for:

• Launching a favorite app with a single tap.
• Triggering a home‑automation command via a webhook.
• Turning on/off a VPN, Do Not Disturb profile, or a custom sound mode.

Prerequisites

1. Android device running Android 7.0 or later.
2. Computer with ADB installed (part of the Android SDK Platform‑Tools).
3. Android Studio (or any Gradle‑based build environment) to compile the sample app.
4. Basic familiarity with Java or Kotlin.

If you prefer not to write code, the guide also points to a ready‑made open‑source sample you can install directly.

Step 1 – Enable Developer Options and Connect ADB

Before you can install a custom app, you need to allow USB debugging:

1. Open Settings → About phone.
2. Tap Build number seven times until you see “You are now a developer”.
3. Go back to Settings → System → Developer options (the path may vary by OEM).
4. Enable USB debugging.

Connect the phone to your computer with a USB cable and verify the connection:

adb devices

You should see your device’s serial number listed as “device”. If it shows “unauthorized”, confirm the prompt on the phone.

Step 2 – Create a Minimal Tile‑Service App

Below is a minimal example written in Kotlin. The same logic works in Java with only syntactic differences.

package com.example.customtile

import android.service.quicksettings.Tile
import android.service.quicksettings.TileService

class MyTileService : TileService() {
    override fun onStartListening() {
        super.onStartListening()
        // Update the tile appearance each time the shade opens
        qsTile?.state = Tile.STATE_INACTIVE
        qsTile?.label = "My Tile"
        qsTile?.updateTile()
    }

    override fun onClick() {
        super.onClick()
        // Toggle the tile state and perform an action
        if (qsTile?.state == Tile.STATE_ACTIVE) {
            qsTile?.state = Tile.STATE_INACTIVE
            // Example action: launch a website
            val intent = Intent(Intent.ACTION_VIEW, Uri.parse("https://example.com"))
            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
            startActivityAndCollapse(intent)
        } else {
            qsTile?.state = Tile.STATE_ACTIVE
        }
        qsTile?.updateTile()
    }
}

Key points:

• TileService is a foreground service that Android treats specially; it does not need a separate permission.
• Override onStartListening() to set the tile’s initial label, icon, and state.
• Override onClick() to define what happens when the user taps the tile.

Next, declare the service in AndroidManifest.xml:

<service
    android:name=".MyTileService"
    android:label="My Tile"
    android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
    <intent-filter>
        <action android:name="android.service.quicksettings.action.QS_TILE" />
    </intent-filter>
</service>

Optionally, you can provide a custom icon by adding a drawable resource and referencing it with the android:icon attribute.

Step 3 – Build and Install the App

If you are using Android Studio:

1. Select File → New → New Project and choose “Empty Activity”.
2. Replace the generated MainActivity with the MyTileService code above (you can delete the activity entirely if you don’t need a UI).
3. Add the service declaration to AndroidManifest.xml as shown.
4. Set the minSdkVersion to 24 (or higher) in build.gradle.

   android {
       compileSdkVersion 34
       defaultConfig {
           applicationId "com.example.customtile"
           minSdkVersion 24
           targetSdkVersion 34
           versionCode 1
           versionName "1.0"
       }
   }
   

5. Click the **Run** button or execute ./gradlew assembleDebug to generate an .apk file.
6. Install the APK via ADB:

   adb install -r app/build/outputs/apk/debug/app-debug.apk

If you prefer not to compile anything, you can download a pre‑built sample (e.g., the “SimpleTile” project on GitHub) and install it directly with the same adb install command.

Step 4 – Add the Tile to Quick Settings

After the app is installed, Android does not automatically place the tile in the Quick Settings panel. You need to add it manually:

1. Pull down the notification shade twice to reveal the full Quick Settings grid.
2. Tap the **Edit** (pencil) icon at the bottom.
3. Find your tile (it will appear with the label you set, e.g., “My Tile”).
4. Drag it into the active area and tap **Done**.

The tile is now ready. Tapping it will execute the code in onClick(). In the example above, the first tap opens a web page; subsequent taps toggle the visual state.

Step 5 – Test, Debug, and Troubleshoot

Common issues and how to resolve them:

• Tile does not appear in the edit list – Ensure the service declaration includes the BIND_QUICK_SETTINGS_TILE permission and that the app’s targetSdkVersion is 24 or higher.
• Tile crashes on click – Open adb logcat and filter for MyTileService to view stack traces.
• Tile state does not persist – Remember that the tile’s state is stored in memory; if you need persistence across reboots, store the value in SharedPreferences and restore it in onStartListening().
• OEM restrictions – Some manufacturers (e.g., Samsung, Xiaomi) disable third‑party tiles on certain devices. In such cases, the tile will not be listed at all.

Use the following ADB command to force‑stop the app if it gets stuck:

adb shell am force-stop com.example.customtile

Security and Compatibility Considerations

Because a TileService runs in the context of its host app, it inherits all of that app’s permissions. Keep the following in mind:

• Do not request unnecessary permissions (e.g., location, contacts) unless the tile truly needs them.
• Always validate any external data (URLs, intents) before acting on it to avoid injection attacks.
• Test on multiple Android versions and on at least one OEM‑skinned device, as manufacturers may hide or modify the Quick Settings UI.
• Starting with Android 13, the system shows a one‑time “Tile added” notification; users can revoke the tile from Settings → Apps → Your App → Tile permissions.

Alternative Approaches

If writing a full app feels heavyweight, consider these options:

1. Tasker + Tile Plugin – Tasker’s “Tile” plugin lets you create tiles without any code, using Tasker actions for the underlying work.
2. Third‑party launchers – Some launchers (e.g., Nova) provide custom tile shortcuts that can call intents directly.
3. Shortcut‑based tiles – Android 13 introduced the ability to pin a shortcut as a tile via the “Add tile” UI; this works for any app that exposes shortcuts.

These methods are quicker but offer less control over the tile’s appearance and state.

Conclusion

Creating a custom Quick Settings tile gives you a powerful shortcut right at your fingertips. By following the steps above you can:

• Set up a minimal TileService app.
• Build and install it using Android Studio or ADB.
• Add the tile to the system UI and make it perform any action you code.
• Handle common pitfalls and keep the implementation secure.

Once you’re comfortable with the basics, you can extend the tile to control smart‑home devices, toggle VPNs, or even display live information like battery level or weather. The only limit is your imagination and the permissions you responsibly request.