In Android, how to Display an Overlay over other Apps

[Keshav-writes-code]

so, in androind, there's a common ability where an app can draw an overlay over other apps. i wonder how to do it in tauri

[yuvrajsingh2428]

Great question. This requires bridging Android's SYSTEM_ALERT_WINDOW
permission with Tauri's plugin system. Here's the complete approach:

1. Add the permission to AndroidManifest.xml

In your Tauri project, navigate to:
src-tauri/gen/android/app/src/main/AndroidManifest.xml

Add inside <manifest>:

<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />

2. Create a Tauri Plugin command to trigger the overlay

In your Rust backend (src-tauri/src/lib.rs), create a command that
invokes Android's native overlay logic via a Tauri plugin:

#[tauri::command]
fn request_overlay_permission(app: tauri::AppHandle) {
    #[cfg(target_os = "android")]
    app.run_on_main_thread(|| {
        // Trigger Settings.ACTION_MANAGE_OVERLAY_PERMISSION intent
    }).unwrap();
}

3. Handle the permission request on the Android side

Create a Kotlin plugin file in:
src-tauri/gen/android/app/src/main/java/com/plugin/overlay/OverlayPlugin.kt

package com.plugin.overlay

import android.app.Activity
import android.content.Intent
import android.net.Uri
import android.os.Build
import android.provider.Settings
import app.tauri.annotation.Command
import app.tauri.annotation.TauriPlugin
import app.tauri.plugin.Plugin
import app.tauri.plugin.Invoke

@TauriPlugin
class OverlayPlugin(private val activity: Activity) : Plugin(activity) {

    @Command
    fun requestOverlayPermission(invoke: Invoke) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            if (!Settings.canDrawOverlays(activity)) {
                val intent = Intent(
                    Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
                    Uri.parse("package:${activity.packageName}")
                )
                activity.startActivityForResult(intent, OVERLAY_PERMISSION_REQ_CODE)
                invoke.resolve()
            } else {
                invoke.resolve()
            }
        } else {
            invoke.resolve() // Permission auto-granted below API 23
        }
    }

    companion object {
        private const val OVERLAY_PERMISSION_REQ_CODE = 1234
    }
}

4. Register the plugin in MainActivity.kt

class MainActivity : TauriActivity() {
    override fun onCreatePlugins(manager: PluginManager) {
        manager.addPlugin(OverlayPlugin(this))
    }
}

5. Call it from your frontend

import { invoke } from '@tauri-apps/api/core';

async function requestOverlay() {
  await invoke('plugin:overlay|request_overlay_permission');
}

6. Draw the actual overlay window

Once permission is granted, use a WindowManager service in Kotlin:

val params = WindowManager.LayoutParams(
    WindowManager.LayoutParams.WRAP_CONTENT,
    WindowManager.LayoutParams.WRAP_CONTENT,
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
        WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY
    else
        WindowManager.LayoutParams.TYPE_PHONE,
    WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE,
    PixelFormat.TRANSLUCENT
)
val windowManager = getSystemService(WINDOW_SERVICE) as WindowManager
val overlayView = LayoutInflater.from(this).inflate(R.layout.overlay_layout, null)
windowManager.addView(overlayView, params)

Important notes

• TYPE_APPLICATION_OVERLAY is required on Android 8.0+ (API 26+).
  Using TYPE_PHONE on newer APIs will throw an exception.
• The user must manually grant the permission via system settings —
  you cannot grant it programmatically.
• Always check Settings.canDrawOverlays(context) before attempting
  to draw, otherwise you'll get a WindowManager$BadTokenException.
• On Android 13+, the system may restrict this permission for
  sideloaded apps — test on a real device, not just emulator.

Let me know if you hit any issues with the plugin registration step —
that's usually where it gets tricky with Tauri's Android bridge.

[MILLERMARRU]

Tauri has no API for this and will not paint outside its own activity, so drawing over other apps is done entirely on the native side through a Tauri mobile plugin with a Kotlin implementation. The flow on Android:

1. Declare android.permission.SYSTEM_ALERT_WINDOW in the manifest. This one is special: you cannot request it with a normal runtime dialog. You check Settings.canDrawOverlays(context), and if it is false you send the user to the system settings screen with an ACTION_MANAGE_OVERLAY_PERMISSION intent and re-check when they return.
2. From your plugin, start a foreground Service (an overlay that outlives your activity needs one, and Android 14+ wants a declared service type).
3. In the service, build the view and attach it with WindowManager.addView() using WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY and the FLAG_NOT_FOCUSABLE / FLAG_LAYOUT_IN_SCREEN combination that fits your use case.

The important mental model shift: the overlay is a native Android view, not your Tauri webview. Your web frontend can control it through plugin commands (show, hide, update text), but if you want actual web content floating there you would have to instantiate a separate WebView inside that window yourself and wire your own bridge.

The mobile plugin guide covers the command and permission plumbing you need on the Rust/Kotlin boundary: https://v2.tauri.app/develop/plugins/develop-mobile/

Also expect friction on recent Android: some OEMs restrict overlays aggressively, and since Android 12/13 overlay windows are dimmed or blocked over certain protected screens by design.