Android Clipboard Access

This page is Android-only. On iOS, clipboard access goes through the keyboard extension, the share extension, and per-app "paste from other apps" permission — those are covered elsewhere and do not apply to Android.

Since Android 10, the system blocks background apps from reading the clipboard by default: when the app is not in the foreground, it can neither read what you copied elsewhere nor write remote content into the system clipboard. To make "copy syncs automatically" and "remote content is written to this device automatically" work in the background too, UniClipboard has to use a special mechanism to work around this restriction. Under Settings → Background → Background reading method, the app offers three; pick any one:

Timed polling (default) — reads/writes via an overlay window and checks the clipboard on a timer. Works out of the box, no computer needed.
ADB events — also reads/writes via the overlay window, but only fires when the system actually reports a copy. Less interference and lower power, but needs a computer once for setup.
Shizuku — reads/writes through Shizuku's privileged service, with no overlay window and event-driven detection. Requires installing and keeping Shizuku running.

To understand the three methods, separate two things: what does the reading/writing and what detects that the clipboard changed:

The first two (Timed polling, ADB events) share the same underlying mechanism — both briefly show an overlay window to grab window focus and actually read/write the system clipboard. They differ only in how they detect a copy: one uses timed polling, the other listens for system copy events (which requires READ_LOGS).
Shizuku is entirely different — it reads/writes through a privileged service, needs no overlay window, and never temporarily grabs focus.

Choosing among the three

Aspect	Timed polling (default)	ADB events	Shizuku
Underlying read/write	Overlay window grabs focus	Overlay window grabs focus	Shizuku privileged service
Copy detection	Timed polling	Listens for system copy events	Event-driven
Needs a computer	No	Yes (grant READ_LOGS, once)	Yes, to start Shizuku without root
Key permissions	Overlay	Overlay + READ_LOGS	Shizuku authorization
Briefly shows overlay	Yes	Yes	No
Best for	Most people who want it to just work	People who can connect a computer and care about power/input	Advanced users familiar with Shizuku

You can switch methods anytime in the app: Settings → Background → Background reading method, swipe to compare, then pick one. Each is detailed below.

Both Timed polling and ADB events read/write via the overlay window, so at the moment of a background read or write the overlay briefly appears on screen, then hides automatically after about 10 seconds of idle — this is expected behavior, not a pop-up ad. The Shizuku method uses no overlay and never shows it.

The three reading methods

Timed polling depends on no external tools — it works as soon as you install the app. It briefly shows an overlay window to perform the background read/write, and checks the system clipboard on a timer for changes.

Permissions needed:

Overlay window permission (SYSTEM_ALERT_WINDOW) — required for both background reads and writes. The app can guide you straight to the system setting to turn this on.

No computer, no adb, nothing to install. The trade-off: because it polls periodically, it briefly grabs focus on each tick, which may momentarily affect keyboards, games, or full-screen apps; it's also less immediate than the two event-driven methods — after you copy, sync can take up to one polling interval. You can adjust that interval under Settings → Sync → Local polling interval.

If you want "install it and never touch a computer again," this is the one.

The ADB events method still uses the same overlay window for reading/writing, but swaps change detection for an event-driven approach: it only reads when the system actually reports a copy event, with no polling in between. That makes it lower-power and less disruptive to foreground input, at the cost of one permission the app cannot request on its own — READ_LOGS.

Permissions needed:

Overlay window permission (SYSTEM_ALERT_WINDOW) — for reading/writing the clipboard, same as Timed polling.
READ_LOGS permission — used to listen for system copy events. This permission cannot be requested from within the app — you must grant it by running one adb command from a computer, and you must restart the app after granting it for it to take effect. UniClipboard uses it only to detect that a copy happened; it does not read other log content.

To grant it: first set up adb per Preparation: USB debugging and adb below, then run:

adb shell pm grant <package-name> android.permission.READ_LOGS

Once you set the reading method to "ADB events" in the app, the Settings page walks you through this and copies the full command (with the actual package name already filled in) to the clipboard — just paste it into your computer's terminal and press Enter. Restart the app after granting.

If you pick "ADB events" but haven't granted READ_LOGS yet, background "copy = sync" won't fire (the Settings page shows "Computer authorization is still required" with the steps), and it won't silently fall back to Timed polling. If you'd rather not deal with a computer, just use Timed polling.

Shizuku is a third-party open-source tool that safely grants system-level permissions to ordinary apps. Once set up, UniClipboard uses its privileged service to read/write the clipboard directly — no overlay window, no focus grabbing, and event-driven, giving the most stable background experience. On MIUI (Xiaomi / HyperOS) it can also disable the "smart clipboard" restriction that interferes with background clipboard read/write.

Install the Shizuku app

Install from any of:

GitHub Releases (sideload the APK): github.com/RikkaApps/Shizuku/releases
Google Play: search for "Shizuku"
Third-party app stores such as Coolapk

Start the Shizuku service

