Every tool in TinyKit, tab by tab: what it does, how it does it, and anything to watch out for.
Commands are shown so you can see exactly what TinyKit changes. They all run as the shell
user through Shizuku. <pkg> stands for an app's package name.
Legend: ♻️ survives a reboot · ⟲ resets on reboot · 📶 uses the internet · 🔓 works without Shizuku
Shows whether Shizuku is installed, running, and allowed for TinyKit, with one button for whatever comes next: Get Shizuku, Allow or Open Shizuku.
Start and Stop work with the standard Shizuku app and with forks such as thedjchi's:
- Start uses Shizuku's auth token if one is saved and your Shizuku has a start intent
(
moe.shizuku.privileged.api.STARTbroadcast, in thedjchi's fork). Otherwise it uses Termux (shizuku startvia Termux'sRUN_COMMANDservice). It gives up after 60 seconds and shows Termux's error if something went wrong. Without Termux or shizuku-termux, it opens Shizuku so you tap its own Start button, and TinyKit connects by itself once Shizuku is running. That's the only way to start the standard Shizuku app without root or a computer. - Stop uses the token (
…STOPbroadcast) on forks that have it. Otherwise it force-stops the Shizuku app (so a Watchdog can't restart the server), sendsshizuku_serverSIGTERM, and SIGKILL if it's still there after 3 seconds. If TinyKit isn't allowed in Shizuku it falls back toshizuku stopin Termux. The tab, the tile and Shut Up share this one stop.
See Getting started → Starting Shizuku from TinyKit.
Stores Shizuku's start/stop token in TinyKit's private preferences. Clear removes it.
Shortcuts to add the Shizuku and Screenshot tiles. Install Shizuku & Termux links to the recommended downloads: thedjchi's Shizuku, Termux from F-Droid and the original Shizuku.
The search bar above the tab searches every row of every tab by title and description, in English and in the phone's language. Every word you type has to match, and title matches come first. A result that opens a page opens it; a switch or a one-tap action is shown in its tab, scrolled into view and lit up, so nothing runs by surprise.
| Toggle | What it does | Command | |
|---|---|---|---|
| Hide developer options | Apps that check whether developer options are on (banking apps, some games) see them as off. adb and Shizuku keep working. |
settings put global development_settings_enabled 0 |
♻️ |
| Ad-blocking DNS | Sets Private DNS to AdGuard, which blocks ads and trackers in every app and browser. Turning it off restores your previous Private DNS setting. | settings put global private_dns_mode hostname and settings put global private_dns_specifier dns.adguard-dns.com |
♻️ |
| Stop background scanning | Wi-Fi and Bluetooth stop scanning for nearby devices while they're turned off. This saves battery and limits location tracking. | settings put global wifi_scan_always_enabled 0 and settings put global ble_scan_always_enabled 0 |
♻️ |
| All sensors off | Blocks every sensor for all apps (motion, microphone and camera), like the hidden developer Sensors off tile that some manufacturers remove. | ISensorPrivacyManager.setSensorPrivacy(true) via app_process |
⟲ |
Hide developer options sits with Shut Up under Developer options in the tab: it hides them from every app at once, Shut Up only from the apps you choose.
All sensors off has no settings key, so TinyKit runs a small helper class from its own APK
(Sensors, started with app_process as the shell user) that calls the system's sensor
privacy service directly. See Architecture.
Each item is a switch. Blocked stops the service, and turning the switch off restores it. Items that don't apply to your phone are greyed out with Not on this phone.
| Item | What it does |
|---|---|
| User Experience Programme (Huawei) | settings put secure user_experience_involved 0 and hw_app_analytics_state 0 |
| Diagnostics & telemetry (Huawei) | Disables (pm disable-user) installed packages whose names match com.huawei.hiview, hiviewtunnel, huawei.android.chr, hwdetectrepair, hwdiagnosis, recsys or huawei.magazine |
| HiCloud (Huawei) | Disables packages matching hicloud |
| Limit ad personalisation (Google) | settings put secure limit_ad_tracking 1 |
Important
Any package containing hwid is always skipped, so your Huawei ID sign-in is never
touched.
Pick apps and cut them off Wi-Fi and mobile data. Needs Android 14 or newer.
TinyKit sets the rule once, through Android's own per-app firewall (the same kernel-level rule
Data Saver and Battery Saver use), and then does nothing. There's no VPN and no background work by
default: Android enforces the block in the network stack, so it holds even when TinyKit
is closed or Shizuku is stopped, and it costs no memory or CPU. The rule uses one of Android's
OEM_DENY firewall chains, which no system feature uses, and leaves Doze and Data Saver alone.
- Changes take effect at once. Apps that were connected lose their connection.
- It blocks every network at the same time; Android has no per-app switch for Wi-Fi only or mobile data only.
- Android clears these rules when the phone restarts. TinyKit keeps your choices and puts them back by itself as soon as Shizuku is running again, without you opening TinyKit (see After a restart).
- Apps from one developer can share an ID and are blocked together. TinyKit tells you which.
- Parts of Android itself (shared system ID) can't be blocked on their own, which protects you from cutting off the system by accident.
Allow list mode flips it round: every app is blocked except the ones you allow, including system apps such as Google Play services (allow it if you want push notifications). TinyKit itself always stays online. Apps you install later are blocked the moment they're installed, without opening TinyKit, if you turn on Run in the background (Info tab, or the same switch on this page). Android only tells a running process about an install, so that switch keeps a quiet notification and a small service running; it is off by default, and with it off, new apps are blocked the next time you open TinyKit. A reinstalled app that was blocked gets its block back too. If Shizuku is off at that moment, TinyKit blocks the app as soon as Shizuku is running again. Unblock all apps clears everything and turns the mode off.
Pause blocking (this page, or the Internet block quick tile) lets every app online for now and keeps your lists, so you can switch the block off and on without setting it up again.
The whole choice is applied in one start of the helper, so switching modes with hundreds of apps takes a moment, not minutes. The user IDs come from Android's package list directly, with no shell command.
# what the helper calls (as the shell user, via app_process)
IConnectivityManager.setUidFirewallRule(FIREWALL_CHAIN_OEM_DENY_3, uid, DENY)The per-app version of Hide developer options. Pick the apps, and while one of them is on screen TinyKit turns Developer options, USB debugging and Wireless debugging off, then turns back on whatever was on the moment you leave the app (or turn the screen off).
- Android can't hide a setting from one app only, so while a chosen app is open every app sees them off.
- One tap: turning Shut Up on also turns on Run in the background (Info tab), which it needs. A small foreground service with a quiet notification then checks which app is open a couple of times a second, only while the screen is on. With the screen off it puts everything back and sleeps until the screen comes on, with no timer and no wake-ups. If you later turn Run in the background off, Shut Up pauses and everything is put back; its page says so, and one tap there turns it back on.
- What was on is written down before anything changes, so a crash, a restart or turning Shut Up
off always puts it back. TinyKit restores through its own
WRITE_SECURE_SETTINGS, so this works even if Shizuku stopped. It needs Shizuku once, to grant that and usage access. - Stop Shizuku while they're open (on by default): some apps notice Shizuku running. TinyKit stops it while a chosen app is open and starts it again about 15 seconds after you leave. It only does this when it can start Shizuku by itself: a Shizuku fork with start and stop intents and the auth token saved in TinyKit, or Termux with shizuku-termux. With the standard Shizuku app alone it leaves Shizuku running, because nothing could bring it back. Turning USB or Wireless debugging off can also end a Shizuku started through adb, so TinyKit starts it again after that too.
- An app that checks in its first moments, before TinyKit notices it, or that remembers an earlier check, can still see them. Turning USB debugging off ends an ADB session for a moment.
Finds the ad and analytics libraries inside your apps (Google Analytics, Google Ads, AppLovin, Facebook, AppsFlyer, Adjust and about 50 more), most first. TinyKit reads each app's declared parts (activities, services, receivers, providers) and matches their class names against a list of known libraries, so it shows what an app carries, not proof that it uses it. Tap an app to see the libraries, and on Android 14+ to cut it off the internet with Block internet.
Note
TinyKit can't switch these parts off one by one. Android refuses it from the shell
(Shell cannot change component state), so blocking the app's internet is what works.
Which apps recently used the camera, microphone, location, contacts or clipboard, and when,
newest first. TinyKit parses dumpsys appops, so it's best-effort and varies a little between
phones.
Checked apps can't read what you copy, even while they're open. Android already stops apps from reading the clipboard in the background, so this closes the rest. Don't check your keyboard, or its paste suggestions stop working. ♻️
appops set <pkg> READ_CLIPBOARD ignore # unchecking sets it back to defaultLists every saved network with its security type and password, with search. Tap a network to see a QR code that any phone camera can scan to join, and a Copy password button.
Android only lets privileged callers read saved Wi-Fi credentials. TinyKit runs a helper class
(WifiDump) as the shell user that calls IWifiManager.getPrivilegedConfiguredNetworks. The
QR code is generated on the device by TinyKit's own encoder (Qr.java), so no library and no
network are involved.
App lists open instantly (the installed-app list is preloaded at launch), and have search, a Show system apps checkbox and a Sort chip. In multi-select lists, checked apps stay on top.
Set every sensitive permission and hidden app-op per app. Fake shows the app the permission as granted while it gets nothing. This is TinyKit's flagship feature, with its own guide: Fake permissions →
Roles: launcher, browser, phone, SMS and assistant. Shows the current holder and lets you pick a new one.
cmd role add-role-holder android.app.role.BROWSER <pkg>To read the current holder, TinyKit tries cmd role get-role-holders first and falls back to
dumpsys role on EMUI.
File types: PDF, images, video, audio, plain text, HTML, ZIP, EPUB, Word, Excel, Markdown
and CSV. Shows the current default (cmd package resolve-activity) and every app that can open
that type. Android only lets the system pin a file-type default, so set one by opening a file and
choosing Always.
Checked apps are disabled. They disappear from the launcher and can't run until you uncheck them. ♻️
pm disable-user --user 0 <pkg> # hide
pm enable <pkg> # show againOn EMUI, disabling is the only method that reliably hides an app.
Launchable apps sorted from longest unused, with Last opened 3 months ago or Never opened.
Uses UsageStatsManager over the last year. Tap an app to open its system settings, where you
can uninstall it.
App, data and cache size for every installed app (StorageStatsManager), largest first, with a
total. Tap an app to open its settings.
Tap an app to choose:
| Action | Command | Effect |
|---|---|---|
| Let it play with others | appops set <pkg> TAKE_AUDIO_FOCUS ignore |
The app no longer pauses other audio. Play music and a video together, or keep a podcast going during a game. |
| Mute audio | appops set <pkg> PLAY_AUDIO deny |
The app is silent. |
Android's audio system enforces both, so nothing runs in the background. ♻️
Everything running, with its memory use (from dumpsys meminfo), sorted by memory or name, and
a used/total RAM summary. Tap an app to stop it (am force-stop). Persistent system processes
can't be stopped and are labelled as such.
Checked apps are restricted the same way as in Settings → Battery → Restricted: no background work, alarms or wake locks until you open them, and Android moves them to its lowest standby priority:
am set-standby-bucket <pkg> restricted # Android 9+; unchecking sets it back to active
appops set <pkg> RUN_ANY_IN_BACKGROUND ignore
appops set <pkg> WAKE_LOCK ignoreNotifications from checked apps may arrive late, so leave messengers unchecked. Android never restricts some system components, so a checked system app may keep its standby priority. ♻️
The opposite: checked apps are exempt from battery optimisation and background limits, so Android won't kill them or delay their notifications. This is useful for Termux, messengers and Shizuku itself. ♻️
dumpsys deviceidle whitelist +<pkg>
appops set <pkg> RUN_ANY_IN_BACKGROUND allow
appops set <pkg> WAKE_LOCK allowNote
The Debloater needs Android 8 or newer: Android 7 has no pm install-existing, so a removed app
could not be restored. Special access hides All files access below Android 11.
Removes apps your phone came with, for your user only, and shows a safety rating for each one the way Canta does:
| Rating | Meaning |
|---|---|
| Recommended | Safe to remove; nothing else depends on it. |
| Advanced | May switch off a feature you use. |
| Expert | Other things depend on it; only if you know what it does. |
| Unsafe | Android needs it. These can't be selected. |
- Search, filter by rating and tick as many apps as you like, then tap Remove. Hold an app to read what it is.
- Apps in use right now (your home screen, keyboard, phone and messages apps, the web view, TinyKit and Shizuku) are always locked.
- Removed apps lists what you removed. Tick and Restore to bring them back with their data. Nothing is deleted from the system, and a factory reset restores everything.
- The ratings come from a short list built into TinyKit. Apps it doesn't know get a cautious default, so read the name before removing one.
pm uninstall -k --user 0 <pkg> # remove (the second pass drops an updated system app)
pm install-existing --user 0 <pkg> # restoreThe permissions Android hides on separate screens: Install unknown apps, Draw over other apps, Modify system settings, All files access and Usage access. Pick one to see only the apps that ask for it, then allow or take it away.
appops set <pkg> REQUEST_INSTALL_PACKAGES allow # unchecking sets it back to defaultGives any app its own language (Android 13 and newer). Pick an app, then a language; the list is the languages Android itself ships. It only takes effect for languages the app has.
cmd locale set-app-locales <pkg> --user 0 --locales fr-FR # no --locales = system defaultAndroid has no command for a dark mode per app, so there isn't one. Force dark on all apps covers every app at once.
Many apps split their notifications into channels, such as "Messages", "Promotions" and "Reminders". Pick an app, then untick a channel to block just that kind. The row under it says how loud it is (Blocked, Silent, Sound, Sound and pop-up). Ticking it again restores the loudness it had before. Android 8 and newer. Some system channels can't be blocked and stay as they were.
It starts a small program (Channels) with app_process as the shell user, which asks Android's
notification service for the app's channels and changes one channel's importance. The change
lasts until you change it back.
Lists the apps TinyKit's installer put on, newest first, with when and how big. Tap one to open
or remove it. TinyKit stores nothing for this: the installer marks itself as the app's
installer, and the list is read back from Android's own records (pm install-create -i). Apps
installed before this feature, or by other installers, aren't listed. TinyKit doesn't keep a
copy of the file, so removing an app can't be undone with an older version.
Installs .apk files, and apps that come in several parts: .apks, .xapk, .apkm, or
several .apk files picked together in the file picker. It uses Android's own package
installer through Shizuku, so there's no per-install "Install unknown apps" prompt.
- Streams, doesn't unpack. Each part is piped into the install session straight from the file, so a big game isn't copied or extracted first. (A file that can't be opened in place, such as one on cloud storage, is copied to the cache once and deleted afterwards.)
- Installs only what this phone needs: the base, feature splits, the processor splits that match your phone, your screen density and your languages.
- Game data.
.xapkfiles withAndroid/obb/<package>/*.obbget it copied toAndroid/obb/<package>. - Updates over an installed app with the same signing key. Android won't install an older version over a newer one, or an app signed with a different key; TinyKit says so in plain words and what to do.
- Old apps that Android 14 would normally refuse (built for Android 5 and older) are allowed.
pm install-create -r -i io.github.order52.tinykit -S <bytes> # one session; -i marks TinyKit as the installer
pm install-write -S <bytes> <id> pN.apk - # each part, from stdin
pm install-commit <id>Under Install APK files in the Apps tab. These apply to every install until you change them:
| Option | pm flag | What it does |
|---|---|---|
| Allow downgrade | -d |
Install an older version over a newer one |
| Grant all permissions | -g |
Allow every permission the app asks for as it installs |
| Allow test-only apps | -t |
Install apps built as test-only |
All are off by default.
Copies any app's APK to Download/TinyKit/<App>-<version>.apk. Split APKs (App Bundles) are
copied into a folder, and all the files in it must be installed together, for example with SAI
or adb install-multiple.
| Setting | What it does | |
|---|---|---|
| Force dark on all apps | Turns on Android's built-in force-dark for apps that have no dark mode. Each app picks it up when it's next opened. Uses setprop debug.hwui.force_dark true, plus the OEM keys op_force_dark_entire_world and aosp_force_dark_mode where they exist. Android forgets the property at a restart, so TinyKit sets it again once Shizuku is running. |
⟲ |
| Disable HW overlays | Makes the display compose everything with the GPU instead of its hardware overlay layers, the same as the developer option of that name. Some phones need it to fix flicker, tearing or colour problems. Uses service call SurfaceFlinger 1008 i32 1 (0 to turn it off). Android forgets it at a restart, so TinyKit sets it again once Shizuku is running. |
⟲ |
| Animation speed | Off, 0.5×, 1×, 1.5× or 2×. Sets window_animation_scale, transition_animation_scale and animator_duration_scale together. |
♻️ |
Edit quick panel is a visual editor for the system's Quick Settings panel, laid out like the real thing: round tiles on EMUI, wide tiles on stock Android 12+, with pages.
- Drag a tile to move it (hold it over a page arrow to turn the page), or tap two tiles to swap them. A picked tile also gets Earlier, Later and Remove buttons.
- Add: every tile not already in your panel, including built-in tiles, TinyKit's tiles and other apps' tiles. Tap one to add it to the end.
- Restore original layout puts back the panel exactly as it was before you first used the editor.
- Every change is written to the
sysui_qs_tilessecure setting, which SystemUI applies immediately. If a write fails, the previous order comes back. Phones that don't allow this say so.
TinyKit tiles lists all 16 of TinyKit's tiles with an Add button each. See Quick Settings tiles.
Run a command runs any shell command as the shell user and shows its output and exit
code. It's handy for checking what TinyKit did:
appops get <pkg>
settings list global
getprop ro.product.modelRecover deleted files searches every recycle bin and trash folder on shared storage in a
single find pass:
| Location | Source |
|---|---|
*/.Gallery2/recycle/* |
Huawei Gallery's recycle bin. File names are decoded from Base32 metadata back to the real name. |
*/.File_Recycle/* |
Huawei Files' recycle bin |
*/.fvTrash/* |
Other gallery and file manager trash |
.trashed-* |
Android 11+'s MediaStore trash |
*/.thumbnails/* |
Thumbnail caches. These often hold a small copy of photos that are long gone. |
*/LOST.DIR/* |
Fragments recovered by a file system check |
Results show thumbnails (decoded through Shizuku, since apps can't open trash folders
directly) and can be sorted by size, date or name. Tapping Restore copies the file to
Download/TinyKit/Recovered, and the original stays in the bin.
Settings backup & restore saves every global, secure and system setting to
Download/TinyKit/settings-<date>.txt (settings list). Restore lists your backups,
newest first, and writes each key back with settings put. Read-only keys are skipped, and
some changes need a restart.
Caution
Restoring a backup from a different phone or Android version can apply settings that don't suit it. Restore on the device the backup was made on.
Back up TinyKit setup saves what you chose inside TinyKit to
Download/TinyKit/setup-<date>.txt: the internet block (both lists and the mode), the clipboard
guard, stopped background apps, kept-alive apps, hidden apps, the special access you allowed,
Force dark and the system apps you removed. Restore TinyKit setup puts all of it back, which
is handy after a factory reset or on a new install. Apps that aren't installed any more are
skipped. The file holds only package names, one per line.
Android keeps nearly everything TinyKit changes (app-ops, hidden and removed apps, settings) across a restart. Three things it forgets: the internet block, Force dark and Disable HW overlays. TinyKit puts all three back by itself the moment Shizuku is running again:
- Shizuku starts, and as it comes up it starts the processes of the apps that use it.
- TinyKit's process notices Shizuku's connection (
TinyKitApp), and once per boot re-applies the block in a single call and turns Force dark and Disable HW overlays back on. - It then goes idle like any other cached app. Nothing polls, no service stays running, and nothing happens until Shizuku starts again.
You never have to open TinyKit for this. If Shizuku isn't running, the block stays off, because nothing without Shizuku can set it.
Advanced reboot offers four modes, each confirmed first:
| Option | Command |
|---|---|
| Reboot | svc power reboot |
| Reboot to recovery | svc power reboot recovery |
| Reboot to bootloader | svc power reboot bootloader |
| Soft reboot | svc power reboot userspace. This restarts Android without restarting the kernel (Android 11+; older versions do a normal reboot). |
| Action | Command | Notes |
|---|---|---|
| Speed up phone | pm trim-caches 999G, am kill-all, cmd activity send-trim-memory, cmd activity compact system, sm fstrim, and sm idle-maint run once a day |
Deletes every app's cache, closes cached apps, frees and compacts memory, trims storage. Works without Shizuku on Android 13 and older (closes cached apps only). |
| Clear all app caches | pm trim-caches 999G |
Reports how much space came back |
| Optimize apps | cmd package bg-dexopt-job |
Compiles apps ahead of time so they open faster. Runs for about 10 minutes and keeps going if you close TinyKit. |
| Trim storage | sm fstrim; sm idle-maint run |
Storage maintenance and TRIM |
Speed up phone is one tap. Every press does all of this:
- Deletes every app's cache (
pm trim-caches). The commands themselves use a little memory, so this runs first. - Closes every cached app: apps you left a while ago that Android keeps around. The app on screen, music, navigation, anything showing a notification and anything running a service are never touched.
- Frees memory: asks every running app to release what it can rebuild
(
TRIM_MEMORY_MODERATEto background apps,TRIM_MEMORY_RUNNING_LOWto apps in use), then has Android compact RAM (Android 11+). SystemUI is left alone. - Trims storage (
sm fstrim) and, once a day, starts Android's idle maintenance.
The result says what was done, for example "Done: trimmed and compacted memory, deleted 412 MB of cache, closed 9 cached apps, started storage maintenance. 2.3 GB memory free now (+640 MB)." Closed apps open normally next time, just without their last screen, and they rebuild their caches as you use them.
Without Shizuku, on Android 13 and older, TinyKit can close cached apps with the regular
killBackgroundProcesses API. Android 14 limited that API to an app's own processes, so on
Android 14 and newer the row shows Requires Shizuku.
Speed-up widget puts Speed up phone on your home screen. One tap runs all of it without opening TinyKit, and the widget then shows how much memory is free. Tap Speed-up widget in this section to place it (Android 8+), or add it from your launcher's widget list. The widget never updates on its own and runs nothing until you tap it.
| Toggle | What it does | Command |
|---|---|---|
| Free hotspot | Hotspot uses your normal data connection instead of a separate "tethering" APN, so carriers that block or meter tethering can't tell. Works on many carriers. | settings put global tether_dun_required 0 (off: settings delete …) |
| Mobile data off on Wi-Fi | Doesn't keep mobile data connected while on Wi-Fi. Saves battery. | settings put global mobile_data_always_on 0 |
| Page | Shows |
|---|---|
| Phone info 🔓 | Battery charge, health, temperature, voltage, current, design and learned capacity, charge cycles; RAM and storage; model, Android version, security patch, build, kernel, processor and ABIs, uptime |
| Network info 🔓 📶 | Connection type and speed; SSID, signal, link speed and band; interface, IP addresses, gateway, DNS servers, Private DNS; Open router settings (opens http://<gateway>); public IP |
| Charging info 🔓 | Status, power source, charge, health, voltage, current, watts, temperature, technology, capacity |
| Temperatures 🔓 | Every thermal zone in /sys/class/thermal, plus the battery |
| Device IDs 🔓 | Android ID, serial number, Wi-Fi MAC, build fingerprint, bootloader, baseband. For the IMEI, TinyKit tells you to dial *#06#. |
Local network details appear instantly. Only the public IP is fetched, from api.ipify.org
with ifconfig.me as a fallback, and only while you have the page open.
| Page | Source | Shows |
|---|---|---|
| Screen time | Android's usage history | How long each app was on screen today, yesterday or in the last 7 days, and how often you opened it. Uses the totals Android already keeps, so TinyKit measures nothing itself |
| Battery usage | dumpsys batterystats --charged |
Estimated mAh per app and component since the last full charge, highest first |
| Wake-ups | dumpsys batterystats --charged |
Partial wake locks: which app held one, for how long and how often |
| Vibration log | dumpsys vibrator_manager |
Recent vibrations: which app, what kind and when |
| App log | logcat --pid |
Up to 500 lines of one app's recent log output. Huawei hides most app logs. |
| Crash log | logcat -b crash |
Every crash since boot, with stack traces. Clear empties the log. |
The first row of the TinyKit section, the one switch for everything TinyKit may keep running. Off (the default): TinyKit never runs by itself. On: one small foreground service with a quiet notification runs, but only while a tool needs it: Shut Up, or watching installs while an internet block or a permission choice is set up (so a new app is blocked at once, and Fake comes back after an app update). The line under the switch says what it is running for right now. The same switch is on the Block internet per app page, and turning Shut Up on turns it on too.
Report a problem opens a new GitHub issue in your browser with TinyKit's version, your phone model, your Android version, whether Shizuku was running, and TinyKit's own recent log lines filled in. You can read and edit it, and nothing is sent until you press Submit on GitHub.
When TinyKit crashes, it saves the error privately and (where notifications are allowed) shows a notification. The next time you open TinyKit it asks if you want to send it, which opens the same pre-filled issue. Not now deletes it. Offer to report crashes turns all of this off. See Crash reports.
After TinyKit updates, a popup lists what changed (every version since the one you last opened, newest first). It shows once per update, never on a fresh install. What's new in the Info tab shows the current version's notes again. The notes ship inside the app, so nothing is downloaded.
Asks the GitHub API for the latest TinyKit release when you tap it, and offers the APK download if there's a newer version.
Check for updates on start (TinyKit asks once, the first time you open it, and you can change it here any time) does the same check each time you open TinyKit, at most once an hour, and shows an "Update available" popup when a new version is out. You get one popup per version, never repeats. No notification permission is needed. Nothing checks while TinyKit is closed.
Version, author, licence and a link to the source code.
| Path | What | Written by |
|---|---|---|
Download/TinyKit/<App>-<version>.apk |
APK backups | Back up app as APK |
Download/TinyKit/settings-<date>.txt |
Settings backups | Settings backup & restore |
Download/TinyKit/setup-<date>.txt |
TinyKit setup backups | Settings backup & restore |
Download/TinyKit/Recovered/ |
Restored files | Recover deleted files |
Pictures/Screenshots/Screenshot_<date>_TinyKit.png |
Screenshots | Screenshot tile |
Movies/Screen_<date>_TinyKit.mp4 |
Recordings | Screen record tile |
App-private files/last_crash.txt |
The last crash, kept until you send or dismiss it (never kept if Offer to report crashes is off) | Crash reports |
App-private shared_prefs/tinykit.xml |
Preferences: last tab, auth token, previous DNS, filters, the internet block lists, Force dark, Disable HW overlays | Everything |
TinyKit sets allowBackup="false", so its private files are never copied off the device by
Android's backup.