# How to Remap the OnePlus Plus Key with PlusKey: Install, Configure Apps and AI Agents

> AI Release · @ai_releaseorg · https://ai-release.org/guides/kak-perenaznachit-knopku-plus-key-na-oneplus-ustanovka_en.html

## TL;DR

- **Time to complete:** about 30 minutes (≈15 minutes to install and map, ≈15 minutes to verify every gesture).
- **Difficulty:** Intermediate — you will use a command line and press hardware buttons in a fixed order.
- **You will need:**
  - A OnePlus phone that actually has the Plus Key hardware button — confirm your model in OnePlus documentation before you start.
  - A USB-C **data** cable (charge-only cables fail at the first step) and a PC with Windows, macOS or Linux.
  - Android Platform Tools, which provide the `adb` command (Android Debug Bridge — a command-line tool that talks to the phone over USB).
  - The PlusKey APK from the source you trust; write down its version from the file name, e.g. `PlusKey-<version>.apk`.
  - The AI agent app(s) you want the key to launch, already installed and signed in.

## Requirements and setup
![Illustration: Requirements and setup](https://ai-release.org/guides/img/kak-perenaznachit-knopku-plus-key-na-oneplus-ustanovka-en-1.jpg?v=1795077857)


- **OS on the PC:** Windows 10/11, macOS or Linux with a working USB port.
- **Android Platform Tools:** installed and on your `PATH`. Verify with `adb version` — if the shell answers `adb: command not found` (`'adb' is not recognized as an internal or external command` on Windows), add the platform-tools folder to `PATH` first.
- **Rights on the phone:** Developer options and USB debugging enabled — this is the permission that lets `adb` send commands.
- **Free space on the phone:** enough for the PlusKey APK plus one copy of the install (check `Settings → Storage` if the install fails).
- **A written mapping plan:** decide *before* installing what each gesture should do (open an app, open an AI agent, run an automation). You cannot verify a mapping you never defined.

Pre-flight checklist — tick every line before Step 1:

- [ ] Phone model confirmed to have the Plus Key button
- [ ] USB-C data cable (not charge-only)
- [ ] `adb version` prints a version string on the PC
- [ ] PlusKey APK downloaded, file name and version recorded
- [ ] AI agent app installed and logged in
- [ ] Mapping plan written (gesture → action)

**Example:** your notes file should look like `single press → AI agent app`, `long press → notes app`, `double press → automation`. If a row is empty, the gesture stays on the system default.

## Step 1. Prepare the phone and capture a baseline key event

**What to do:** enable Developer options, allow USB debugging, connect the phone, and record what the system sees when you press the Plus Key *before* PlusKey is installed.

1. On the phone open `Settings → About device → Build number` and tap it seven times. The screen shows `You are now a developer!`.
2. Open `Settings → System → Developer options` and switch on `USB debugging`.
3. Connect the phone to the PC. A dialog appears on the phone: `Allow USB debugging?` — tap `Allow` (tick `Always allow from this computer`).
4. On the PC run the device check, then capture events.

**Why:** the capture in step 4 gives you the **key code** — the numeric/textual identifier Android assigns to that button. If you skip it, you cannot tell whether PlusKey failed or whether the button never reaches Android at all.

```bash
adb devices
```

Expected output — one line per phone, ending in `device`:

```
List of devices attached
<RANDOM_SERIAL>	device
```

If the state reads `unauthorized` or `offline`, see Troubleshooting.

Now list the input devices and their capabilities:

```bash
adb shell getevent -pl
```

Find the block that belongs to the physical buttons (it lists key codes such as `KEY_VOLUMEUP`). Then start the live capture and press the Plus Key once, twice, and hold it:

```bash
adb shell getevent -l
```

Illustrative output — the label on the Plus Key line depends on how the vendor mapped the button, so **record whatever appears**:

```
/dev/input/event2: EV_KEY       KEY_VOLUMEUP         DOWN
/dev/input/event2: EV_SYN       SYN_REPORT           00000000
/dev/input/event2: EV_KEY       KEY_VOLUMEUP         UP
/dev/input/event2: EV_SYN       SYN_REPORT           00000000
```

Press `Ctrl+C` to stop the capture and save the output to a text file.

**How to check:** you see at least one `EV_KEY … DOWN` line each time you press the Plus Key. Three different press patterns must produce three distinguishable traces (single, double, long) — if single and long look identical, note it now; that gesture cannot be remapped separately on your build.

**Example:** if your capture shows only `KEY_VOLUMEUP` for every press, you are capturing the wrong input device or the wrong button — re-run `getevent -pl` and pick the block whose key list matches the button you pressed.

## Step 2. Install PlusKey and map the key to apps and AI agents
![Illustration: Step 2. Install PlusKey and map the key to apps and AI agents](https://ai-release.org/guides/img/kak-perenaznachit-knopku-plus-key-na-oneplus-ustanovka-en-2.jpg?v=1795077866)


**What to do:** install the APK over USB, confirm the package is present, grant the permissions the app asks for, then bind each gesture from your mapping plan.

Install from the PC:

```bash
adb install -r PlusKey-<version>.apk
```

Expected output: `Success`. The `-r` flag reinstalls over an existing copy and keeps data.

**Find the package name** — you need it later for verification and for launching the app from the command line:

```bash
adb shell pm list packages | grep -i pluskey
```

On Windows PowerShell use:

```powershell
adb shell pm list packages | Select-String pluskey
```

**Why:** the package name (for example `package:<com.vendor.pluskey>`) is the only stable identifier. Menu labels change between builds; the package name does not.

Open PlusKey on the phone and go through its own setup screen. Switch on the accessibility service or the special permission it requests — the exact permission name depends on the build, so **check the app documentation and grant exactly what it lists in its own setup screen**. Without that permission the app can see the button but cannot act on it.

Then fill in your mapping plan. Gesture names must match what PlusKey shows on your build; if a gesture is not listed there, drop that row.

| Gesture | Bind to (example) | How to verify |
|---|---|---|
| Single press | your AI agent app | App opens, no extra taps |
| Double press | an automation that sends a fixed prompt | Automation runs once |
| Long press | a notes app | App opens after ≈1 s hold |

Bind the AI agent the same way you bind any app: pick the target from PlusKey's app list. If PlusKey offers only a shortcut/intent field on your build, use the app's launch intent instead — that is the Android message (`intent`) that asks the system to open a specific screen. Test the intent by hand before saving it:

```bash
adb shell am start -n <agent-package>/<agent-launch-activity>
```

Replace `<agent-package>` with the package from `adb shell pm list packages` and `<agent-launch-activity>` with the activity named in the app documentation. If the command opens the right screen, the same intent will work from the key.

**How to check:** `adb shell pm list packages | grep -i pluskey` returns one line, and every gesture you saved in PlusKey shows the target you selected after you close and reopen the app. A mapping that disappears after a restart was never saved.

**Example:** mapping "single press → AI agent" is correct when a single press opens the agent's chat screen directly, not its splash screen followed by a login prompt.

For agents that live on a watch or that you want running with a local model before the key fires, see the companion guides: [How to Use AI Chat on Wear OS Smartwatches](https://ai-release.org/guides/kak-ispolzovat-ii-chat-na-umnyh-chasah-wear-os-ustanovk.html?utm_source=tg&utm_medium=channel&utm_campaign=guide_inline&utm_content=guide_to_guide) and [How to Speed Up DeepSeek with DeepInfer](https://ai-release.org/guides/kak-uskorit-deepseek-s-pomoschyu-deepinfer-ustanovka-i.html?utm_source=tg&utm_medium=channel&utm_campaign=guide_inline&utm_content=guide_to_guide). The same pattern — a hardware trigger calling an app that already runs — is what [CarDeck](https://ai-release.org/guides/kak-prevratit-android-smartfon-v-peredatchik-carplay-us.html?utm_source=tg&utm_medium=channel&utm_campaign=guide_inline&utm_content=guide_to_guide) does for CarPlay.

## Step 3. Verify every gesture and lock in the result
![Illustration: Step 3. Verify every gesture and lock in the result](https://ai-release.org/guides/img/kak-perenaznachit-knopku-plus-key-na-oneplus-ustanovka-en-3.jpg?v=1795077873)


**What to do:** clear the log, press each gesture three times, and read the log to confirm PlusKey handled the press.

```bash
adb logcat -c
adb logcat | grep -i pluskey
```

Windows PowerShell:

```powershell
adb logcat -c
adb logcat | Select-String -Pattern pluskey
```

**Why:** the log shows whether the press reached PlusKey and whether PlusKey fired the action. Without it you only see the end result and cannot tell "button not detected" from "action not launched".

Press the Plus Key for each mapped gesture, one at a time, leaving a few seconds between presses. Expected: one short burst of lines per press, containing the PlusKey package name, and the target app appearing on screen immediately after.

**How to check:** three passes, three identical results. Success looks like this:

- Single press → the AI agent opens on its chat screen within about a second.
- Double press → the automation runs exactly once (not twice).
- Long press → the notes app opens only after you hold the button.
- After a phone reboot, all three still work without opening PlusKey.

Record the final state in a note on the PC so the next change is reversible:

```text
Captured key code: <label from getevent -l>
Package: <com.vendor.pluskey>  Version: <from APK file name>
single -> <agent-package>/<activity>
double -> <automation task name>
long   -> <notes-package>/<activity>
```

**Example:** if a gesture works but fires twice, the build is reporting both press and release to PlusKey — re-check the gesture list in PlusKey and confirm you did not bind the same action to two gestures.

## Troubleshooting

**Problem. The PC sees no phone at all.**

- Error: `adb: no devices/emulators found`
- Cause: charge-only cable, a USB hub, or `USB debugging` switched off after a reboot.
- Solution: plug the cable directly into the PC, then re-check the state:
  ```bash
  adb kill-server
  adb start-server
  adb devices
  ```
  If a dialog appeared on the phone, tap `Allow`. If nothing appears, revoke authorizations in `Developer options → Revoke USB debugging authorizations` and reconnect.

**Problem. The phone is listed but refuses commands.**

- Error: `error: device unauthorized. This adb server's $ADB_VENDOR_KEYS is not set`
- Cause: the RSA fingerprint dialog was never accepted, or was accepted for another PC.
- Solution: unlock the phone, unplug and replug the cable, then tap `Allow` on the dialog and run `adb devices` again — the state must change from `unauthorized` to `device`.

**Problem. The install fails with a signature conflict.**

- Error: `Failure [INSTALL_FAILED_UPDATE_INCOMPATIBLE: Package com.vendor.pluskey signatures do not match previously installed version; ignoring!]`
- Cause: an older copy of PlusKey installed from another source (or another signature) is already on the phone.
- Solution: uninstall the old copy, then install again:
  ```bash
  adb uninstall <com.vendor.pluskey>
  adb install PlusKey-<version>.apk
  ```
  Re-do the gesture mapping afterwards — uninstalling clears the saved bindings.

## Summary and next steps

You captured the key code, installed PlusKey, bound each gesture to an app or an AI agent, and verified the result in `logcat`. Next, add one automation behind the double press and repeat Step 3 after every PlusKey update, because gesture names and permission prompts can change between builds — check the app documentation for the version you install.

## FAQ

**Does remapping the Plus Key require root?**
No. The workflow in this guide uses USB debugging, `adb`, and the permissions PlusKey requests on its own setup screen. If your build asks for anything beyond that, stop and check its documentation before granting it.

**How do I find the Plus Key's key code?**
Run `adb shell getevent -l` and press the button; the `EV_KEY … DOWN` line that appears is the code, and the `/dev/input/eventN` prefix tells you which input device reported it.

**Why does the key open the app but not the chat screen?**
The bound target is the launcher activity, not the chat activity. Get the exact activity from the app documentation, test it with `adb shell am start -n <package>/<activity>`, and bind that intent instead.

**Will an OTA update break the mapping?**
It can: updates may change the gesture list or reset the accessibility permission. After every system update, repeat Step 3 — press each gesture once and confirm the target app opens before relying on it.