Shizuku needs its service started once after every reboot. Pick one method:

No root (what most people use) — start it from a computer over adb. First set up adb per Preparation: USB debugging and adb below, then run the start command Shizuku shows you inside the app (follow the exact command displayed in-app). On Android 11+ you can also use Shizuku's built-in wireless debugging pairing to do it entirely without a computer.
Rooted — just tap "Start" inside the Shizuku app; no computer needed.

With the no-root method, you must restart the Shizuku service after every phone reboot (an inherent limitation of Shizuku, not a UniClipboard issue). If you want something hands-off, consider the default Timed polling method.

Authorize and switch to Shizuku

Authorize UniClipboard inside Shizuku (it prompts on first use).
Back in UniClipboard, go to Settings → Background → Background reading method and switch it to Shizuku.

Preparation: USB debugging and adb

Granting READ_LOGS for the ADB events method, or starting Shizuku on a non-rooted phone, both require connecting to your phone from a computer over adb. You only configure this once. If you only use Timed polling, you can skip this section.

Install adb on your computer

adb is part of Google's official Android Platform Tools. Download the package for your OS from developer.android.com/tools/releases/platform-tools and unzip it anywhere.

On macOS you can also use Homebrew: brew install --cask android-platform-tools
On Windows / Linux, after unzipping, open a terminal in that folder (or add it to your PATH) to use the adb command.

Verify: run adb version in your terminal; if it prints a version number, it's installed.

Enable "Developer options" on your phone

Go to Settings → About phone and tap the build number (on some systems it's labeled "MIUI version", "Build number", etc.) about 7 times, until it says "You are now a developer".

Turn on "USB debugging"

Go to Settings → System → Developer options (the exact location varies by vendor) and turn on the USB debugging switch.

Connect and authorize the computer

Connect the phone to the computer with a USB cable (choosing "File transfer / MTP" mode is more reliable). The phone shows an "Allow USB debugging?" dialog — check "Always allow from this computer" and confirm.

Run adb devices in your terminal; when your device shows up with status device (not unauthorized), you're connected.

Don't want to stay tethered? Android 11+ supports wireless debugging: turn on "Wireless debugging" in Developer options, pair your computer with the phone using a pairing code over the same Wi‑Fi, then unplug and run adb commands over Wi‑Fi.

Once connected: to grant READ_LOGS, run the adb shell pm grant … command from the "ADB events" tab above (the app has already copied the full command with the package name filled in); to start Shizuku, run the start command shown inside the Shizuku app.

Where to configure it

All background-related toggles live under Settings → Background.

When the master toggle "Background auto-sync" at the top is on, it walks you through granting the system permissions needed for background operation, one after another:

Ignore battery optimization (otherwise the system suspends the app in the background);
Notification permission (for the persistent notification);
The authorization required by your current background reading method (the default Timed polling needs overlay permission; other methods guide you through their own).

Just allow each one as the walkthrough prompts you. Below that is a set of advanced items you can adjust individually as needed:

Persistent notification — keeps one notification present to reduce the chance of the app being killed in the background.
Ignore battery optimization — re-triggers this grant on its own.
Background download from remote — pull new content pushed by the desktop while in the background.
Background upload from this device — push content copied on this device to the desktop while in the background.
Background reading method — switch among Timed polling, ADB events, and Shizuku (tap in to swipe and compare).

UniClipboard does not use the Accessibility service — you don't need to enable any accessibility permission in the system.

Whether background sync runs reliably over the long term depends heavily on your phone's vendor OS. Chinese vendor systems like MIUI / HyperOS, EMUI / HarmonyOS, ColorOS, and Funtouch generally have more aggressive background management than stock Android — even with the permissions above granted, they may suspend the app and drop sync after the screen locks or after a period of inactivity.

We recommend, where possible: turn on the persistent notification, add UniClipboard to the system's battery "unrestricted / always allow background" allowlist, and "lock" it in the recent tasks list so it isn't cleared by a one-tap sweep. MIUI users can also use the Shizuku method to disable the "smart clipboard" restriction. These are system-level behaviors that the app cannot fully handle on your behalf.

Can't connect or not syncing?

Background upload isn't working — make sure your selected background reading method is ready. With ADB events, background copy detection also needs READ_LOGS (finish the computer-side grant, or just switch to Timed polling); with Shizuku, confirm the service is started and authorized.
Granted READ_LOGS but still no effect — remember to restart the app; the adb grant doesn't take effect until you do.
It stops syncing after a while — most likely the vendor OS killed the app in the background; see the recommendations in the Callout above.
Does syncing require a network connection to the desktop — yes. Background access only addresses "can it read/write this device's clipboard"; whether it can reach the desktop is a separate matter, see Connect to desktop.

For more complete troubleshooting, see the Troubleshooting page. To learn how to enable phone sync on the desktop side and how to get pairing credentials, see Mobile sync and Pairing and sync.

Android Clipboard Access

On this page