AppOpsNext
1.6.7 · GitHub
More about this app
Android 15+ AppOps manager with permission templates, batch changes, install history and diagnostics via Shizuku
AppOpsNext
English | 简体中文
AppOpsNext helps protect your privacy with finer control over app permissions, access history, and live monitoring. It runs through Shizuku without root and helps answer four questions:
- Settings: What have I allowed?
- Activity: Which apps are accessing what?
- Outcomes: Did the system allow or deny the access?
- Listeners: Which other processes are watching for permission changes?
Download APK · Report an issue · Build status
Official APKs are published ONLY on GitHub Releases. No guarantee is made for APKs from any third-party source.
Preview
Highlights
- Permission controls. Set AppOps such as camera, location, and clipboard per app, then read back each change to verify it. On MIUI and HyperOS, manage the private operations of the system.
- Change marks and notifications. See which settings AppOpsNext changed. When something else changes one of them, find it in the in-app notifications and restore or keep it.
- Templates. Apply saved rules to several apps, or automatically to new apps right after they are installed. Restore the earlier settings of an app when it is installed again.
- History. Filter by time and app, including counts of denied attempts. Save individual records on the device beyond Android's seven-day retention period.
- Access monitoring (experimental). Watch chosen app permissions, get reports of allowed and denied accesses, and review them in a log.
- Permission change listeners (experimental). See which processes are registered to watch for permission-setting changes.
- Setting guard (experimental). Get a notification when the system, a vendor policy, or another app changes a guarded setting, and optionally restore it.
- Limited privileged access. Use a fixed set of AppOps and permission-flag commands, with no arbitrary shell execution. Records stay on the device; only the update check uses the network.
What you can do
| Area | Features |
|---|---|
| Applications | Browse apps, search names and packages, sort by name, install time, or update time, and choose whether to show system apps. On a device with several users, switch to another user such as a work profile or private space. Show only the apps that AppOpsNext changed, with the latest change first. Switch to By permission to see the mode of every app for one operation and change it there. |
| AppOps | Inspect package and UID modes, search operations by localized or system name, and verify changes by reading them back. A permission that still has the mode AppOpsNext set shows Changed by AppOpsNext. After something else changes the setting, restore the previous setting or keep the current one. On MIUI and HyperOS, the list includes the private operations that the device reports. The operations that the security center asks about can use the Ask mode. |
| In-app notifications | See the permissions whose current setting is different from the one AppOpsNext last set. Restore one item or all items, or keep the current setting. The page also shows new app rule results and Setting guard events. AppOpsNext compares the settings when it opens, when it returns to the foreground and when the records change. It does not compare while it is closed. |
| Templates and batches | Create reusable rules, reorder them, apply a template to multiple apps, or change several operations in one app. Multi-select lists offer Select all for the items shown. Batch confirmations list the target mode and the items to change. After a batch finishes, run its failed changes again. When Setting guard is on, a template batch can also guard the settings it applied. |
| Newly installed apps | Opt in to automatic template application and inspect saved per-rule results. With Apply right after install, a process kept in Shizuku watches for installs, so the template applies without opening AppOpsNext. A periodic background check handles anything missed. With Restore settings after reinstall, AppOpsNext keeps the change records of a removed app for 30 days and restores its settings when the app is installed again. |
| History | Explore permission distribution, app statistics, and timelines by day range and app; choose and reorder the operations you follow. Optionally keep individual records past the seven days Android retains. |
| Settings and diagnostics | Switch between English, Simplified Chinese, or the system language. Choose a theme: follow system, light, or dark. Inspect connection status and diagnostic reports, and see quietly whether a newer release exists. |
| Backup and migration | Export templates, preferences, the access monitor selection, your own monitor templates, and Setting guard rules to a file. An import shows a preview of the changes and applies them only after you confirm. |
| Experimental | Watch chosen operations for chosen apps, with per-point reporting intervals, outcome filters and off-screen-only reporting. Notification permission is required for alerts. A registry check reports confirmed or unconfirmed coverage. A monitor log keeps every reported access, allowed or refused, whatever the notification settings. A monitor template holds a set of permissions with their monitor settings, and you can apply it to several apps at one time. On MIUI and HyperOS, the monitor can try to watch the private permissions of the system, which is not verified. Setting guard checks guarded settings hourly or in real time, and each rule can restore its target mode automatically, at most 3 attempts in 24 hours. Stop background work turns off the access monitor and stops the install watcher in one step. Also inspect a snapshot of processes registered for permission mode changes. |
Install and get started
Requirements
- Android 15 or later (API 35+).
- Shizuku 13 or later, running and authorized for AppOpsNext.
- The bundled native backend targets ARM64. Other CPU architectures have not been verified.
Root is not required when Shizuku is started through ADB or wireless debugging. AppOpsNext still needs Shizuku for privileged operations.
- Install and start Shizuku.
- Download the APK from the latest release and install it.
- Open AppOpsNext and grant access when Shizuku prompts you.
- Choose an app, select an operation, and review the confirmation before applying a change.
Use Templates for reusable rules and History to review system records. Automatic template application for newly installed apps is optional; configure its rules before enabling it. Apply right after install needs Shizuku to be running, and its process starts again when Shizuku restarts. The first reconciliation establishes an existing-app baseline; it does not retroactively apply the template to every installed app.
For updates, install the new release APK over the existing app to retain its settings. If Shizuku stops after a reboot or authorization is revoked, restore the connection before making new privileged reads or changes. Saved history remains viewable without that connection.
Tested environments
| Device | System | Validation |
|---|---|---|
| ASUS AI2302 | Android 15 / API 35 | Primary development and physical-device test environment. |
| Xiaomi 24117RN76G | HyperOS 3 / Android 16 / API 36 | Independent user verification of the native backend, reads/writes, history, and camera enforcement. |
| realme RMX3370 | Android 16 / API 36 | Independent user verification that Ignore takes effect through the compatibility revocation flag. |
These results describe the tested environments, not compatibility with every OEM ROM. See backend compatibility notes for the evidence and known limitations.
How history works
History comes from records retained by Android. AppOpsNext prefers individual access records and falls back to time-bucketed system statistics where needed, such as for clipboard access. Retention and timestamp precision depend on the device; this is not a complete, independently recorded audit log. Denied attempts are shown as interval counts alongside accesses, including when individual access records exist. Interval boundaries are labelled; they are not individual rejection timestamps. Aggregate accesses are not counted again when discrete records are available. The seven-day chart continues to count accesses only.
- Each operation's last successful result is saved locally and restored when the app reopens, with its update time shown on the page.
- Returning within five minutes reuses fresh results. Older or missing results are read when the history screen is visible, the app is in the foreground, and the backend is connected; periodic refresh follows the same conditions.
- Manual refresh bypasses the freshness check. Results update as each operation finishes, and a failed read keeps the previous result with an error message.
- Before the first successful read, the page distinguishes unloaded history from a genuine zero count.
The saved result is a cache of the latest successful read. It is stored in the app's private storage and excluded from Android backup; clearing app data or uninstalling removes it.
History persistence
Android keeps individual records for seven days; older accesses survive only as interval counts without their times. With Settings → History persistence turned on, AppOpsNext keeps the individual records of the permissions chosen there (camera, microphone, and precise and approximate location, the ones with individual records):
- The choice starts from the history page's selection and is independent of it afterwards.
- Permissions the history page shows are saved as it refreshes. The rest are saved when the app is opened, at most every six hours. When reads and writes succeed, opening the app at least once every seven days avoids gaps caused by individual records expiring.
- Periods that were not saved are filled from interval counts within 30 days. An interval that partly overlaps saved records counts only the accesses beyond them, which can be slightly high because Android may merge accesses into one record.
- Up to 100,000 records are kept, oldest removed first. They stay on the device, are excluded from backup, and can be deleted by date range or all at once.
- A saved file that cannot be read, for example after a downgrade, is left as it is and saving pauses until it is deleted, rather than being overwritten.
Denied attempts are never saved as individual records by Android. To record them one by one, use the experimental access monitor and its log.
What an AppOps change means
AppOps and Android runtime permissions are separate layers. Setting an AppOp to Allow cannot grant a missing runtime permission. Android or an OEM policy may also normalize or reject a requested mode. AppOpsNext explains runtime-permission failures and provides a route to the app's system settings.
Some Android 16 devices restrict AppOps changes for runtime permissions such as camera, microphone and location. When these restrictions apply, AppOpsNext uses the compatibility revocation flag (REVOKED_COMPAT) to enforce Ignore. This keeps the app's granted permission and does not stop its process. The system permission settings can still show the permission as allowed. On these devices, Deny is not available for the affected permissions. If you select Deny, AppOpsNext uses Ignore.
Changes use a verified transaction:
Read and check the original state
→ Write the requested mode
→ Read back and verify
→ On failure, attempt to restore and verify the original state
Manual, batch, and automatic-template writes share a serialized transaction queue. A command completing is not sufficient to report success; verification and restoration outcomes are surfaced separately. Restoration is attempted, not guaranteed.
UID-scoped changes can affect multiple apps sharing that UID. The confirmation screen identifies those packages. Automatic scope fallback is constrained to avoid silently extending a change to other apps. Batch results report each target separately.
Permissions and network use
| Permission | Why it is needed |
|---|---|
QUERY_ALL_PACKAGES |
An AppOps manager has to discover packages that are not known at build time. |
INTERNET |
Only to check quietly whether a newer release exists. |
POST_NOTIFICATIONS |
Results of automatic template application, access reports from the experimental monitor, and Setting guard alerts. |
FOREGROUND_SERVICE, FOREGROUND_SERVICE_SPECIAL_USE |
Keeps the callbacks of the experimental access monitor and of realtime Setting guard reachable while they are switched on. |
The update check reads public GitHub release information and nothing else. It never forces an update, never downloads or installs anything, and never shows a popup or a notification about it: an available version appears next to the app version in Settings and nowhere else. No user data of any kind is uploaded.
The diagnostic report is never sent anywhere on its own. It is assembled on the device and copied to the clipboard only when you ask for it, and sharing it is entirely your decision.
Troubleshooting
- Cannot connect: confirm Shizuku is running and AppOpsNext is authorized, then check Settings → Connection. The app tries its bundled native backend first and Shizuku UserService if native startup fails.
- A mode will not apply: check the Android runtime permission and the reported verification result. Some system restrictions cannot be overridden through AppOps. On some Android 16 devices, you can set runtime permissions only to Ignore. See What an AppOps change means.
- History looks old or incomplete: check the saved update time, refresh manually, and verify the connection. Android controls which records exist.
- The access monitor reports nothing: it is experimental and depends on a privileged interface that not every ROM provides. Turn it on again and read the registry check result; it can be confirmed, unconfirmed or failed, and partial registration and callback parsing errors stay visible. Matching registrations do not prove callback delivery. Enable notification permission and the monitoring notification channels. Also confirm at least one app and operation are selected, since nothing is watched by default.
- Monitor counts differ from app calls: the count represents reported events, which Android may emit more than once for one call. A monitoring point may also carry a reporting interval, in which case anything inside that interval is not reported at all. Only the selected apps in the current user profile are included. The monitor is not an exact API-call audit log.
- A busy permission fills the notification: an operation such as location is reported once per delivered fix, so watching one without an interval produces a report per second. Give that monitoring point a reporting interval in Settings, Experimental, Monitor settings, Monitoring points.
- "Only when off screen" still reports what you can see: the monitor reads the process state AppOps keeps for the app, and treats anything other than the app being on screen as off screen — including a foreground service. If the state cannot be read at all, the access is reported rather than dropped, so a monitor that cannot check something never goes quiet.
- The monitor stops after a force stop: a force stop removes its service and prevents Android from restarting it. Opening AppOpsNext again brings it back while the switch is still on.
- The monitor stops after the screen has been off for a while: some vendors' battery optimisation or background management ends the app's process, and a foreground service does not survive it either. This is outside the app's control. To run the monitor for long periods, exclude AppOpsNext from battery optimisation in system settings and lock it in the recents list. Opening the app again restores the monitor.
- Reporting a problem: include the device, Android/ROM version, reproduction steps, and a diagnostic report from Settings. Review and redact that report before posting it in a public issue.
Build from source
Use JDK 17, Go 1.24+, and the Android SDK with platform 36 installed.
The repository includes the Gradle wrapper. Set JAVA_HOME to JDK 17 and point
local.properties (sdk.dir) or ANDROID_HOME to your SDK installation.
# Optional: set this if Go is not on PATH.
# export GO_EXECUTABLE="/absolute/path/to/go"
./gradlew :app:assembleDebug
Output: app/build/outputs/apk/debug/app-debug.apk.
Gradle also cross-compiles the bundled daemon for Android ARM64; a separate NDK
build is not required. Debug builds keep the screen awake while the app is in
the foreground and use a different signing identity from public releases.
Run the same checks as Android CI:
(cd daemon && "${GO_EXECUTABLE:-go}" test ./...)
./gradlew :app:testDebugUnitTest :app:lintDebug :app:assembleDebug --no-daemon
Signed release builds
Public release signing material is excluded from Git. The configured release
build expects .signing/appopsnext-release.keystore, alias appopsnext, and
APPOPSNEXT_STORE_PASSWORD / APPOPSNEXT_KEY_PASSWORD in the environment:
./gradlew :app:assembleRelease
Output: app/build/outputs/apk/release/app-release.apk.
For your own distribution, supply your own keystore. Updating an existing
installation requires the same signing identity. Maintainer validation and
publishing steps are in the release checklist.
Code and documentation
Android packages live under app/src/main/java/dev/izumi/appopsnext/.
| Location | Responsibility |
|---|---|
presentation/ |
Compose screens, ViewModels, and UI state. |
appops/ |
Commands, parsers, scope handling, verified write transactions, and change records. |
nativebackend/, shizuku/ |
Privileged connections, native pipes, and UserService fallback. |
apps/, settings/ |
App discovery, metadata caching, and preferences. |
templates/, newapps/, batch/ |
Template persistence, installation detection and the install watcher, resumable rule execution, and batch targets. |
guard/, backup/ |
Experimental Setting guard, and export and import of the app's setup. |
history/ |
System-history parsing, refresh scheduling, local snapshots, and the saved individual-record archive. |
diagnostics/ |
Environment and connection reports. |
monitor/ |
Experimental access monitor: watch registration over a forwarded binder call, per-point reporting settings, event filtering, notifications, and the event log. |
update/ |
Release check against the GitHub API and version comparison. |
daemon/ at the repository root |
Go daemon with an allowlisted command protocol. |
Further reading: Architecture · Privileged backends · Device findings · Release checklist.
License
AppOpsNext is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
Copyright (C) 2026 1zumiii.
Third-party components keep their own licenses: the Shizuku API is MIT, and the
Phosphor Icons are MIT; AndroidX, Jetpack Compose and HiddenApiBypass are
Apache-2.0. These are
compatible with GPL-3.0. The Phosphor notice is included in the app at
app/src/main/assets/licenses/phosphor-icons.txt.
Project background
AppOpsNext is an independent clean-room implementation inspired by the general
product idea and workflows of the historical App Ops application (rikka.appops).
It is not a fork, port, modified build, or official successor.
It includes no legacy application source, decompiled code, assets, branding, or configuration data, and does not require or provide migration from that app.
AppOpsNext is not developed, endorsed, or supported by RikkaApps or the original App Ops author. Its use of Shizuku does not imply affiliation with its maintainers. “AppOps” refers to Android's built-in system service.
How Shizuku is used
Can view and change AppOps, review history, monitor live use and guard rules via `cmd appops` and `dumpsys` through Shizuku.
This is an AI-assisted analysis of Shizuku-related usages in the app's public source code. It is best effort, so it may not catch every single usage.
How this app uses Shizuku
Shizuku is used to read, change, watch and guard Android AppOps privacy settings with elevated privilege.
- View app permissions: see current AppOps states for any installed app, UID or Android user, plus runtime permission grants, using the
cmd appops getanddumpsys appops --opanddumpsys packageshell commands through Shizuku. - Change app permissions: set an operation to allow, ignore, deny, default or foreground for a package or UID, including single changes, batch changes, permission templates and per user changes, using the
cmd appops setshell commands through Shizuku, plus permission flag handling with thecmd package set-permission-flagsshell command through Shizuku. - Review access history: show past accesses and denials for an operation and saved archives using the
dumpsys appops --historyshell command through Shizuku, and show install and update times using thedumpsys package packagesshell command through Shizuku. - Monitor live accesses: receive immediate notifications when watched apps access location, camera and other operations by registering AppOps watch callbacks on the system AppOps service through Shizuku.
- Enforce guard rules: automatically check guarded operations and restore them to the configured mode shortly after they change by watching AppOps mode changes on the system AppOps service through Shizuku.
- Detect new installs: keep a persistent watcher that observes install sessions and wakes the app when an install succeeds so templates and rules can be applied, using the system install session callback and the
am broadcastshell command through Shizuku.
Android APIs or commands used
/system/bin/cmd appops get/system/bin/cmd appops set/system/bin/cmd appops set --uid/system/bin/dumpsys appops --op/system/bin/dumpsys appops --package/system/bin/dumpsys appops --history/system/bin/dumpsys appops --watchers/system/bin/dumpsys package/system/bin/dumpsys package packages/system/bin/cmd package set-permission-flags/system/bin/cmd package clear-permission-flags/system/bin/pm list users/system/bin/pm list packages/system/bin/am broadcastIAppOpsService.getOpsForPackageIAppOpsService.getUidOpsIAppOpsService.getPackagesForOpsIAppOpsService.startWatchingModeIAppOpsService.stopWatchingModeIAppOpsService.startWatchingActiveIAppOpsService.startWatchingNotedIAppOpsService.startWatchingStartedPackageInstaller.registerSessionCallback
Changelog
What's new for version 1.6.7
简体中文
1.6.7 新增权限修改标记、应用内通知、监测模板和重装后恢复设置,支持 MIUI、澎湃 OS 的私有操作,并改进安装监听进程的稳定性。可直接从 1.6.6 覆盖安装升级。
新增
- 新增权限修改标记(#26)。AppOpsNext 在本机记录成功的权限修改,仍保持所设模式的权限显示“经 AppOpsNext 修改”。应用列表可只显示有修改记录的应用,并按最近修改时间排序。
- 设置被 AppOpsNext 以外的途径改动后,标记不再显示,并提供“恢复此前设置”和“保留当前设置”两个选项。
- 此版本安装前的修改不在记录范围内。只有 AppOpsNext 运行期间检查到的外部改动才会被识别。修改记录不包含在备份中。
- 新增应用内通知。通知页集中列出与 AppOpsNext 上次设置不一致的权限,可逐项或全部恢复,也可保留当前设置,同时显示新装应用规则的结果和设置守护记录。
- 支持读取和修改 MIUI、澎湃 OS 的私有操作(#10)。其中由安全中心弹窗询问的四项操作可设为“询问”。
- 新增监测模板(实验性功能)。可将一组权限及其监测设置保存为模板,一次套用到多个应用。应用内置了几个模板,自定义模板包含在备份中。
- 访问监测可尝试监听 MIUI、澎湃 OS 的私有权限(#27)。这类权限标明未经验证,系统拒绝监听时,标准权限的监测不受影响。
- 新增“重装后恢复设置”(#27)。开启后,应用卸载时保留其修改记录 30 天,重新安装时恢复 AppOpsNext 此前的设置。此项默认关闭。
- 批量修改完成后,可重试失败的项目。
- 新增“停止后台任务”,一次关闭访问监测并结束安装监听进程。
改进
- 修改其他用户空间中的权限时,如果因缺少运行时权限而无法设为“允许”或“仅前台”,会提示先授予系统权限。
- 诊断日志减少重复内容,重要记录与常规记录分开保留,并记录写入失败的细节和安装监听进程的状态。诊断报告新增进程一节。
- 改善 UI/UX,优化 App 性能。
修复
- 修复部分应用需要多次操作才能设为“忽略”的问题。
- 修复安装监听进程被系统结束后不再恢复的问题,以及 Shizuku 服务重启后可能同时存在多个安装监听进程的问题(#27)。
- 修复先开启“安装后立即套用”、后授予 Shizuku 权限时,安装监听进程不启动的问题。
- 修复关闭“安装后立即套用”后立即重新开启时,安装监听进程可能长时间无法连接的问题。
- 修复单次读取失败后,后续读取持续使用较慢方式的问题。
- 修复后端拒绝请求后连接断开的问题。
- 修复 UserService 后端连接超时后,后台任务无法重新连接的问题。
- 修复实时设置守护在部分操作注册失败后不再重试的问题。
- 修复同一应用的图标在部分页面显示模糊的问题。
English
1.6.7 adds permission change marks, in-app notifications, monitor templates and Restore settings after reinstall. It supports MIUI and HyperOS private operations and makes the install watcher more stable. You can install it over 1.6.6.
New
- Added permission change marks (#26). AppOpsNext keeps a local record of each permission change that it wrote and verified. A permission that still has the mode AppOpsNext set shows Changed by AppOpsNext. The app list can show only the apps with change records, with the latest change first.
- After a setting is changed outside AppOpsNext, the mark does not show. The page offers Restore previous and Keep current.
- Changes made before this version have no record. AppOpsNext finds only the outside changes that it sees while it runs. Backups do not include the records.
- Added in-app notifications. The Notifications page lists the permissions whose current setting is different from the one AppOpsNext last set. You can restore one item or all items, or keep the current setting. The page also shows new app rule results and Setting guard events.
- Added support for MIUI and HyperOS private operations (#10). You can select the Ask mode for the four operations that the security center asks about.
- Added monitor templates (experimental). A template holds a set of permissions with their monitor settings, and you can apply it to several apps at one time. The app has some built-in templates. Backups include your own templates.
- The access monitor can try to watch MIUI and HyperOS private permissions (#27). These permissions have a label that says they are not verified. If the system refuses to watch them, the standard permissions are still monitored.
- Added Restore settings after reinstall (#27). When it is on, AppOpsNext keeps the change records of a removed app for 30 days. It restores the settings when the app is installed again. The setting is off by default.
- After a batch change, you can run the failed changes again.
- Added Stop background work. It turns off the access monitor and stops the install watcher in one step.
Improved
- In another user, a change to Allow or Foreground only fails when the runtime permission is not granted. AppOpsNext then shows the Grant the Android permission first message.
- The diagnostic log has fewer repeated lines and keeps important lines apart from routine lines. It records the details of failed writes and the state of the install watcher. The diagnostic report has a new section that lists processes.
- Improved the UI/UX and app performance.
Fixed
- Fixed a problem where some apps needed several attempts to change to Ignore.
- Fixed the install watcher not starting again after the system stopped it, and more than one install watcher running after the Shizuku service restarted (#27).
- Fixed the install watcher not starting when Apply right after install was turned on before the Shizuku permission was granted.
- Fixed the install watcher not connecting for a long time when Apply right after install was turned off and immediately on again.
- Fixed a problem where one failed read made all later reads use the slower method.
- Fixed the backend connection closing after the backend refused one request.
- Fixed background tasks not connecting again after the UserService backend connection timed out.
- Fixed real-time Setting guard not trying again after it failed to register some operations.
- Fixed blurry app icons on some pages.
SHA-256 (AppOpsNext-v1.6.7.apk): c3d6b1d5264a76d35a3c1d35b936103abc0893d3a54bfee4cbdc25292c8443cb
Permissions
10 permissions requested
