# OpenTasker [](https://github.com/SysAdminDoc/OpenTasker/releases) [](LICENSE) [](https://developer.android.com) [](https://kotlinlang.org) [](https://apps.obtainium.imranr.dev/redirect?r=obtainium://app/%7B%22id%22%3A%22com.opentasker.app%22%2C%22url%22%3A%22https%3A%2F%2Fgithub.com%2FSysAdminDoc%2FOpenTasker%22%2C%22author%22%3A%22SysAdminDoc%22%2C%22name%22%3A%22OpenTasker%22%7D)
If OpenTasker runs useful automations for you, a coffee helps me keep building and testing it.
**OpenTasker** is a fully open-source, on-device, FOSS alternative to [Tasker](https://tasker.joaoapps.com/) for Android. It doesn't use an accessibility service, so Android's [Advanced Protection limit on accessibility services](https://support.google.com/android/answer/16339980) doesn't touch it. --- ## Screenshots | Profiles | Tasks | Run Log | |---|---|---| |  |  |  | | Flow | Setup | Settings | |---|---|---| |  |  |  | ## Features ### Automation engine - **Encrypted automation database**. SQLCipher encrypts the complete Room file at rest with a random key wrapped by Android Keystore. Existing plaintext databases migrate once before Room opens, and wrong-key opens fail closed - **Profiles, contexts, tasks, actions**. A complete Room-backed automation pipeline with a Compose UI - **Companion presence triggers**. User-confirmed CompanionDeviceManager associations emit low-power present/absent events without a scanning loop, with setup-time revocation - **7 context families**. Application, Time, Day, Location, State, Event, and Plugin (Locale/Tasker condition) - **99 built-in actions** plus engine-handled flow control (`task.run` with named inputs, `task.stop`, `if`/`else`/`end if`, `for each`/`end for`, `try`/`catch`/`end try`, `stop`, `go to` and `anchor`) - **USB device contexts**. Attach/detach event pulses expose bounded device, vendor, product, and class fields for local input-device automations - **Template expressions**. Bounded `{{ ... }}` expansion with scoped variables, arrays, JSON paths, string/math/date functions, traces, and strict regex policy - **Side-effect-free preflight reviews**. Preview a task or profile with synthetic event variables, expanded inputs, branch decisions, setup gaps, intended effects, and explicit blockers before any action runs - **Trigger simulation**. From a profile editor or Context Inspector, pin family-specific synthetic events and see each predicate, context expression, cooldown, and admission result without writing a production run-log row or running the task - **Automation lint**. Profile saves, imports, the flow graph, and Context Inspector surface missing reversals, repeated state triggers, conflicting writers, and inter-profile loops with concrete fixes - **Profile lifecycle policy**. Assign deterministic priority, symmetric activation grace, and never/date/once lifetimes. The Inspector explains expiry and priority suppression, while bundles and Tasker mappings preserve safe defaults - **Profile execution admission**. Optionally bound active and burst starts per profile, choose replayable logged holds or silent skips on overflow, and inspect rejection counts and circuit-breaker state in Diagnostics - **Failure recovery**. Route unhandled failures to an optional per-profile or global fallback task. The fallback receives bounded structured error variables and cannot recurse into another fallback - **First-class secret variables**. AES-256-GCM Android Keystore storage, deliberate reveal/re-entry UX, and provenance-based redaction for derived action arguments, logs, traces, and failures - **One redaction boundary for stored arguments**. Credential-bearing action arguments (HTTP authorization/headers/query/body, request payloads, script stdin, SMS text) are masked wherever they are displayed, including the task list, flow graph, and previews, so they cannot leak through a screenshot or accessibility semantics. Unregistered actions and unknown keys fail closed - **Coherent execution controls**. Per-profile single/restart/queued/parallel re-trigger behavior, followed by a global per-task abort-new/abort-existing/run-both/wait collision policy across profile, manual, nested, widget, notification, and external runs - **Action-level flow controls**. Atomic action reordering plus optional conditions and continue-after-failure behavior, with those semantics preserved through storage and bundle round trips - **Durable edit history**. Task, profile, and scene cards expose five-step undo/redo. Variable and project deletion offer snackbar Undo, including readable Keystore-backed secrets after a project restore - **Profile groups**. Organize profiles into named groups with filter chips - **Nested context logic**. Author backward-compatible ALL/ANY/NOT groups over profile contexts. The Inspector explains the evaluated tree - **Local projects**. Scope tasks, profiles, scenes, and variables behind a shared project boundary with explicit reassignment on deletion ### Triggers (contexts) - **Offline bundle import**. Paste exported JSON or decoded QR text into the existing disabled-by-default review flow with bounded input validation - **MacroDroid migration**. Import full `.mdr` backups, password-protected `.emdr` exports or single `.macro` shares into disabled profiles, with bounded decoding and an exact mapped, unsupported, and lossy review - Time/day schedules with presets, aliases, and ranges - Device state (battery, charging, headphones, screen, media playback, airplane, power save, Wi-Fi SSID, orientation, proximity, physical activity, speed, roaming, tethering, phone-call state, Bluetooth devices nearby, and Health Connect steps, heart rate, sleep and exercise). Sensor/GPS/phone callbacks are demand-gated per profile - App foreground detection via UsageStats, with optional exact/glob Activity component matching and explicit unavailable-component reporting - Wi-Fi and data/internet connectivity via NetworkCallback - Notification listener with package/title/body filters. A matching notification hands the task `{{ event.notification_package }}`, `{{ event.notification_title }}` and `{{ event.notification_body }}` - Incoming calls while the phone rings. A task reads `{{ event.incoming_number }}` and `{{ event.incoming_known_contact }}`, and a profile can ask for strangers only or a part of the number - NFC tag scans with normalized ID matching and a one-time NDEF write helper - Calendar windows with redacted event metadata - Sunrise/sunset filters with coordinate, offset, and window support - Shake, Bluetooth connect/disconnect and Android 16 bond-loss/encryption security events, Android 16 Advanced Protection transitions, sanitized SMS/MMS receipt on standard/F-Droid builds, package install/remove/replace - Bluetooth all-devices-disconnected transition with an editor preset and multi-device tracking - Android 15+ screen-recording visibility trigger. `event=screen_recording` reacts to whether this app is visible in a recording without capturing screen contents - SMS/MMS-received trigger. `event=sms_received` exposes sanitized sender/body metadata on standard/F-Droid builds and hands the task `{{ event.sms_sender }}`, `{{ event.sms_body }}`, `{{ event.sms_kind }}`, `{{ event.sms_message_count }}` and `{{ event.sms_subscription_id }}`, so an HTTP Request can forward a message while the run log shows a placeholder. Android 17 may delay standard OTP SMS delivery for up to three hours outside exempt apps - Received-broadcast trigger. `event=broadcast` fires when another app or `adb shell am broadcast` sends an intent action you name. Only the actions your enabled profiles declare are ever registered, at most 16 of them, and the receiver re-checks the action on delivery. Extras arrive as bounded strings: text, numbers and booleans only, capped at 16 keys and 512 characters each, with anything oversized or Parcelable dropped and flagged in `broadcast_extras_lossy` rather than truncated. Tasks get `broadcast_action`, `broadcast_sender`, `broadcast_extra_count` and one `broadcast_extra_*` per surviving extra. Android names the sender only when the sending app opts in to sharing its identity, which most apps and adb do not, so `broadcast_sender` is usually empty and a sender filter refuses what it cannot identify - Quick Settings tile tap, home-screen widget/shortcut, boot - Authenticated `event=push` bridge for a de-googled UnifiedPush distributor. Delivery IDs are deduplicated, payloads are bounded, and message content is redacted before matching/logging - Received Share (`ACTION_SEND`/`SEND_MULTIPLE`) trigger for bounded text, URLs, single files, and multiple files, with MIME/text/URI filters and `share_*` task variables - FOSS platform location/geofence. GPS/network fixes, balanced provider cadence, radius/accuracy/dwell evaluation, persisted dwell state, and API 36 background delivery evidence - Locale/Tasker condition plugins, polled as first-class context predicates with last-known-state caching, and asked again early when a plugin says its answer changed - Home Assistant bridge proof of concept, with bounded outbound JSON webhooks, HTTPS by default, redacted webhook secrets and retries with backoff ### Actions (99 registered + 13 engine-handled) | Category | Count | Examples | |----------|------:|---------| | Settings | 21 | Wi-Fi, Wi-Fi scan, Bluetooth, brightness, volume, airplane, mobile data, Wi-Fi hotspot, always-on display, screen timeout, write setting, DND, Zen rule set/clear, ringer mode, torch, tile state, wallpaper, temporary state, keyboard info, keyboard picker | | App | 10 | launch intent, launch app, publish shortcut, kill, archive, unarchive, go home, open URL, SMS, screenshot | | File | 5 | read, write, append, delete, list | | Network | 9 | HTTP Request, Home Assistant webhook, MQTT publish, legacy GET/POST aliases, ping, download, Wake-on-LAN, WireGuard and Tailscale tunnels | | Media | 11 | play, beep, stop, pause, resume, play/pause, next, previous, rewind, fast forward, mute | | System | 7 | vibrate, clipboard set, reboot, lock, screen off, wake, log | | Notification | 4 | notify/toast, progress, cancel, TTS speak | | Variable | 24 | set variable, set several variables at once, variable clear (one, a pattern or all), clipboard get, contacts lookup, read data (JSON/CSV/XML/HTML), date-time (format/parse/add), text (match, replace or collect regex matches into an array, split, join, substring, length), Tasker's numbered arrays (variable split/join, array push/pop/clear/process), variable convert (sizes, units, dates, Base64, hashes and more), sunrise and sunset times | | Flow | 2+13 | wait, profile status; engine: task.run, task.stop, if/else/end if, for each/end for, try/catch/end try, stop, go to, anchor | | Plugin | 2 | Locale setting dispatch, Locale condition query | | Script | 2 | SHA-256-pinned Termux `RUN_COMMAND` and Shizuku shell scripts, both with bounded result capture | | Import | 2 | unsupported Tasker and MacroDroid action placeholders | Every action carries an explicit capability contract. An action with no reviewed contract resolves to unsupported rather than defaulting to available. Privileged actions (airplane, mobile data, always-on display, screenshot, reboot, screen off, kill app) are gated to fail honestly. Always-on display reads the setting back after writing it, so a build that accepts the write and ignores it reports a failure rather than a success. Set brightness and set screen timeout require the **Modify system settings** special access granted from Setup, and Wake-on-LAN requires local network access on Android 17+. Lock device needs the **Lock screen admin**, also turned on from Setup: Android only lets an app lock the screen through a device admin, and OpenTasker's asks for `force-lock` and nothing else, so it cannot wipe the device, set a password policy, or read anything. Turning it on means Android will not let you uninstall OpenTasker until you turn it back off, which the same Setup row does. No root, Shizuku, or accessibility service is involved, so it keeps working under Android 17 Advanced Protection. SMS is available in standard/F-Droid builds. Play builds omit SMS/phone-state permissions. New automations use **HTTP Request** for GET, HEAD, POST, PUT, PATCH, DELETE, and OPTIONS. It accepts structured query/header lines, inline or OpenTasker-file request bodies, per-stage timeouts, status/header/body variables, and atomic file output. Redirects default off and can be enabled only for the same origin. TLS verification cannot be disabled, cleartext remains private-LAN-only, and response/request sizes are bounded. Stored `http.get` and `http.post` actions continue to execute through compatibility aliases. Put credentials in Keystore-backed secret variables and reference them from Authorization or header fields so traces remain redacted. The **Intent Dispatch** action supports bounded activity, explicit broadcast, and explicit service delivery. It accepts allowlisted URI/MIME data, six activity/URI flags, capped string/int/bool extras, and optional ordered-broadcast result-code capture. Every configured data URI must carry an explicit `grant_read_uri` or `grant_write_uri` flag. External activity actions with arbitrary actions require a chosen component. Broadcasts and services always require one. `file://` URIs, parcelable/serialization-style extras, unknown flags, ambiguous targets, and non-exported external components fail closed. The **MQTT Publish** action uses a small in-app MQTT 3.1.1 QoS 0/1 client over platform sockets and TLS, so the F-Droid build adds no MQTT dependency. TLS is enabled by default, verifies the broker hostname, and sends SNI. Cleartext is restricted to private/local hosts and the Android 17 local-network grant. Payloads are capped at 64 KB, QoS 2 and wildcard publish topics are rejected, and username/password fields are redacted. The **Clipboard** actions read and write text without an extra permission, cap transfers at 64 KiB, and mark clipboard-derived values sensitive. **Contact lookup** supports bounded name/phone/email matching into sensitive variables. Android 17+ defaults to a field-scoped system picker with a timeout and no broad address-book grant. Explicit `READ_CONTACTS` permission mode remains available for unattended runs through Setup. **Quick Settings tiles** provide four app-owned slots. Long-press a tile to bind a task and configure its label, subtitle, icon, and state. `tile.set` can update a configured slot at runtime, and tile-triggered task runs use the same foreground execution and run-log identity as other external entry points. The **Temporary State** action applies a bounded reversible setting (brightness, volume, ringer mode, or DND) and restores the captured prior value through a unique persisted WorkManager job. Reusing the same revert key replaces the earlier timer, and pending work remains inspectable through WorkManager after process death. The **Keyboard** actions report the current/enabled IMEs into bounded variables. `ime.set` validates the requested component or package and opens Android's picker. Normal applications cannot silently select another keyboard, so it fails with an explicit user-selection message rather than pretending the switch happened. The **push trigger** uses the official distributor-neutral UnifiedPush connector. Setup can discover a distributor through `unifiedpush://link`, register/unregister the default instance, and retain the latest endpoint for inspection or copying. The connector chooses the SDK 34+ shared-identity registration path and the immutable `PendingIntent` fallback on older Android versions, decrypts RFC 8291 bytes messages, and acknowledges deliveries. OpenTasker consumes the standard ntfy JSON fields (`id`, `topic`, `title`, and `message`) as `event=push`. Payloads are bounded, duplicate topic/event-ID deliveries are suppressed for 30 seconds, and message content is redacted before event matching and logs. `VAPID_REQUIRED`, network, action-required, and internal failures remain visible in Setup. The legacy token-authenticated `com.opentasker.action.PUSH_EVENT` broadcast remains available for existing adapters. The **Received Share trigger** registers OpenTasker in Android's Sharesheet for text, URLs, MIME-typed content, and one or more file/content URIs. It sanitizes and bounds every value before matching, rejects arbitrary Parcelable or oversized extras, checks content-URI readability using the temporary grant without reading file contents, and shows an in-app error when access is missing. Matching share tasks receive `share_text`, `share_uri`, `share_uris`, `share_mime`, `share_count`, and `share_multiple` as run-scoped variables. Variable names follow Tasker's scope rule: an all-lowercase name is local to the current task, while any name containing an uppercase letter is global and durable. `var.persist` promotes an all-lowercase target to a global name, and the Variable vault applies the same normalization. Concurrent runs merge changes to different globals. If two stale snapshots change the same global, the first committed value is kept and the later conflict is recorded in the run log. ### Reliability and observability - OEM battery-killer detection with per-vendor remediation (Samsung, Xiaomi, OnePlus, Oppo, Realme, Vivo, Huawei, etc.) - Alarm-backed time/day reevaluation through Doze, with a persisted engine heartbeat and periodic WorkManager watchdog that re-arms dropped ticks and foreground-service timeout recovery - Setup checklist covering notifications, exact alarms, battery optimization, usage access, overlays, location, physical activity, Bluetooth, SMS, phone state, call log, DND, modify system settings, Health Connect, Shizuku, and Termux - Optional Android 16+ promoted ongoing notifications for active tasks, with standard foreground-notification fallback when promotion is unavailable or denied - Context inspector with live source health, latest values, per-profile match explanations, and Loading/Ready/Stale/Error observation status with age-aware reporting - Keyset-paged run logs with SQL-backed task/status/date/search filters, complete expandable action traces, redacted JSON/CSV export, per-step diagnostics and variable writes, reviewed retention reductions, held admission rows with safe manual replay, and user-pinned history - Live view of in-flight automations (task, origin, current step and elapsed time) with per-run cancellation that unwinds nested sub-tasks and records a terminal `Cancelled` outcome - In-app diagnostics for service/foreground-type/standby/exact-alarm/matcher/watchdog health, execution admission limits and circuit trips, a bounded process log, and captured crash previews. Shared reports include the same evidence with credential redaction - Scheduling diagnostics include API 36 pending-job reason history, API 37 aggregate pending durations, expanded WorkManager stop reasons, and plain-language standby delivery consequences with honest unsupported states - Crash log capture and local diagnostic export ### Interoperability - **Locale/Tasker plugin host**. Setting dispatch, condition queries, configuration parsing, request-query events, bundle validation, and last-known-state fallback. `Set up in the plugin` opens the plugin's own settings screen and saves what it returns. Bundle values keep their types, so a plugin that reads an int or a boolean gets one: plain JSON values are sent as strings, and a typed value looks like `{"int":3}`, `{"boolean":true}`, `{"long":5}`, `{"double":0.5}`, `{"stringArray":["a","b"]}` or `{"null":true}`. Variables fill in one value at a time, so a quote in one can't change the bundle around it, and a bundle that lists Tasker's `VARIABLE_REPLACE_KEYS` only gets those keys filled in - **Locale/Tasker condition plugin target**. Third-party hosts can configure OpenTasker profile-active, context-satisfied, and non-secret variable-comparison conditions. The exported ordered query receiver returns satisfied, unsatisfied, or unknown with bounded, typed bundles - **Locale/Tasker condition context**. Condition plugins as first-class profile predicates polled every 30 seconds, with the blurb their setup saved. A plugin that sends a query request is asked again as soon as any check already under way is done, instead of at the next poll - **External automation target**. Signature-scoped intents to run tasks, toggle profiles, query status, and pass variables. Task runs are asynchronous (protocol v2): the receiver validates and enqueues, then returns an execution ID that callers poll with `QUERY_EXECUTION`, because a broadcast cannot stay open for a task that may wait minutes. Callers must send `PROTOCOL_VERSION=2`. See [docs/EXTERNAL_INTENTS.md](docs/EXTERNAL_INTENTS.md) - **Home Assistant / ntfy interoperability**. The Home Assistant webhook action accepts the Companion `message`/`data` envelope, including documented `command_*` values such as `command_broadcast_intent`. The push bridge accepts ntfy's `id`, `topic`, `title`, `time`, `tags`, `priority`, and other bounded metadata names. An ntfy `broadcast` action can target `com.opentasker.action.PUSH_EVENT` directly with the per-install token and needs no relay app. Message bodies and remote URLs stay out of event metadata and logs. - **OpenTasker JSON bundles**. Schema-versioned export/import with deterministic legacy migrations, project membership preservation, computed action-power manifests, data-to-external-chain warnings, explicit keep/rename/replace review for variable-name conflicts, disabled-by-default installation, explicit first-enable acknowledgement, and secret values omitted by design - **Tasker XML import/export**. Preview with migration/capability warnings, deterministic mapped/unsupported/lossy reporting, and safe batches for notification, variable, media, settings, and flow actions. Tasker plugin steps (AutoInput, Kustom and the like) come over as plugin steps with their typed settings - **MacroDroid JSON import**. Full `.mdr` backups, password-protected `.emdr` exports and single `.macro` shares use the same review gate, with safe trigger/action conversions, explicit placeholders, and disabled-by-default profiles - **Profile sharing**. Offline share manifests with editable local preview, screenshot attachments, safety findings, import-plan review, and GitHub Discussions submission text. Unverified shares stay blocked until the existing import review passes Untrusted imports are preflighted before object/DOM allocation. OpenTasker JSON is capped at 16 Mi characters, 250,000 lexical tokens, and depth 64. A MacroDroid source file gets 3 million tokens and depth 256 because a whole-app backup passes the ordinary limit at about 1.5 MB, and what it converts into still has to fit the ordinary limits. Tasker XML is capped at 4 Mi characters, 100,000 nodes, and depth 64. Every format shares decoded limits of 5,000 top-level entities, 20,000 actions, 10,000 contexts, 10,000 scene elements, and 8 MiB of aggregate UTF-8 string data. A named budget violation aborts before the Room transaction. ### UI and theming - True-black workspace surfaces now use a compact, information-first layout across Profiles, Tasks, Variables, Flow, Scenes, Inspector, Setup, Run Log, Diagnostics, and Settings - Five primary destinations stay visible in the bottom navigation, while advanced workspaces remain one tap away in More - Project scope, readiness, search, and primary creation actions have a consistent hierarchy on every main page - AMOLED-first Catppuccin Mocha (dark) and Latte (light) palettes, high contrast mode - Refined mobile shell with clearer primary navigation, bottom-bar contrast, and edge-to-edge system bar theming - Setup theme selector that announces its selected state, plus denser backup controls - Compact-safe profile, task, and run-log cards with horizontally safe status chips and filtered empty states - Variable vault, Flow, Scenes, and Inspector surfaces with summary metrics, clear status language, and polished empty states - Shared installed-app picker across application, notification, action, and Locale plugin editors, with label/package search, app icons, validated manual entry, and a latest-observed Inspector shortcut - Metadata-driven action forms with stable-value selectors, bounded number validation, task/app/file pickers, typed output variable chips for safe step chaining, localized parameter summaries, and forward-compatible preservation of unfamiliar imported arguments - Guided profile templates with variable slots and safety notes, including two that search an unknown caller's number on a site you pick (one on a notification button, one automatically) - Scene element editor with drag-to-move, resize handles, multi-select, alignment guides, scaled canvas previews, overlay launch, accessible image metadata, validated sliders, and tap/long-press task bindings - Flow graphs with zoom/pan canvas previews, edge routing, branch/subflow markers, node deep links, and picker-backed add commands - Profile and task search bars - One global search across profiles, tasks, actions, variables, and scenes, including named references, with live results and deep links into the matching editor or library surface - Saveable editor/dialog state across rotation and resize - Adaptive navigation rail at medium/expanded widths keeps every destination discoverable while compact windows retain the bottom navigation layout ### Distribution - F-Droid readiness profile with dependency-policy and metadata verification - Non-F-Droid builds can opt into a daily HTTPS-only GitHub release check from Setup. It sends no identifying data, stores only a newer-release link, and never downloads or installs updates. F-Droid builds omit this check because F-Droid supplies their updates. - Play distribution profile with SMS/phone-state manifest policy gate - Local release verification scripts for F-Droid metadata, readiness, and APK payload comparison - Environment-driven release signing kept outside the repository. F-Droid's own source build of the F-Droid distribution is unsigned, and each release also attaches that build signed with the release key, so F-Droid can ship this project's signature once its rebuild matches byte for byte - SQLite database backup/restore with WAL-safe validation and atomic staged restore, reviewed before staging (source, schema version, compatibility, entity counts) and cancellable afterwards. Encrypted `.otbackup` v2 exports use bounded-memory, independently authenticated 64 KiB frames while legacy v1 files remain restorable. Secret rows stay ciphertext and the device-bound Keystore key is never copied, so a restore on another device requires secret re-entry - APK payload comparison tool for reproducibility checks - SQLCipher native libraries are included in both standard and F-Droid source builds. The release gate audits their 16 KB page alignment and keeps the dependency checksum-pinned ### Power-user backends - Shizuku manager/service/permission status, a persisted default-on kill switch, and a fail-closed command allowlist. The eight elevated actions run through a separately bound AIDL user service and fail closed when Shizuku is absent, revoked, or stopped - Termux 0.109+ `RUN_COMMAND` integration with a user-managed SHA-256 allowlist, pre-run hash verification, timeouts, and bounded output variables - **Run Shizuku Script** runs your own shell script as the Android shell user, gated by its own SHA-256 allowlist and the same kill switch To run a Termux script, place it below `~/.termux/tasker/`, enable Termux's external-app access, and grant OpenTasker `RUN_COMMAND` permission from Setup. Add the script path and the expected 64-character SHA-256 under **Approved Termux scripts** in More > Settings. OpenTasker performs a hash preflight and rechecks inside the fixed execution wrapper before the script can run. A capture prefix such as `%script` writes bounded `%script_stdout`, `%script_stderr`, `%script_exit_code`, and original-length variables. Captured content is never written to the run log. To run a script through Shizuku, put it where the shell user can read it (`/data/local/tmp` or shared storage), add its path and SHA-256 under **Approved Shizuku scripts** in More > Settings, and point a **Run Shizuku Script** action at it. It runs with `/system/bin/sh` as the shell user, so it doesn't need `rish` inside it and a `#!` line is ignored. Scripts can be up to 64 KB, and an edited script refuses to run until you approve its new hash. The capture prefix works the same way as above. On Android 17 the original Shizuku app may not start, and it hasn't been updated since June 2025. The [thedjchi fork](https://github.com/thedjchi/Shizuku/releases/tag/v13.7.0-thedjchi) adds Android 17 support and keeps the same package name, so Setup finds it like the original. Its author calls v13.7.0 the last release for now, and its home screen shows server version 13.6 while About says 13.7.0. That's expected. Some phones turn wireless debugging off when they restart (people report it on Samsung's One UI 8.5), and Shizuku can't start until it's back on. OpenTasker can't turn wireless debugging on by itself, so after a reboot switch it on in Developer options and start Shizuku again. Setup says the same thing on Android 17 while Shizuku isn't running. ### Bluetooth devices nearby Add a state context with the **Bluetooth device nearby** preset and type the device's name or address. OpenTasker looks for it about once a minute, and it can take a few minutes after a device leaves for the context to turn off. Open the Inspector to see what's around and how each device names itself. A phone only shows up while it's advertising, and most change their address every few minutes. Pairing the phone once fixes that, because Android can then recognize it under its paired name. Anyone can give a device any name, so don't use this to unlock or disarm anything. ### Health Connect State contexts can compare four Health Connect readings: `health_steps` (steps since midnight), `health_heart_rate` (the newest reading from the last hour), `health_sleep_minutes` (minutes asleep in sleep sessions that ended in the last 24 hours) and `health_exercise_minutes` (since midnight). The presets cover the common ones, like 10,000 steps today. OpenTasker reads them in the background on a schedule, every 15 minutes by default, and **Check every (minutes)** on the context stretches that out to as much as a day. With several health contexts, the shortest schedule wins. Steps and exercise get one more read just after midnight, so they start over on time. Heart rate and sleep stay blank when there's nothing recent, so a comparison like `< 60` won't match on an empty reading. It only reads, and never asks for more than 30 days of history. Allow it under **Read Health Connect** in Setup, which asks for background reading along with the readings your profiles use. Android 14 and later have Health Connect built in. On Android 9 to 13 it's a separate app from Google, and Setup links to it. If Health Connect refuses a reading, the context stays off (an inverted one too) and the Inspector says which reading it won't share. ### VPN tunnels Android has no general way for one app to switch another app's VPN, but WireGuard and Tailscale both accept a request to. Install the **WireGuard off at home** or **Tailscale off at home** template to drop the VPN on your home Wi-Fi and bring it back when you leave, or use **Connect or Disconnect VPN** in your own tasks. WireGuard needs two things first: **WireGuard tunnel control** in Setup and `Allow remote control apps` in its own settings. The action fails with a reason if the VPN doesn't actually change. --- ## Architecture ``` AutomationService (foreground) ↓ ProfileMatcher (monitors context streams) ↓ ContextSources (app, time, state, event, location, plugin) ↓ TaskRunner (executes action list with flow control) ↓ ActionRegistry (built-ins + capability gates + Locale plugin dispatch) ↓ Room DB (persistent storage + StateFlow live queries) ``` No Hilt. Dependencies are wired by hand in `OpenTaskerApp_NoHilt`. MVVM with Compose, Room, coroutines, DataStore, and WorkManager. --- ## Install Releases come from this repository. **With [Obtainium](https://github.com/ImranR98/Obtainium)** (recommended, it tracks new releases for you): tap the Obtainium badge above on the device, or add `https://github.com/SysAdminDoc/OpenTasker` as a GitHub source. Default settings are correct, nothing needs configuring. **By hand:** download the APK attached to the [latest release](https://github.com/SysAdminDoc/OpenTasker/releases/latest) and install it. Since `v0.2.88` that file is named `OpenTasker-v